simon/ocaml-opentelemetry
1
0
Fork 0
mirror of https://github.com/ocaml-tracing/ocaml-opentelemetry.git synced 2026-03-07 18:37:56 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

tracer/logger/metrics_emitter now pair emitter and clock

Browse source 
- clock is needed because timestamps need to be provided now
- explicit types are good anyway
- have at least one helper to emit the signal with optional
tracer/logger/metrics_emitter
- easier logger with `log` and `logf`
This commit is contained in:
Simon Cruanes 2025-12-17 11:46:25 -05:00
parent ec584b4829
commit e2c4a4e680
No known key found for this signature in database
GPG key ID: EBFFF6F283F3A2B4
16 changed files with 145 additions and 124 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/client/self_trace.ml
View file

@ -2,7 +2,7 @@ open Common_
let enabled = Atomic.make false
let tracer = Atomic.make OTEL.Tracer.dynamic_forward_to_main_exporter
let tracer = Atomic.make OTEL.Tracer.dynamic_main
let[@inline] add_event (scope : OTEL.Span.t) ev = OTEL.Span.add_event scope ev
@ -15,7 +15,7 @@ let dummy_span_id = OTEL.Span_id.dummy
let with_ ?kind ?attrs name f =
if Atomic.get enabled then (
let tracer = Atomic.get tracer in
OTEL.Tracer.with_ tracer ?kind ?attrs name f
OTEL.Tracer.with_ ~tracer ?kind ?attrs name f
) else (
(* A new scope is needed here because it might be modified *)
let span : OTEL.Span.t =

13
src/core/metrics.ml
View file

@ -16,15 +16,15 @@ type t = Metrics.metric
let pp = Proto.Metrics.pp_metric
(** Number data point, as a float *)
let float ?start_time_unix_nano ?(now = Clock.now_main ()) ?(attrs = [])
let float ?start_time_unix_nano ?(attrs = []) ~(now : Timestamp_ns.t)
(d : float) : number_data_point =
let attributes = attrs |> List.map Key_value.conv in
make_number_data_point ?start_time_unix_nano ~time_unix_nano:now ~attributes
~value:(As_double d) ()
(** Number data point, as an int *)
let int ?start_time_unix_nano ?(now = Clock.now_main ()) ?(attrs = []) (i : int)
: number_data_point =
let int ?start_time_unix_nano ?(attrs = []) ~(now : Timestamp_ns.t) (i : int) :
number_data_point =
let attributes = attrs |> List.map Key_value.conv in
make_number_data_point ?start_time_unix_nano ~time_unix_nano:now ~attributes
~value:(As_int (Int64.of_int i))
@ -52,13 +52,14 @@ let sum ~name ?description ?unit_
(** Histogram data
@param count number of values in population (non negative)
@param sum sum of values in population (0 if count is 0)
@param now the timestamp for this data point
@param bucket_counts
count value of histogram for each bucket. Sum of the counts must be equal
to [count]. length must be [1+length explicit_bounds]
@param explicit_bounds strictly increasing list of bounds for the buckets *)
let histogram_data_point ?start_time_unix_nano ?(now = Clock.now_main ())
?(attrs = []) ?(exemplars = []) ?(explicit_bounds = []) ?sum ~bucket_counts
~count () : histogram_data_point =
let histogram_data_point ?start_time_unix_nano ?(attrs = []) ?(exemplars = [])
?(explicit_bounds = []) ?sum ~(now : Timestamp_ns.t) ~bucket_counts ~count
() : histogram_data_point =
let attributes = attrs |> List.map Key_value.conv in
make_histogram_data_point ?start_time_unix_nano ~time_unix_nano:now
~attributes ~exemplars ~bucket_counts ~explicit_bounds ~count ?sum ()

14
src/integrations/cohttp/opentelemetry_cohttp_lwt.ml
View file

@ -117,10 +117,10 @@ end = struct
in
{ req with headers }
let trace ?(tracer = Otel.Tracer.get_main ()) ?(attrs = []) callback conn req
let trace ?(tracer = Otel.Tracer.dynamic_main) ?(attrs = []) callback conn req
body =
let parent = get_trace_context ~from:`External req in
Otel_lwt.Tracer.with_ tracer "request" ~kind:Span_kind_server
Otel_lwt.Tracer.with_ ~tracer "request" ~kind:Span_kind_server
?trace_id:(Option.map Otel.Span.trace_id parent)
?parent
~attrs:(attrs @ attrs_of_request req)
@ -131,18 +131,18 @@ end = struct
Otel.Span.add_attrs span (attrs_of_response res);
Lwt.return (res, body))
let with_ ?(tracer = Otel.Tracer.get_main ()) ?trace_state ?attrs
let with_ ?(tracer = Otel.Tracer.dynamic_main) ?trace_state ?attrs
?(kind = Otel.Span.Span_kind_internal) ?links name req
(f : Request.t -> 'a Lwt.t) =
let span = get_trace_context ~from:`Internal req in
Otel_lwt.Tracer.with_ tracer ?trace_state ?attrs ~kind
Otel_lwt.Tracer.with_ ~tracer ?trace_state ?attrs ~kind
?trace_id:(Option.map Otel.Span.trace_id span) ?parent:span ?links name
(fun span ->
let req = set_trace_context span req in
f req)
end
let client ?(tracer = Otel.Tracer.get_main ()) ?(span : Otel.Span.t option)
let client ?(tracer = Otel.Tracer.dynamic_main) ?(span : Otel.Span.t option)
(module C : Cohttp_lwt.S.Client) =
let module Traced = struct
open Lwt.Syntax
@ -190,7 +190,7 @@ let client ?(tracer = Otel.Tracer.get_main ()) ?(span : Otel.Span.t option)
let call ?ctx ?headers ?body ?chunked meth (uri : Uri.t) :
(Response.t * Cohttp_lwt.Body.t) Lwt.t =
let trace_id, parent, attrs = context_for ~uri ~meth in
Otel_lwt.Tracer.with_ tracer "request" ~kind:Span_kind_client ?trace_id
Otel_lwt.Tracer.with_ ~tracer "request" ~kind:Span_kind_client ?trace_id
?parent ~attrs (fun span ->
let headers = add_traceparent span headers in
let* res, body = C.call ?ctx ~headers ?body ?chunked meth uri in
@ -217,7 +217,7 @@ let client ?(tracer = Otel.Tracer.get_main ()) ?(span : Otel.Span.t option)
let post_form ?ctx ?headers ~params uri =
let trace_id, parent, attrs = context_for ~uri ~meth:`POST in
Otel_lwt.Tracer.with_ tracer "request" ~kind:Span_kind_client ?trace_id
Otel_lwt.Tracer.with_ ~tracer "request" ~kind:Span_kind_client ?trace_id
?parent ~attrs (fun span ->
let headers = add_traceparent span headers in
let* res, body = C.post_form ?ctx ~headers ~params uri in

22
src/integrations/logs/opentelemetry_logs.ml
View file

@ -1,4 +1,4 @@
module Otel = Opentelemetry
module OTEL = Opentelemetry
(*****************************************************************************)
(* Prelude *)
@ -10,8 +10,8 @@ module Otel = Opentelemetry
(*****************************************************************************)
(* Levels *)
(*****************************************************************************)
(* Convert log level to Otel severity *)
let log_level_to_severity (level : Logs.level) : Otel.Log_record.severity =
(* Convert log level to OTEL severity *)
let log_level_to_severity (level : Logs.level) : OTEL.Log_record.severity =
match level with
| Logs.App -> Severity_number_info (* like info, but less severe *)
| Logs.Info -> Severity_number_info2
@ -34,18 +34,20 @@ let emit_telemetry do_emit = Logs.Tag.(empty |> add emit_telemetry_tag do_emit)
(*****************************************************************************)
(* Log a message to otel with some attrs *)
let log ?(logger = Otel.Logger.get_main ()) ?attrs
?(scope = Otel.Ambient_span.get ()) ~level msg =
let log ?(logger = OTEL.Logger.dynamic_main) ?attrs
?(scope = OTEL.Ambient_span.get ()) ~level msg =
let log_level = Logs.level_to_string (Some level) in
let span_id = Option.map Otel.Span.id scope in
let trace_id = Option.map Otel.Span.trace_id scope in
let span_id = Option.map OTEL.Span.id scope in
let trace_id = Option.map OTEL.Span.trace_id scope in
let severity = log_level_to_severity level in
let log =
Otel.Log_record.make_str ~severity ~log_level ?attrs ?trace_id ?span_id msg
let observed_time_unix_nano = OTEL.Clock.now logger.clock in
OTEL.Log_record.make_str ~observed_time_unix_nano ~severity ~log_level
?attrs ?trace_id ?span_id msg
in
(* Noop if no backend is set *)
(* TODO: be more explicit *)
Otel.Emitter.emit logger [ log ]
OTEL.Logger.emit1 logger log
let otel_reporter ?(attributes = []) () : Logs.reporter =
let report src level ~over k msgf =

4
src/lib/dune
View file

@ -18,8 +18,8 @@
(re_export opentelemetry.util)
(re_export opentelemetry.ambient-context)
(re_export opentelemetry.atomic)
(re_export hmap)
mtime
mtime.clock.os
pbrt
threads
hmap))
threads))

55
src/lib/logger.ml
View file

@ -6,26 +6,55 @@
open Opentelemetry_emitter
type t = Log_record.t Emitter.t
(** {2 Logger object} *)
let dummy : t = Emitter.dummy
type t = {
emit: Log_record.t Emitter.t;
clock: Clock.t;
}
let enabled = Emitter.enabled
let dummy : t = { emit = Emitter.dummy; clock = Clock.Main.dynamic_main }
let of_exporter (exp : Exporter.t) : t = exp.emit_logs
let[@inline] enabled (self : t) : bool = Emitter.enabled self.emit
let get_main () : t =
match Main_exporter.get () with
| None -> dummy
| Some e -> e.emit_logs
let of_exporter (exp : Exporter.t) : t =
{ emit = exp.emit_logs; clock = exp.clock }
let (emit [@deprecated "use an explicit Logger.t"]) =
let[@inline] emit1 (self : t) (l : Log_record.t) = Emitter.emit self.emit [ l ]
let (emit_main [@deprecated "use an explicit Logger.t"]) =
fun (logs : Log_record.t list) : unit ->
match Main_exporter.get () with
| None -> ()
| Some exp -> Exporter.send_logs exp logs
(** An emitter that uses the current {!Main_exporter} *)
let dynamic_forward_to_main_exporter : t =
Main_exporter.Util.dynamic_forward_to_main_exporter () ~get_emitter:(fun e ->
e.emit_logs)
(** An emitter that uses the current {!Main_exporter}'s logger *)
let dynamic_main : t =
of_exporter Main_exporter.dynamic_forward_to_main_exporter
(** {2 Logging helpers} *)
open Log_record
(** Create log record and emit it on [logger] *)
let log ?(logger = dynamic_main) ?attrs ?trace_id ?span_id
?(severity : severity option) (msg : string) : unit =
if enabled logger then (
let now = Clock.now logger.clock in
let logrec =
Log_record.make_str ?attrs ?trace_id ?span_id ?severity
~observed_time_unix_nano:now msg
in
emit1 logger logrec
)
(** Helper to create a log record, with a suspension, like in [Logs].
Example usage:
[logf ~severity:Severity_number_warn (fun k->k"oh no!! %s it's bad: %b"
"help" true)] *)
let logf ?(logger = dynamic_main) ?attrs ?trace_id ?span_id ?severity msgf :
unit =
if enabled logger then
msgf (fun fmt ->
Format.kasprintf (log ~logger ?attrs ?trace_id ?span_id ?severity) fmt)

26
src/lib/metrics_emitter.ml
View file

@ -1,12 +1,19 @@
open Opentelemetry_emitter
type t = Metrics.t Emitter.t
type t = {
emit: Metrics.t Emitter.t;
clock: Clock.t;
}
let dummy : t = Emitter.dummy
let dummy : t = { emit = Emitter.dummy; clock = Clock.Main.dynamic_main }
let enabled = Emitter.enabled
let[@inline] enabled (self : t) = Emitter.enabled self.emit
let of_exporter (exp : Exporter.t) : t = exp.emit_metrics
let of_exporter (exp : Exporter.t) : t =
{ emit = exp.emit_metrics; clock = exp.clock }
let dynamic_main : t =
Main_exporter.dynamic_forward_to_main_exporter |> of_exporter
(** Emit some metrics to the collector (sync). This blocks until the backend has
pushed the metrics into some internal queue, or discarded them. *)
@ -16,12 +23,5 @@ let (emit [@deprecated "use an explicit Metrics_emitter.t"]) =
| None -> ()
| Some exp -> Exporter.send_metrics exp l
let get_main () : t =
match Main_exporter.get () with
| None -> dummy
| Some e -> e.emit_metrics
(** An emitter that uses the current {!Main_exporter} *)
let dynamic_forward_to_main_exporter : t =
Main_exporter.Util.dynamic_forward_to_main_exporter () ~get_emitter:(fun e ->
e.emit_metrics)
let[@inline] emit1 (self : t) (m : Metrics.t) : unit =
Emitter.emit self.emit [ m ]

42
src/lib/tracer.ml
View file

@ -10,29 +10,31 @@ open Opentelemetry_emitter
type span = Span.t
type t = Span.t Emitter.t
type t = {
emit: Span.t Emitter.t;
clock: Clock.t;
}
(** A tracer.
https://opentelemetry.io/docs/specs/otel/trace/api/#tracer *)
(** Dummy tracer, always disabled *)
let dummy : t = Emitter.dummy
let dummy : t = { emit = Emitter.dummy; clock = Clock.Main.dynamic_main }
let[@inline] enabled (self : t) = Emitter.enabled self.emit
let of_exporter (exp : Exporter.t) : t =
{ emit = exp.emit_spans; clock = exp.clock }
(** A tracer that uses the current {!Main_exporter} *)
let dynamic_forward_to_main_exporter : t =
Main_exporter.Util.dynamic_forward_to_main_exporter () ~get_emitter:(fun e ->
e.emit_spans)
let dynamic_main : t =
Main_exporter.dynamic_forward_to_main_exporter |> of_exporter
(** Get tracer using the main exporter in {!Main_exporter} *)
let get_main () : t =
match Main_exporter.get () with
| None -> dummy
| Some e -> e.emit_spans
let (add_event [@deprecated "use Span.add_event"]) = Span.add_event'
let (add_event [@deprecated "use Span.add_event"]) = Span.add_event
let (add_attrs [@deprecated "use Span.add_attrs"]) = Span.add_attrs
let (add_attrs [@deprecated "use Span.add_attrs"]) = Span.add_attrs'
(** Helper to implement {!with_} and similar functions *)
let with_thunk_and_finally (self : t) ?(force_new_trace_id = false) ?trace_state
?(attrs : (string * [< Value.t ]) list = []) ?kind ?trace_id ?parent ?links
name cb =
@ -48,7 +50,8 @@ let with_thunk_and_finally (self : t) ?(force_new_trace_id = false) ?trace_state
| None, Some p -> Span.trace_id p
| None, None -> Trace_id.create ()
in
let start_time = Timestamp_ns.now_unix_ns () in
(* TODO: pass a clock in emitters *)
let start_time = Clock.now_main () in
let span_id = Span_id.create () in
let parent_id = Option.map Span.id parent in
@ -59,7 +62,7 @@ let with_thunk_and_finally (self : t) ?(force_new_trace_id = false) ?trace_state
in
(* called once we're done, to emit a span *)
let finally res =
let end_time = Timestamp_ns.now_unix_ns () in
let end_time = Clock.now_main () in
Proto.Trace.span_set_end_time_unix_nano span end_time;
(match Span.status span with
@ -80,7 +83,7 @@ let with_thunk_and_finally (self : t) ?(force_new_trace_id = false) ?trace_state
in
Span.set_status span status));
Emitter.emit self [ span ]
Emitter.emit self.emit [ span ]
in
let thunk () = Ambient_span.with_ambient span (fun () -> cb span) in
thunk, finally
@ -97,14 +100,15 @@ let with_thunk_and_finally (self : t) ?(force_new_trace_id = false) ?trace_state
{b NOTE} be careful not to call this inside a Gc alarm, as it can cause
deadlocks.
@param tracer the tracer to use (default [get_main()])
@param force_new_trace_id
if true (default false), the span will not use a ambient scope, the
[~scope] argument, nor [~trace_id], but will instead always create fresh
identifiers for this span *)
let with_ (self : t) ?force_new_trace_id ?trace_state ?attrs ?kind ?trace_id
?parent ?links name (cb : Span.t -> 'a) : 'a =
let with_ ?(tracer = dynamic_main) ?force_new_trace_id ?trace_state ?attrs ?kind
?trace_id ?parent ?links name (cb : Span.t -> 'a) : 'a =
let thunk, finally =
with_thunk_and_finally self ?force_new_trace_id ?trace_state ?attrs ?kind
with_thunk_and_finally tracer ?force_new_trace_id ?trace_state ?attrs ?kind
?trace_id ?parent ?links name cb
in

8
src/lwt/opentelemetry_lwt.ml
View file

@ -18,11 +18,11 @@ module Tracer = struct
include Tracer
(** Sync span guard *)
let with_ (self : t) ?force_new_trace_id ?trace_state ?attrs ?kind ?trace_id
?parent ?links name (cb : Span.t -> 'a Lwt.t) : 'a Lwt.t =
let with_ ?(tracer = dynamic_main) ?force_new_trace_id ?trace_state ?attrs
?kind ?trace_id ?parent ?links name (cb : Span.t -> 'a Lwt.t) : 'a Lwt.t =
let thunk, finally =
with_thunk_and_finally self ?force_new_trace_id ?trace_state ?attrs ?kind
?trace_id ?parent ?links name cb
with_thunk_and_finally tracer ?force_new_trace_id ?trace_state ?attrs
?kind ?trace_id ?parent ?links name cb
in
try%lwt

6
src/trace/opentelemetry_trace.ml
View file

@ -315,11 +315,13 @@ module Make_collector (A : COLLECTOR_ARG) = struct
let name_thread _name = ()
let counter_int ~data:attrs name cur_val : unit =
let m = OTEL.Metrics.(gauge ~name [ int ~attrs cur_val ]) in
let now = OTEL.Clock.now exporter.clock in
let m = OTEL.Metrics.(gauge ~name [ int ~attrs ~now cur_val ]) in
OTEL.Exporter.send_metrics exporter [ m ]
let counter_float ~data:attrs name cur_val : unit =
let m = OTEL.Metrics.(gauge ~name [ float ~attrs cur_val ]) in
let now = OTEL.Clock.now exporter.clock in
let m = OTEL.Metrics.(gauge ~name [ float ~attrs ~now cur_val ]) in
OTEL.Exporter.send_metrics exporter [ m ]
let extension_event = function

16
tests/bin/emit1.ml
View file

@ -28,7 +28,7 @@ let run_job () =
while OT.Aswitch.is_on active && !cnt < !n do
let@ _scope =
Atomic.incr num_tr;
OT.Tracer.with_ tracer ~kind:OT.Span.Span_kind_producer "loop.outer"
OT.Tracer.with_ ~tracer ~kind:OT.Span.Span_kind_producer "loop.outer"
~attrs:[ "i", `Int !i ]
in
@ -39,7 +39,7 @@ let run_job () =
(* parent scope is found via thread local storage *)
let@ scope =
Atomic.incr num_tr;
OT.Tracer.with_ tracer ~kind:OT.Span.Span_kind_internal ~parent:_scope
OT.Tracer.with_ ~tracer ~kind:OT.Span.Span_kind_internal ~parent:_scope
~attrs:[ "j", `Int j ]
"loop.inner"
in
@ -49,13 +49,9 @@ let run_job () =
Atomic.incr num_sleep
);
let logger = OT.Logger.get_main () in
OT.Emitter.emit logger
[
OT.Log_record.make_strf ~trace_id:(OT.Span.trace_id scope)
~span_id:(OT.Span.id scope) ~severity:Severity_number_info
"inner at %d" j;
];
OT.Logger.logf ~trace_id:(OT.Span.trace_id scope)
~span_id:(OT.Span.id scope) ~severity:Severity_number_info (fun k ->
k "inner at %d" j);
incr i;
@ -63,7 +59,7 @@ let run_job () =
(* allocate some stuff *)
if !stress_alloc_ then (
let@ _ =
OT.Tracer.with_ tracer ~kind:OT.Span.Span_kind_internal
OT.Tracer.with_ ~tracer ~kind:OT.Span.Span_kind_internal
~parent:scope "alloc"
in
Atomic.incr num_tr;

14
tests/bin/emit1_cohttp.ml
View file

@ -29,7 +29,7 @@ let run_job job_id : unit Lwt.t =
let tracer = T.Tracer.get_main () in
let@ scope =
Atomic.incr num_tr;
T.Tracer.with_ tracer ~kind:T.Span.Span_kind_producer "loop.outer"
T.Tracer.with_ ~tracer ~kind:T.Span.Span_kind_producer "loop.outer"
~attrs:[ "i", `Int job_id ]
in
@ -41,7 +41,7 @@ let run_job job_id : unit Lwt.t =
(* parent scope is found via thread local storage *)
let@ span =
Atomic.incr num_tr;
T.Tracer.with_ tracer ~parent:scope ~kind:T.Span.Span_kind_internal
T.Tracer.with_ ~tracer ~parent:scope ~kind:T.Span.Span_kind_internal
~attrs:[ "j", `Int j ]
"loop.inner"
in
@ -49,19 +49,15 @@ let run_job job_id : unit Lwt.t =
let* () = Lwt_unix.sleep !sleep_outer in
Atomic.incr num_sleep;
Opentelemetry_emitter.Emitter.emit (T.Logger.get_main ())
[
T.Log_record.make_strf ~trace_id:(T.Span.trace_id span)
~span_id:(T.Span.id span) ~severity:Severity_number_info
"inner at %d" j;
];
T.Logger.logf ~trace_id:(T.Span.trace_id span) ~span_id:(T.Span.id span)
~severity:Severity_number_info (fun k -> k "inner at %d" j);
incr i;
try%lwt
Atomic.incr num_tr;
let@ scope =
T.Tracer.with_ tracer ~kind:T.Span.Span_kind_internal ~parent:span
T.Tracer.with_ ~tracer ~kind:T.Span.Span_kind_internal ~parent:span
"alloc"
in
(* allocate some stuff *)

16
tests/bin/emit1_eio.ml
View file

@ -26,7 +26,7 @@ let run_job clock _job_id iterations : unit =
let tracer = OT.Tracer.get_main () in
let@ scope =
Atomic.incr num_tr;
OT.Tracer.with_ tracer ~kind:OT.Span.Span_kind_producer "loop.outer"
OT.Tracer.with_ ~tracer ~kind:OT.Span.Span_kind_producer "loop.outer"
~attrs:[ "i", `Int (Atomic.get i) ]
in
@ -38,7 +38,7 @@ let run_job clock _job_id iterations : unit =
(* parent scope is found via thread local storage *)
let@ scope =
Atomic.incr num_tr;
OT.Tracer.with_ tracer ~parent:scope ~kind:OT.Span.Span_kind_internal
OT.Tracer.with_ ~tracer ~parent:scope ~kind:OT.Span.Span_kind_internal
~attrs:[ "j", `Int j ]
"loop.inner"
in
@ -46,20 +46,16 @@ let run_job clock _job_id iterations : unit =
let () = Eio.Time.sleep clock !sleep_outer in
Atomic.incr num_sleep;
(let logger = OT.Logger.get_main () in
OT.Emitter.emit logger
[
OT.Log_record.make_strf ~trace_id:(OT.Span.trace_id scope)
~span_id:(OT.Span.id scope) ~severity:Severity_number_info
"inner at %d" j;
]);
OT.Logger.logf ~trace_id:(OT.Span.trace_id scope)
~span_id:(OT.Span.id scope) ~severity:Severity_number_info (fun k ->
k "inner at %d" j);
Atomic.incr i;
try
Atomic.incr num_tr;
let@ scope =
OT.Tracer.with_ tracer ~kind:OT.Span.Span_kind_internal ~parent:scope
OT.Tracer.with_ ~tracer ~kind:OT.Span.Span_kind_internal ~parent:scope
"alloc"
in
(* allocate some stuff *)

20
tests/bin/emit1_stdout.ml
View file

@ -28,7 +28,7 @@ let run_job () =
while OT.Aswitch.is_on active && !cnt < !n do
let@ _scope =
Atomic.incr num_tr;
OT.Tracer.with_ tracer ~kind:OT.Span.Span_kind_producer "loop.outer"
OT.Tracer.with_ ~tracer ~kind:OT.Span.Span_kind_producer "loop.outer"
~attrs:[ "i", `Int !i ]
in
@ -39,7 +39,7 @@ let run_job () =
(* parent scope is found via thread local storage *)
let@ scope =
Atomic.incr num_tr;
OT.Tracer.with_ tracer ~kind:OT.Span.Span_kind_internal ~parent:_scope
OT.Tracer.with_ ~tracer ~kind:OT.Span.Span_kind_internal ~parent:_scope
~attrs:[ "j", `Int j ]
"loop.inner"
in
@ -49,13 +49,9 @@ let run_job () =
Atomic.incr num_sleep
);
let logger = OT.Logger.get_main () in
OT.Emitter.emit logger
[
OT.Log_record.make_strf ~trace_id:(OT.Span.trace_id scope)
~span_id:(OT.Span.id scope) ~severity:Severity_number_info
"inner at %d" j;
];
OT.Logger.logf ~trace_id:(OT.Span.trace_id scope)
~span_id:(OT.Span.id scope) ~severity:Severity_number_info (fun k ->
k "inner at %d" j);
incr i;
@ -64,7 +60,7 @@ let run_job () =
(* allocate some stuff *)
(if !stress_alloc_ then
let@ _ =
OT.Tracer.with_ tracer ~kind:OT.Span.Span_kind_internal
OT.Tracer.with_ ~tracer ~kind:OT.Span.Span_kind_internal
~parent:scope "alloc"
in
let _arr : _ array =
@ -153,10 +149,10 @@ let () =
!sleep_outer !sleep_inner !queued;
let exporter =
let exp = OTC.Exporter_stdout.stdout in
let exp = OTC.Exporter_stdout.stdout () in
if !queued then (
let q = OTC.Bounded_queue_sync.create ~high_watermark:20_000 () in
OTC.Exporter_queued.create ~q
OTC.Exporter_queued.create ~clock:exp.clock ~q
~consumer:(Consumer_exporter.consumer exp)
()
) else

2
tests/bin/emit_logs_cohttp.ml
View file

@ -37,7 +37,7 @@ let run () =
Logs.app (fun m -> m "emit_logs: app log");
let%lwt () =
let tracer = T.Tracer.get_main () in
T.Tracer.with_ tracer ~kind:T.Span.Span_kind_producer "my_scope"
T.Tracer.with_ ~tracer ~kind:T.Span.Span_kind_producer "my_scope"
(fun _scope ->
Logs.info (fun m ->
m ~tags:varied_tag_set

7
tests/implicit_scope/sync/test_implicit_scope_sync.ml
View file

@ -19,12 +19,11 @@ let bytes_to_hex = Opentelemetry_util.Util_bytes_.bytes_to_hex
let test_stack_based_implicit_scope () =
let run () =
let tracer = Otel.Tracer.get_main () in
Otel.Tracer.with_ tracer "first trace" @@ fun _scope ->
Otel.Tracer.with_ "first trace" @@ fun _scope ->
Thread.delay 0.2;
Otel.Tracer.with_ tracer "second trace" @@ fun _scope ->
Otel.Tracer.with_ "second trace" @@ fun _scope ->
Thread.delay 0.2;
Otel.Tracer.with_ tracer "third trace" @@ fun _scope ->
Otel.Tracer.with_ "third trace" @@ fun _scope ->
Thread.delay 0.2;
()
in