mirror of
https://github.com/ocaml-tracing/ocaml-opentelemetry.git
synced 2026-03-09 12:23:32 -04:00
8b1b6aecf2
this requires ocaml-protoc with support for optionals in proto3, which is [wip](https://github.com/mransan/ocaml-protoc/pull/184). However we only extract the protobufs explicitly, not during a regular build
547 lines
19 KiB
OCaml
547 lines
19 KiB
OCaml
[@@@ocaml.warning "-27-30-39"]
|
|
|
|
type span_event_mutable = {
|
|
mutable time_unix_nano : int64;
|
|
mutable name : string;
|
|
mutable attributes : Common_types.key_value list;
|
|
mutable dropped_attributes_count : int32;
|
|
}
|
|
|
|
let default_span_event_mutable () : span_event_mutable = {
|
|
time_unix_nano = 0L;
|
|
name = "";
|
|
attributes = [];
|
|
dropped_attributes_count = 0l;
|
|
}
|
|
|
|
type span_link_mutable = {
|
|
mutable trace_id : bytes;
|
|
mutable span_id : bytes;
|
|
mutable trace_state : string;
|
|
mutable attributes : Common_types.key_value list;
|
|
mutable dropped_attributes_count : int32;
|
|
}
|
|
|
|
let default_span_link_mutable () : span_link_mutable = {
|
|
trace_id = Bytes.create 0;
|
|
span_id = Bytes.create 0;
|
|
trace_state = "";
|
|
attributes = [];
|
|
dropped_attributes_count = 0l;
|
|
}
|
|
|
|
type status_mutable = {
|
|
mutable message : string;
|
|
mutable code : Trace_types.status_status_code;
|
|
}
|
|
|
|
let default_status_mutable () : status_mutable = {
|
|
message = "";
|
|
code = Trace_types.default_status_status_code ();
|
|
}
|
|
|
|
type span_mutable = {
|
|
mutable trace_id : bytes;
|
|
mutable span_id : bytes;
|
|
mutable trace_state : string;
|
|
mutable parent_span_id : bytes;
|
|
mutable name : string;
|
|
mutable kind : Trace_types.span_span_kind;
|
|
mutable start_time_unix_nano : int64;
|
|
mutable end_time_unix_nano : int64;
|
|
mutable attributes : Common_types.key_value list;
|
|
mutable dropped_attributes_count : int32;
|
|
mutable events : Trace_types.span_event list;
|
|
mutable dropped_events_count : int32;
|
|
mutable links : Trace_types.span_link list;
|
|
mutable dropped_links_count : int32;
|
|
mutable status : Trace_types.status option;
|
|
}
|
|
|
|
let default_span_mutable () : span_mutable = {
|
|
trace_id = Bytes.create 0;
|
|
span_id = Bytes.create 0;
|
|
trace_state = "";
|
|
parent_span_id = Bytes.create 0;
|
|
name = "";
|
|
kind = Trace_types.default_span_span_kind ();
|
|
start_time_unix_nano = 0L;
|
|
end_time_unix_nano = 0L;
|
|
attributes = [];
|
|
dropped_attributes_count = 0l;
|
|
events = [];
|
|
dropped_events_count = 0l;
|
|
links = [];
|
|
dropped_links_count = 0l;
|
|
status = None;
|
|
}
|
|
|
|
type scope_spans_mutable = {
|
|
mutable scope : Common_types.instrumentation_scope option;
|
|
mutable spans : Trace_types.span list;
|
|
mutable schema_url : string;
|
|
}
|
|
|
|
let default_scope_spans_mutable () : scope_spans_mutable = {
|
|
scope = None;
|
|
spans = [];
|
|
schema_url = "";
|
|
}
|
|
|
|
type resource_spans_mutable = {
|
|
mutable resource : Resource_types.resource option;
|
|
mutable scope_spans : Trace_types.scope_spans list;
|
|
mutable schema_url : string;
|
|
}
|
|
|
|
let default_resource_spans_mutable () : resource_spans_mutable = {
|
|
resource = None;
|
|
scope_spans = [];
|
|
schema_url = "";
|
|
}
|
|
|
|
type traces_data_mutable = {
|
|
mutable resource_spans : Trace_types.resource_spans list;
|
|
}
|
|
|
|
let default_traces_data_mutable () : traces_data_mutable = {
|
|
resource_spans = [];
|
|
}
|
|
|
|
|
|
let rec decode_span_span_kind d =
|
|
match Pbrt.Decoder.int_as_varint d with
|
|
| 0 -> (Trace_types.Span_kind_unspecified:Trace_types.span_span_kind)
|
|
| 1 -> (Trace_types.Span_kind_internal:Trace_types.span_span_kind)
|
|
| 2 -> (Trace_types.Span_kind_server:Trace_types.span_span_kind)
|
|
| 3 -> (Trace_types.Span_kind_client:Trace_types.span_span_kind)
|
|
| 4 -> (Trace_types.Span_kind_producer:Trace_types.span_span_kind)
|
|
| 5 -> (Trace_types.Span_kind_consumer:Trace_types.span_span_kind)
|
|
| _ -> Pbrt.Decoder.malformed_variant "span_span_kind"
|
|
|
|
let rec decode_span_event d =
|
|
let v = default_span_event_mutable () in
|
|
let continue__= ref true in
|
|
while !continue__ do
|
|
match Pbrt.Decoder.key d with
|
|
| None -> (
|
|
v.attributes <- List.rev v.attributes;
|
|
); continue__ := false
|
|
| Some (1, Pbrt.Bits64) -> begin
|
|
v.time_unix_nano <- Pbrt.Decoder.int64_as_bits64 d;
|
|
end
|
|
| Some (1, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span_event), field(1)" pk
|
|
| Some (2, Pbrt.Bytes) -> begin
|
|
v.name <- Pbrt.Decoder.string d;
|
|
end
|
|
| Some (2, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span_event), field(2)" pk
|
|
| Some (3, Pbrt.Bytes) -> begin
|
|
v.attributes <- (Common_pb.decode_key_value (Pbrt.Decoder.nested d)) :: v.attributes;
|
|
end
|
|
| Some (3, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span_event), field(3)" pk
|
|
| Some (4, Pbrt.Varint) -> begin
|
|
v.dropped_attributes_count <- Pbrt.Decoder.int32_as_varint d;
|
|
end
|
|
| Some (4, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span_event), field(4)" pk
|
|
| Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
|
|
done;
|
|
({
|
|
Trace_types.time_unix_nano = v.time_unix_nano;
|
|
Trace_types.name = v.name;
|
|
Trace_types.attributes = v.attributes;
|
|
Trace_types.dropped_attributes_count = v.dropped_attributes_count;
|
|
} : Trace_types.span_event)
|
|
|
|
let rec decode_span_link d =
|
|
let v = default_span_link_mutable () in
|
|
let continue__= ref true in
|
|
while !continue__ do
|
|
match Pbrt.Decoder.key d with
|
|
| None -> (
|
|
v.attributes <- List.rev v.attributes;
|
|
); continue__ := false
|
|
| Some (1, Pbrt.Bytes) -> begin
|
|
v.trace_id <- Pbrt.Decoder.bytes d;
|
|
end
|
|
| Some (1, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span_link), field(1)" pk
|
|
| Some (2, Pbrt.Bytes) -> begin
|
|
v.span_id <- Pbrt.Decoder.bytes d;
|
|
end
|
|
| Some (2, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span_link), field(2)" pk
|
|
| Some (3, Pbrt.Bytes) -> begin
|
|
v.trace_state <- Pbrt.Decoder.string d;
|
|
end
|
|
| Some (3, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span_link), field(3)" pk
|
|
| Some (4, Pbrt.Bytes) -> begin
|
|
v.attributes <- (Common_pb.decode_key_value (Pbrt.Decoder.nested d)) :: v.attributes;
|
|
end
|
|
| Some (4, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span_link), field(4)" pk
|
|
| Some (5, Pbrt.Varint) -> begin
|
|
v.dropped_attributes_count <- Pbrt.Decoder.int32_as_varint d;
|
|
end
|
|
| Some (5, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span_link), field(5)" pk
|
|
| Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
|
|
done;
|
|
({
|
|
Trace_types.trace_id = v.trace_id;
|
|
Trace_types.span_id = v.span_id;
|
|
Trace_types.trace_state = v.trace_state;
|
|
Trace_types.attributes = v.attributes;
|
|
Trace_types.dropped_attributes_count = v.dropped_attributes_count;
|
|
} : Trace_types.span_link)
|
|
|
|
let rec decode_status_status_code d =
|
|
match Pbrt.Decoder.int_as_varint d with
|
|
| 0 -> (Trace_types.Status_code_unset:Trace_types.status_status_code)
|
|
| 1 -> (Trace_types.Status_code_ok:Trace_types.status_status_code)
|
|
| 2 -> (Trace_types.Status_code_error:Trace_types.status_status_code)
|
|
| _ -> Pbrt.Decoder.malformed_variant "status_status_code"
|
|
|
|
let rec decode_status d =
|
|
let v = default_status_mutable () in
|
|
let continue__= ref true in
|
|
while !continue__ do
|
|
match Pbrt.Decoder.key d with
|
|
| None -> (
|
|
); continue__ := false
|
|
| Some (2, Pbrt.Bytes) -> begin
|
|
v.message <- Pbrt.Decoder.string d;
|
|
end
|
|
| Some (2, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(status), field(2)" pk
|
|
| Some (3, Pbrt.Varint) -> begin
|
|
v.code <- decode_status_status_code d;
|
|
end
|
|
| Some (3, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(status), field(3)" pk
|
|
| Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
|
|
done;
|
|
({
|
|
Trace_types.message = v.message;
|
|
Trace_types.code = v.code;
|
|
} : Trace_types.status)
|
|
|
|
let rec decode_span d =
|
|
let v = default_span_mutable () in
|
|
let continue__= ref true in
|
|
while !continue__ do
|
|
match Pbrt.Decoder.key d with
|
|
| None -> (
|
|
v.links <- List.rev v.links;
|
|
v.events <- List.rev v.events;
|
|
v.attributes <- List.rev v.attributes;
|
|
); continue__ := false
|
|
| Some (1, Pbrt.Bytes) -> begin
|
|
v.trace_id <- Pbrt.Decoder.bytes d;
|
|
end
|
|
| Some (1, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(1)" pk
|
|
| Some (2, Pbrt.Bytes) -> begin
|
|
v.span_id <- Pbrt.Decoder.bytes d;
|
|
end
|
|
| Some (2, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(2)" pk
|
|
| Some (3, Pbrt.Bytes) -> begin
|
|
v.trace_state <- Pbrt.Decoder.string d;
|
|
end
|
|
| Some (3, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(3)" pk
|
|
| Some (4, Pbrt.Bytes) -> begin
|
|
v.parent_span_id <- Pbrt.Decoder.bytes d;
|
|
end
|
|
| Some (4, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(4)" pk
|
|
| Some (5, Pbrt.Bytes) -> begin
|
|
v.name <- Pbrt.Decoder.string d;
|
|
end
|
|
| Some (5, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(5)" pk
|
|
| Some (6, Pbrt.Varint) -> begin
|
|
v.kind <- decode_span_span_kind d;
|
|
end
|
|
| Some (6, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(6)" pk
|
|
| Some (7, Pbrt.Bits64) -> begin
|
|
v.start_time_unix_nano <- Pbrt.Decoder.int64_as_bits64 d;
|
|
end
|
|
| Some (7, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(7)" pk
|
|
| Some (8, Pbrt.Bits64) -> begin
|
|
v.end_time_unix_nano <- Pbrt.Decoder.int64_as_bits64 d;
|
|
end
|
|
| Some (8, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(8)" pk
|
|
| Some (9, Pbrt.Bytes) -> begin
|
|
v.attributes <- (Common_pb.decode_key_value (Pbrt.Decoder.nested d)) :: v.attributes;
|
|
end
|
|
| Some (9, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(9)" pk
|
|
| Some (10, Pbrt.Varint) -> begin
|
|
v.dropped_attributes_count <- Pbrt.Decoder.int32_as_varint d;
|
|
end
|
|
| Some (10, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(10)" pk
|
|
| Some (11, Pbrt.Bytes) -> begin
|
|
v.events <- (decode_span_event (Pbrt.Decoder.nested d)) :: v.events;
|
|
end
|
|
| Some (11, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(11)" pk
|
|
| Some (12, Pbrt.Varint) -> begin
|
|
v.dropped_events_count <- Pbrt.Decoder.int32_as_varint d;
|
|
end
|
|
| Some (12, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(12)" pk
|
|
| Some (13, Pbrt.Bytes) -> begin
|
|
v.links <- (decode_span_link (Pbrt.Decoder.nested d)) :: v.links;
|
|
end
|
|
| Some (13, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(13)" pk
|
|
| Some (14, Pbrt.Varint) -> begin
|
|
v.dropped_links_count <- Pbrt.Decoder.int32_as_varint d;
|
|
end
|
|
| Some (14, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(14)" pk
|
|
| Some (15, Pbrt.Bytes) -> begin
|
|
v.status <- Some (decode_status (Pbrt.Decoder.nested d));
|
|
end
|
|
| Some (15, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(span), field(15)" pk
|
|
| Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
|
|
done;
|
|
({
|
|
Trace_types.trace_id = v.trace_id;
|
|
Trace_types.span_id = v.span_id;
|
|
Trace_types.trace_state = v.trace_state;
|
|
Trace_types.parent_span_id = v.parent_span_id;
|
|
Trace_types.name = v.name;
|
|
Trace_types.kind = v.kind;
|
|
Trace_types.start_time_unix_nano = v.start_time_unix_nano;
|
|
Trace_types.end_time_unix_nano = v.end_time_unix_nano;
|
|
Trace_types.attributes = v.attributes;
|
|
Trace_types.dropped_attributes_count = v.dropped_attributes_count;
|
|
Trace_types.events = v.events;
|
|
Trace_types.dropped_events_count = v.dropped_events_count;
|
|
Trace_types.links = v.links;
|
|
Trace_types.dropped_links_count = v.dropped_links_count;
|
|
Trace_types.status = v.status;
|
|
} : Trace_types.span)
|
|
|
|
let rec decode_scope_spans d =
|
|
let v = default_scope_spans_mutable () in
|
|
let continue__= ref true in
|
|
while !continue__ do
|
|
match Pbrt.Decoder.key d with
|
|
| None -> (
|
|
v.spans <- List.rev v.spans;
|
|
); continue__ := false
|
|
| Some (1, Pbrt.Bytes) -> begin
|
|
v.scope <- Some (Common_pb.decode_instrumentation_scope (Pbrt.Decoder.nested d));
|
|
end
|
|
| Some (1, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(scope_spans), field(1)" pk
|
|
| Some (2, Pbrt.Bytes) -> begin
|
|
v.spans <- (decode_span (Pbrt.Decoder.nested d)) :: v.spans;
|
|
end
|
|
| Some (2, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(scope_spans), field(2)" pk
|
|
| Some (3, Pbrt.Bytes) -> begin
|
|
v.schema_url <- Pbrt.Decoder.string d;
|
|
end
|
|
| Some (3, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(scope_spans), field(3)" pk
|
|
| Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
|
|
done;
|
|
({
|
|
Trace_types.scope = v.scope;
|
|
Trace_types.spans = v.spans;
|
|
Trace_types.schema_url = v.schema_url;
|
|
} : Trace_types.scope_spans)
|
|
|
|
let rec decode_resource_spans d =
|
|
let v = default_resource_spans_mutable () in
|
|
let continue__= ref true in
|
|
while !continue__ do
|
|
match Pbrt.Decoder.key d with
|
|
| None -> (
|
|
v.scope_spans <- List.rev v.scope_spans;
|
|
); continue__ := false
|
|
| Some (1, Pbrt.Bytes) -> begin
|
|
v.resource <- Some (Resource_pb.decode_resource (Pbrt.Decoder.nested d));
|
|
end
|
|
| Some (1, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(resource_spans), field(1)" pk
|
|
| Some (2, Pbrt.Bytes) -> begin
|
|
v.scope_spans <- (decode_scope_spans (Pbrt.Decoder.nested d)) :: v.scope_spans;
|
|
end
|
|
| Some (2, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(resource_spans), field(2)" pk
|
|
| Some (3, Pbrt.Bytes) -> begin
|
|
v.schema_url <- Pbrt.Decoder.string d;
|
|
end
|
|
| Some (3, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(resource_spans), field(3)" pk
|
|
| Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
|
|
done;
|
|
({
|
|
Trace_types.resource = v.resource;
|
|
Trace_types.scope_spans = v.scope_spans;
|
|
Trace_types.schema_url = v.schema_url;
|
|
} : Trace_types.resource_spans)
|
|
|
|
let rec decode_traces_data d =
|
|
let v = default_traces_data_mutable () in
|
|
let continue__= ref true in
|
|
while !continue__ do
|
|
match Pbrt.Decoder.key d with
|
|
| None -> (
|
|
v.resource_spans <- List.rev v.resource_spans;
|
|
); continue__ := false
|
|
| Some (1, Pbrt.Bytes) -> begin
|
|
v.resource_spans <- (decode_resource_spans (Pbrt.Decoder.nested d)) :: v.resource_spans;
|
|
end
|
|
| Some (1, pk) ->
|
|
Pbrt.Decoder.unexpected_payload "Message(traces_data), field(1)" pk
|
|
| Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
|
|
done;
|
|
({
|
|
Trace_types.resource_spans = v.resource_spans;
|
|
} : Trace_types.traces_data)
|
|
|
|
let rec encode_span_span_kind (v:Trace_types.span_span_kind) encoder =
|
|
match v with
|
|
| Trace_types.Span_kind_unspecified -> Pbrt.Encoder.int_as_varint (0) encoder
|
|
| Trace_types.Span_kind_internal -> Pbrt.Encoder.int_as_varint 1 encoder
|
|
| Trace_types.Span_kind_server -> Pbrt.Encoder.int_as_varint 2 encoder
|
|
| Trace_types.Span_kind_client -> Pbrt.Encoder.int_as_varint 3 encoder
|
|
| Trace_types.Span_kind_producer -> Pbrt.Encoder.int_as_varint 4 encoder
|
|
| Trace_types.Span_kind_consumer -> Pbrt.Encoder.int_as_varint 5 encoder
|
|
|
|
let rec encode_span_event (v:Trace_types.span_event) encoder =
|
|
Pbrt.Encoder.key (1, Pbrt.Bits64) encoder;
|
|
Pbrt.Encoder.int64_as_bits64 v.Trace_types.time_unix_nano encoder;
|
|
Pbrt.Encoder.key (2, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.string v.Trace_types.name encoder;
|
|
List.iter (fun x ->
|
|
Pbrt.Encoder.key (3, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.nested (Common_pb.encode_key_value x) encoder;
|
|
) v.Trace_types.attributes;
|
|
Pbrt.Encoder.key (4, Pbrt.Varint) encoder;
|
|
Pbrt.Encoder.int32_as_varint v.Trace_types.dropped_attributes_count encoder;
|
|
()
|
|
|
|
let rec encode_span_link (v:Trace_types.span_link) encoder =
|
|
Pbrt.Encoder.key (1, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.bytes v.Trace_types.trace_id encoder;
|
|
Pbrt.Encoder.key (2, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.bytes v.Trace_types.span_id encoder;
|
|
Pbrt.Encoder.key (3, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.string v.Trace_types.trace_state encoder;
|
|
List.iter (fun x ->
|
|
Pbrt.Encoder.key (4, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.nested (Common_pb.encode_key_value x) encoder;
|
|
) v.Trace_types.attributes;
|
|
Pbrt.Encoder.key (5, Pbrt.Varint) encoder;
|
|
Pbrt.Encoder.int32_as_varint v.Trace_types.dropped_attributes_count encoder;
|
|
()
|
|
|
|
let rec encode_status_status_code (v:Trace_types.status_status_code) encoder =
|
|
match v with
|
|
| Trace_types.Status_code_unset -> Pbrt.Encoder.int_as_varint (0) encoder
|
|
| Trace_types.Status_code_ok -> Pbrt.Encoder.int_as_varint 1 encoder
|
|
| Trace_types.Status_code_error -> Pbrt.Encoder.int_as_varint 2 encoder
|
|
|
|
let rec encode_status (v:Trace_types.status) encoder =
|
|
Pbrt.Encoder.key (2, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.string v.Trace_types.message encoder;
|
|
Pbrt.Encoder.key (3, Pbrt.Varint) encoder;
|
|
encode_status_status_code v.Trace_types.code encoder;
|
|
()
|
|
|
|
let rec encode_span (v:Trace_types.span) encoder =
|
|
Pbrt.Encoder.key (1, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.bytes v.Trace_types.trace_id encoder;
|
|
Pbrt.Encoder.key (2, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.bytes v.Trace_types.span_id encoder;
|
|
Pbrt.Encoder.key (3, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.string v.Trace_types.trace_state encoder;
|
|
Pbrt.Encoder.key (4, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.bytes v.Trace_types.parent_span_id encoder;
|
|
Pbrt.Encoder.key (5, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.string v.Trace_types.name encoder;
|
|
Pbrt.Encoder.key (6, Pbrt.Varint) encoder;
|
|
encode_span_span_kind v.Trace_types.kind encoder;
|
|
Pbrt.Encoder.key (7, Pbrt.Bits64) encoder;
|
|
Pbrt.Encoder.int64_as_bits64 v.Trace_types.start_time_unix_nano encoder;
|
|
Pbrt.Encoder.key (8, Pbrt.Bits64) encoder;
|
|
Pbrt.Encoder.int64_as_bits64 v.Trace_types.end_time_unix_nano encoder;
|
|
List.iter (fun x ->
|
|
Pbrt.Encoder.key (9, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.nested (Common_pb.encode_key_value x) encoder;
|
|
) v.Trace_types.attributes;
|
|
Pbrt.Encoder.key (10, Pbrt.Varint) encoder;
|
|
Pbrt.Encoder.int32_as_varint v.Trace_types.dropped_attributes_count encoder;
|
|
List.iter (fun x ->
|
|
Pbrt.Encoder.key (11, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.nested (encode_span_event x) encoder;
|
|
) v.Trace_types.events;
|
|
Pbrt.Encoder.key (12, Pbrt.Varint) encoder;
|
|
Pbrt.Encoder.int32_as_varint v.Trace_types.dropped_events_count encoder;
|
|
List.iter (fun x ->
|
|
Pbrt.Encoder.key (13, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.nested (encode_span_link x) encoder;
|
|
) v.Trace_types.links;
|
|
Pbrt.Encoder.key (14, Pbrt.Varint) encoder;
|
|
Pbrt.Encoder.int32_as_varint v.Trace_types.dropped_links_count encoder;
|
|
begin match v.Trace_types.status with
|
|
| Some x ->
|
|
Pbrt.Encoder.key (15, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.nested (encode_status x) encoder;
|
|
| None -> ();
|
|
end;
|
|
()
|
|
|
|
let rec encode_scope_spans (v:Trace_types.scope_spans) encoder =
|
|
begin match v.Trace_types.scope with
|
|
| Some x ->
|
|
Pbrt.Encoder.key (1, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.nested (Common_pb.encode_instrumentation_scope x) encoder;
|
|
| None -> ();
|
|
end;
|
|
List.iter (fun x ->
|
|
Pbrt.Encoder.key (2, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.nested (encode_span x) encoder;
|
|
) v.Trace_types.spans;
|
|
Pbrt.Encoder.key (3, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.string v.Trace_types.schema_url encoder;
|
|
()
|
|
|
|
let rec encode_resource_spans (v:Trace_types.resource_spans) encoder =
|
|
begin match v.Trace_types.resource with
|
|
| Some x ->
|
|
Pbrt.Encoder.key (1, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.nested (Resource_pb.encode_resource x) encoder;
|
|
| None -> ();
|
|
end;
|
|
List.iter (fun x ->
|
|
Pbrt.Encoder.key (2, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.nested (encode_scope_spans x) encoder;
|
|
) v.Trace_types.scope_spans;
|
|
Pbrt.Encoder.key (3, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.string v.Trace_types.schema_url encoder;
|
|
()
|
|
|
|
let rec encode_traces_data (v:Trace_types.traces_data) encoder =
|
|
List.iter (fun x ->
|
|
Pbrt.Encoder.key (1, Pbrt.Bytes) encoder;
|
|
Pbrt.Encoder.nested (encode_resource_spans x) encoder;
|
|
) v.Trace_types.resource_spans;
|
|
()
|