From 30ddf7e6adc20479ae19e5760f15e4a3135fc5c7 Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Mon, 15 Aug 2022 13:53:32 -0400 Subject: [PATCH 1/7] chore: update vendored otel to 0.19 --- vendor/opentelemetry-proto | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/vendor/opentelemetry-proto b/vendor/opentelemetry-proto index cc4ed55c..6459e1aa 160000 --- a/vendor/opentelemetry-proto +++ b/vendor/opentelemetry-proto @@ -1 +1 @@ -Subproject commit cc4ed55c082cb75e084d40b4ddf3805eda099f97 +Subproject commit 6459e1aae1c22e273ac92be86016f0ae55a2430a From 8b1b6aecf219562170ed528d6b1cd6d44ad14427 Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Mon, 15 Aug 2022 13:54:11 -0400 Subject: [PATCH 2/7] update codegenerated protos 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 --- src/common_pb.ml | 39 ++++++++--- src/common_pb.mli | 8 +-- src/common_pp.ml | 4 +- src/common_pp.mli | 4 +- src/common_types.ml | 12 +++- src/common_types.mli | 12 ++-- src/logs_pb.ml | 54 ++++++-------- src/logs_pb.mli | 8 +-- src/logs_pp.ml | 7 +- src/logs_pp.mli | 4 +- src/logs_service_pb.ml | 76 ++++++++++++++++++++ src/logs_service_pb.mli | 12 ++++ src/logs_service_pp.ml | 13 ++++ src/logs_service_pp.mli | 6 ++ src/logs_service_types.ml | 23 ++++++ src/logs_service_types.mli | 22 ++++++ src/logs_types.ml | 21 +++--- src/logs_types.mli | 18 +++-- src/metrics_pb.ml | 128 +++++++++++++++++++++++++--------- src/metrics_pb.mli | 8 +-- src/metrics_pp.ml | 14 ++-- src/metrics_pp.mli | 4 +- src/metrics_service_pb.ml | 76 ++++++++++++++++++++ src/metrics_service_pb.mli | 12 ++++ src/metrics_service_pp.ml | 13 ++++ src/metrics_service_pp.mli | 6 ++ src/metrics_service_types.ml | 23 ++++++ src/metrics_service_types.mli | 22 ++++++ src/metrics_types.ml | 38 ++++++---- src/metrics_types.mli | 32 +++++---- src/trace_pb.ml | 44 ++++++------ src/trace_pb.mli | 8 +-- src/trace_pp.ml | 6 +- src/trace_pp.mli | 4 +- src/trace_service_pb.ml | 76 ++++++++++++++++++++ src/trace_service_pb.mli | 12 ++++ src/trace_service_pp.ml | 13 ++++ src/trace_service_pp.mli | 6 ++ src/trace_service_types.ml | 23 ++++++ src/trace_service_types.mli | 22 ++++++ src/trace_types.ml | 18 ++--- src/trace_types.mli | 16 ++--- 42 files changed, 765 insertions(+), 202 deletions(-) diff --git a/src/common_pb.ml b/src/common_pb.ml index 0d0fa8c3..07425f0f 100644 --- a/src/common_pb.ml +++ b/src/common_pb.ml @@ -26,14 +26,18 @@ let default_key_value_mutable () : key_value_mutable = { value = None; } -type instrumentation_library_mutable = { +type instrumentation_scope_mutable = { mutable name : string; mutable version : string; + mutable attributes : Common_types.key_value list; + mutable dropped_attributes_count : int32; } -let default_instrumentation_library_mutable () : instrumentation_library_mutable = { +let default_instrumentation_scope_mutable () : instrumentation_scope_mutable = { name = ""; version = ""; + attributes = []; + dropped_attributes_count = 0l; } @@ -119,29 +123,42 @@ and decode_key_value d = Common_types.value = v.value; } : Common_types.key_value) -let rec decode_instrumentation_library d = - let v = default_instrumentation_library_mutable () in +let rec decode_instrumentation_scope d = + let v = default_instrumentation_scope_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.name <- Pbrt.Decoder.string d; end | Some (1, pk) -> - Pbrt.Decoder.unexpected_payload "Message(instrumentation_library), field(1)" pk + Pbrt.Decoder.unexpected_payload "Message(instrumentation_scope), field(1)" pk | Some (2, Pbrt.Bytes) -> begin v.version <- Pbrt.Decoder.string d; end | Some (2, pk) -> - Pbrt.Decoder.unexpected_payload "Message(instrumentation_library), field(2)" pk + Pbrt.Decoder.unexpected_payload "Message(instrumentation_scope), field(2)" pk + | Some (3, Pbrt.Bytes) -> begin + v.attributes <- (decode_key_value (Pbrt.Decoder.nested d)) :: v.attributes; + end + | Some (3, pk) -> + Pbrt.Decoder.unexpected_payload "Message(instrumentation_scope), 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(instrumentation_scope), field(4)" pk | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind done; ({ Common_types.name = v.name; Common_types.version = v.version; - } : Common_types.instrumentation_library) + Common_types.attributes = v.attributes; + Common_types.dropped_attributes_count = v.dropped_attributes_count; + } : Common_types.instrumentation_scope) let rec encode_any_value (v:Common_types.any_value) encoder = begin match v with @@ -193,9 +210,15 @@ and encode_key_value (v:Common_types.key_value) encoder = end; () -let rec encode_instrumentation_library (v:Common_types.instrumentation_library) encoder = +let rec encode_instrumentation_scope (v:Common_types.instrumentation_scope) encoder = Pbrt.Encoder.key (1, Pbrt.Bytes) encoder; Pbrt.Encoder.string v.Common_types.name encoder; Pbrt.Encoder.key (2, Pbrt.Bytes) encoder; Pbrt.Encoder.string v.Common_types.version encoder; + List.iter (fun x -> + Pbrt.Encoder.key (3, Pbrt.Bytes) encoder; + Pbrt.Encoder.nested (encode_key_value x) encoder; + ) v.Common_types.attributes; + Pbrt.Encoder.key (4, Pbrt.Varint) encoder; + Pbrt.Encoder.int32_as_varint v.Common_types.dropped_attributes_count encoder; () diff --git a/src/common_pb.mli b/src/common_pb.mli index 0f23b6d0..7ece8615 100644 --- a/src/common_pb.mli +++ b/src/common_pb.mli @@ -15,8 +15,8 @@ val encode_key_value_list : Common_types.key_value_list -> Pbrt.Encoder.t -> uni val encode_key_value : Common_types.key_value -> Pbrt.Encoder.t -> unit (** [encode_key_value v encoder] encodes [v] with the given [encoder] *) -val encode_instrumentation_library : Common_types.instrumentation_library -> Pbrt.Encoder.t -> unit -(** [encode_instrumentation_library v encoder] encodes [v] with the given [encoder] *) +val encode_instrumentation_scope : Common_types.instrumentation_scope -> Pbrt.Encoder.t -> unit +(** [encode_instrumentation_scope v encoder] encodes [v] with the given [encoder] *) (** {2 Protobuf Decoding} *) @@ -33,5 +33,5 @@ val decode_key_value_list : Pbrt.Decoder.t -> Common_types.key_value_list val decode_key_value : Pbrt.Decoder.t -> Common_types.key_value (** [decode_key_value decoder] decodes a [key_value] value from [decoder] *) -val decode_instrumentation_library : Pbrt.Decoder.t -> Common_types.instrumentation_library -(** [decode_instrumentation_library decoder] decodes a [instrumentation_library] value from [decoder] *) +val decode_instrumentation_scope : Pbrt.Decoder.t -> Common_types.instrumentation_scope +(** [decode_instrumentation_scope decoder] decodes a [instrumentation_scope] value from [decoder] *) diff --git a/src/common_pp.ml b/src/common_pp.ml index 634c598f..e809bafc 100644 --- a/src/common_pp.ml +++ b/src/common_pp.ml @@ -29,9 +29,11 @@ and pp_key_value fmt (v:Common_types.key_value) = in Pbrt.Pp.pp_brk pp_i fmt () -let rec pp_instrumentation_library fmt (v:Common_types.instrumentation_library) = +let rec pp_instrumentation_scope fmt (v:Common_types.instrumentation_scope) = let pp_i fmt () = Pbrt.Pp.pp_record_field ~first:true "name" Pbrt.Pp.pp_string fmt v.Common_types.name; Pbrt.Pp.pp_record_field ~first:false "version" Pbrt.Pp.pp_string fmt v.Common_types.version; + Pbrt.Pp.pp_record_field ~first:false "attributes" (Pbrt.Pp.pp_list pp_key_value) fmt v.Common_types.attributes; + Pbrt.Pp.pp_record_field ~first:false "dropped_attributes_count" Pbrt.Pp.pp_int32 fmt v.Common_types.dropped_attributes_count; in Pbrt.Pp.pp_brk pp_i fmt () diff --git a/src/common_pp.mli b/src/common_pp.mli index f6355812..4c2fc14d 100644 --- a/src/common_pp.mli +++ b/src/common_pp.mli @@ -15,5 +15,5 @@ val pp_key_value_list : Format.formatter -> Common_types.key_value_list -> unit val pp_key_value : Format.formatter -> Common_types.key_value -> unit (** [pp_key_value v] formats v *) -val pp_instrumentation_library : Format.formatter -> Common_types.instrumentation_library -> unit -(** [pp_instrumentation_library v] formats v *) +val pp_instrumentation_scope : Format.formatter -> Common_types.instrumentation_scope -> unit +(** [pp_instrumentation_scope v] formats v *) diff --git a/src/common_types.ml b/src/common_types.ml index c53b3f1f..bddc9354 100644 --- a/src/common_types.ml +++ b/src/common_types.ml @@ -23,9 +23,11 @@ and key_value = { value : any_value option; } -type instrumentation_library = { +type instrumentation_scope = { name : string; version : string; + attributes : key_value list; + dropped_attributes_count : int32; } let rec default_any_value () : any_value = String_value ("") @@ -50,10 +52,14 @@ and default_key_value value; } -let rec default_instrumentation_library +let rec default_instrumentation_scope ?name:((name:string) = "") ?version:((version:string) = "") - () : instrumentation_library = { + ?attributes:((attributes:key_value list) = []) + ?dropped_attributes_count:((dropped_attributes_count:int32) = 0l) + () : instrumentation_scope = { name; version; + attributes; + dropped_attributes_count; } diff --git a/src/common_types.mli b/src/common_types.mli index f81d7095..8427638a 100644 --- a/src/common_types.mli +++ b/src/common_types.mli @@ -26,9 +26,11 @@ and key_value = { value : any_value option; } -type instrumentation_library = { +type instrumentation_scope = { name : string; version : string; + attributes : key_value list; + dropped_attributes_count : int32; } @@ -56,9 +58,11 @@ val default_key_value : key_value (** [default_key_value ()] is the default value for type [key_value] *) -val default_instrumentation_library : +val default_instrumentation_scope : ?name:string -> ?version:string -> + ?attributes:key_value list -> + ?dropped_attributes_count:int32 -> unit -> - instrumentation_library -(** [default_instrumentation_library ()] is the default value for type [instrumentation_library] *) + instrumentation_scope +(** [default_instrumentation_scope ()] is the default value for type [instrumentation_scope] *) diff --git a/src/logs_pb.ml b/src/logs_pb.ml index 3ec4685a..b604b0d9 100644 --- a/src/logs_pb.ml +++ b/src/logs_pb.ml @@ -5,7 +5,6 @@ type log_record_mutable = { mutable observed_time_unix_nano : int64; mutable severity_number : Logs_types.severity_number; mutable severity_text : string; - mutable name : string; mutable body : Common_types.any_value option; mutable attributes : Common_types.key_value list; mutable dropped_attributes_count : int32; @@ -19,7 +18,6 @@ let default_log_record_mutable () : log_record_mutable = { observed_time_unix_nano = 0L; severity_number = Logs_types.default_severity_number (); severity_text = ""; - name = ""; body = None; attributes = []; dropped_attributes_count = 0l; @@ -28,27 +26,27 @@ let default_log_record_mutable () : log_record_mutable = { span_id = Bytes.create 0; } -type instrumentation_library_logs_mutable = { - mutable instrumentation_library : Common_types.instrumentation_library option; +type scope_logs_mutable = { + mutable scope : Common_types.instrumentation_scope option; mutable log_records : Logs_types.log_record list; mutable schema_url : string; } -let default_instrumentation_library_logs_mutable () : instrumentation_library_logs_mutable = { - instrumentation_library = None; +let default_scope_logs_mutable () : scope_logs_mutable = { + scope = None; log_records = []; schema_url = ""; } type resource_logs_mutable = { mutable resource : Resource_types.resource option; - mutable instrumentation_library_logs : Logs_types.instrumentation_library_logs list; + mutable scope_logs : Logs_types.scope_logs list; mutable schema_url : string; } let default_resource_logs_mutable () : resource_logs_mutable = { resource = None; - instrumentation_library_logs = []; + scope_logs = []; schema_url = ""; } @@ -118,11 +116,6 @@ let rec decode_log_record d = end | Some (3, pk) -> Pbrt.Decoder.unexpected_payload "Message(log_record), field(3)" pk - | Some (4, Pbrt.Bytes) -> begin - v.name <- Pbrt.Decoder.string d; - end - | Some (4, pk) -> - Pbrt.Decoder.unexpected_payload "Message(log_record), field(4)" pk | Some (5, Pbrt.Bytes) -> begin v.body <- Some (Common_pb.decode_any_value (Pbrt.Decoder.nested d)); end @@ -160,7 +153,6 @@ let rec decode_log_record d = Logs_types.observed_time_unix_nano = v.observed_time_unix_nano; Logs_types.severity_number = v.severity_number; Logs_types.severity_text = v.severity_text; - Logs_types.name = v.name; Logs_types.body = v.body; Logs_types.attributes = v.attributes; Logs_types.dropped_attributes_count = v.dropped_attributes_count; @@ -169,8 +161,8 @@ let rec decode_log_record d = Logs_types.span_id = v.span_id; } : Logs_types.log_record) -let rec decode_instrumentation_library_logs d = - let v = default_instrumentation_library_logs_mutable () in +let rec decode_scope_logs d = + let v = default_scope_logs_mutable () in let continue__= ref true in while !continue__ do match Pbrt.Decoder.key d with @@ -178,27 +170,27 @@ let rec decode_instrumentation_library_logs d = v.log_records <- List.rev v.log_records; ); continue__ := false | Some (1, Pbrt.Bytes) -> begin - v.instrumentation_library <- Some (Common_pb.decode_instrumentation_library (Pbrt.Decoder.nested d)); + v.scope <- Some (Common_pb.decode_instrumentation_scope (Pbrt.Decoder.nested d)); end | Some (1, pk) -> - Pbrt.Decoder.unexpected_payload "Message(instrumentation_library_logs), field(1)" pk + Pbrt.Decoder.unexpected_payload "Message(scope_logs), field(1)" pk | Some (2, Pbrt.Bytes) -> begin v.log_records <- (decode_log_record (Pbrt.Decoder.nested d)) :: v.log_records; end | Some (2, pk) -> - Pbrt.Decoder.unexpected_payload "Message(instrumentation_library_logs), field(2)" pk + Pbrt.Decoder.unexpected_payload "Message(scope_logs), field(2)" pk | Some (3, Pbrt.Bytes) -> begin v.schema_url <- Pbrt.Decoder.string d; end | Some (3, pk) -> - Pbrt.Decoder.unexpected_payload "Message(instrumentation_library_logs), field(3)" pk + Pbrt.Decoder.unexpected_payload "Message(scope_logs), field(3)" pk | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind done; ({ - Logs_types.instrumentation_library = v.instrumentation_library; + Logs_types.scope = v.scope; Logs_types.log_records = v.log_records; Logs_types.schema_url = v.schema_url; - } : Logs_types.instrumentation_library_logs) + } : Logs_types.scope_logs) let rec decode_resource_logs d = let v = default_resource_logs_mutable () in @@ -206,7 +198,7 @@ let rec decode_resource_logs d = while !continue__ do match Pbrt.Decoder.key d with | None -> ( - v.instrumentation_library_logs <- List.rev v.instrumentation_library_logs; + v.scope_logs <- List.rev v.scope_logs; ); continue__ := false | Some (1, Pbrt.Bytes) -> begin v.resource <- Some (Resource_pb.decode_resource (Pbrt.Decoder.nested d)); @@ -214,7 +206,7 @@ let rec decode_resource_logs d = | Some (1, pk) -> Pbrt.Decoder.unexpected_payload "Message(resource_logs), field(1)" pk | Some (2, Pbrt.Bytes) -> begin - v.instrumentation_library_logs <- (decode_instrumentation_library_logs (Pbrt.Decoder.nested d)) :: v.instrumentation_library_logs; + v.scope_logs <- (decode_scope_logs (Pbrt.Decoder.nested d)) :: v.scope_logs; end | Some (2, pk) -> Pbrt.Decoder.unexpected_payload "Message(resource_logs), field(2)" pk @@ -227,7 +219,7 @@ let rec decode_resource_logs d = done; ({ Logs_types.resource = v.resource; - Logs_types.instrumentation_library_logs = v.instrumentation_library_logs; + Logs_types.scope_logs = v.scope_logs; Logs_types.schema_url = v.schema_url; } : Logs_types.resource_logs) @@ -293,8 +285,6 @@ let rec encode_log_record (v:Logs_types.log_record) encoder = encode_severity_number v.Logs_types.severity_number encoder; Pbrt.Encoder.key (3, Pbrt.Bytes) encoder; Pbrt.Encoder.string v.Logs_types.severity_text encoder; - Pbrt.Encoder.key (4, Pbrt.Bytes) encoder; - Pbrt.Encoder.string v.Logs_types.name encoder; begin match v.Logs_types.body with | Some x -> Pbrt.Encoder.key (5, Pbrt.Bytes) encoder; @@ -315,11 +305,11 @@ let rec encode_log_record (v:Logs_types.log_record) encoder = Pbrt.Encoder.bytes v.Logs_types.span_id encoder; () -let rec encode_instrumentation_library_logs (v:Logs_types.instrumentation_library_logs) encoder = - begin match v.Logs_types.instrumentation_library with +let rec encode_scope_logs (v:Logs_types.scope_logs) encoder = + begin match v.Logs_types.scope with | Some x -> Pbrt.Encoder.key (1, Pbrt.Bytes) encoder; - Pbrt.Encoder.nested (Common_pb.encode_instrumentation_library x) encoder; + Pbrt.Encoder.nested (Common_pb.encode_instrumentation_scope x) encoder; | None -> (); end; List.iter (fun x -> @@ -339,8 +329,8 @@ let rec encode_resource_logs (v:Logs_types.resource_logs) encoder = end; List.iter (fun x -> Pbrt.Encoder.key (2, Pbrt.Bytes) encoder; - Pbrt.Encoder.nested (encode_instrumentation_library_logs x) encoder; - ) v.Logs_types.instrumentation_library_logs; + Pbrt.Encoder.nested (encode_scope_logs x) encoder; + ) v.Logs_types.scope_logs; Pbrt.Encoder.key (3, Pbrt.Bytes) encoder; Pbrt.Encoder.string v.Logs_types.schema_url encoder; () diff --git a/src/logs_pb.mli b/src/logs_pb.mli index c91527be..93e6d369 100644 --- a/src/logs_pb.mli +++ b/src/logs_pb.mli @@ -9,8 +9,8 @@ val encode_severity_number : Logs_types.severity_number -> Pbrt.Encoder.t -> uni val encode_log_record : Logs_types.log_record -> Pbrt.Encoder.t -> unit (** [encode_log_record v encoder] encodes [v] with the given [encoder] *) -val encode_instrumentation_library_logs : Logs_types.instrumentation_library_logs -> Pbrt.Encoder.t -> unit -(** [encode_instrumentation_library_logs v encoder] encodes [v] with the given [encoder] *) +val encode_scope_logs : Logs_types.scope_logs -> Pbrt.Encoder.t -> unit +(** [encode_scope_logs v encoder] encodes [v] with the given [encoder] *) val encode_resource_logs : Logs_types.resource_logs -> Pbrt.Encoder.t -> unit (** [encode_resource_logs v encoder] encodes [v] with the given [encoder] *) @@ -30,8 +30,8 @@ val decode_severity_number : Pbrt.Decoder.t -> Logs_types.severity_number val decode_log_record : Pbrt.Decoder.t -> Logs_types.log_record (** [decode_log_record decoder] decodes a [log_record] value from [decoder] *) -val decode_instrumentation_library_logs : Pbrt.Decoder.t -> Logs_types.instrumentation_library_logs -(** [decode_instrumentation_library_logs decoder] decodes a [instrumentation_library_logs] value from [decoder] *) +val decode_scope_logs : Pbrt.Decoder.t -> Logs_types.scope_logs +(** [decode_scope_logs decoder] decodes a [scope_logs] value from [decoder] *) val decode_resource_logs : Pbrt.Decoder.t -> Logs_types.resource_logs (** [decode_resource_logs decoder] decodes a [resource_logs] value from [decoder] *) diff --git a/src/logs_pp.ml b/src/logs_pp.ml index 2e5e70e2..99a084a3 100644 --- a/src/logs_pp.ml +++ b/src/logs_pp.ml @@ -34,7 +34,6 @@ let rec pp_log_record fmt (v:Logs_types.log_record) = Pbrt.Pp.pp_record_field ~first:false "observed_time_unix_nano" Pbrt.Pp.pp_int64 fmt v.Logs_types.observed_time_unix_nano; Pbrt.Pp.pp_record_field ~first:false "severity_number" pp_severity_number fmt v.Logs_types.severity_number; Pbrt.Pp.pp_record_field ~first:false "severity_text" Pbrt.Pp.pp_string fmt v.Logs_types.severity_text; - Pbrt.Pp.pp_record_field ~first:false "name" Pbrt.Pp.pp_string fmt v.Logs_types.name; Pbrt.Pp.pp_record_field ~first:false "body" (Pbrt.Pp.pp_option Common_pp.pp_any_value) fmt v.Logs_types.body; Pbrt.Pp.pp_record_field ~first:false "attributes" (Pbrt.Pp.pp_list Common_pp.pp_key_value) fmt v.Logs_types.attributes; Pbrt.Pp.pp_record_field ~first:false "dropped_attributes_count" Pbrt.Pp.pp_int32 fmt v.Logs_types.dropped_attributes_count; @@ -44,9 +43,9 @@ let rec pp_log_record fmt (v:Logs_types.log_record) = in Pbrt.Pp.pp_brk pp_i fmt () -let rec pp_instrumentation_library_logs fmt (v:Logs_types.instrumentation_library_logs) = +let rec pp_scope_logs fmt (v:Logs_types.scope_logs) = let pp_i fmt () = - Pbrt.Pp.pp_record_field ~first:true "instrumentation_library" (Pbrt.Pp.pp_option Common_pp.pp_instrumentation_library) fmt v.Logs_types.instrumentation_library; + Pbrt.Pp.pp_record_field ~first:true "scope" (Pbrt.Pp.pp_option Common_pp.pp_instrumentation_scope) fmt v.Logs_types.scope; Pbrt.Pp.pp_record_field ~first:false "log_records" (Pbrt.Pp.pp_list pp_log_record) fmt v.Logs_types.log_records; Pbrt.Pp.pp_record_field ~first:false "schema_url" Pbrt.Pp.pp_string fmt v.Logs_types.schema_url; in @@ -55,7 +54,7 @@ let rec pp_instrumentation_library_logs fmt (v:Logs_types.instrumentation_librar let rec pp_resource_logs fmt (v:Logs_types.resource_logs) = let pp_i fmt () = Pbrt.Pp.pp_record_field ~first:true "resource" (Pbrt.Pp.pp_option Resource_pp.pp_resource) fmt v.Logs_types.resource; - Pbrt.Pp.pp_record_field ~first:false "instrumentation_library_logs" (Pbrt.Pp.pp_list pp_instrumentation_library_logs) fmt v.Logs_types.instrumentation_library_logs; + Pbrt.Pp.pp_record_field ~first:false "scope_logs" (Pbrt.Pp.pp_list pp_scope_logs) fmt v.Logs_types.scope_logs; Pbrt.Pp.pp_record_field ~first:false "schema_url" Pbrt.Pp.pp_string fmt v.Logs_types.schema_url; in Pbrt.Pp.pp_brk pp_i fmt () diff --git a/src/logs_pp.mli b/src/logs_pp.mli index 0ebaa575..fd952524 100644 --- a/src/logs_pp.mli +++ b/src/logs_pp.mli @@ -9,8 +9,8 @@ val pp_severity_number : Format.formatter -> Logs_types.severity_number -> unit val pp_log_record : Format.formatter -> Logs_types.log_record -> unit (** [pp_log_record v] formats v *) -val pp_instrumentation_library_logs : Format.formatter -> Logs_types.instrumentation_library_logs -> unit -(** [pp_instrumentation_library_logs v] formats v *) +val pp_scope_logs : Format.formatter -> Logs_types.scope_logs -> unit +(** [pp_scope_logs v] formats v *) val pp_resource_logs : Format.formatter -> Logs_types.resource_logs -> unit (** [pp_resource_logs v] formats v *) diff --git a/src/logs_service_pb.ml b/src/logs_service_pb.ml index 623d903e..64fde20f 100644 --- a/src/logs_service_pb.ml +++ b/src/logs_service_pb.ml @@ -8,6 +8,24 @@ let default_export_logs_service_request_mutable () : export_logs_service_request resource_logs = []; } +type export_logs_partial_success_mutable = { + mutable rejected_log_records : int64; + mutable error_message : string; +} + +let default_export_logs_partial_success_mutable () : export_logs_partial_success_mutable = { + rejected_log_records = 0L; + error_message = ""; +} + +type export_logs_service_response_mutable = { + mutable partial_success : Logs_service_types.export_logs_partial_success option; +} + +let default_export_logs_service_response_mutable () : export_logs_service_response_mutable = { + partial_success = None; +} + let rec decode_export_logs_service_request d = let v = default_export_logs_service_request_mutable () in @@ -28,9 +46,67 @@ let rec decode_export_logs_service_request d = Logs_service_types.resource_logs = v.resource_logs; } : Logs_service_types.export_logs_service_request) +let rec decode_export_logs_partial_success d = + let v = default_export_logs_partial_success_mutable () in + let continue__= ref true in + while !continue__ do + match Pbrt.Decoder.key d with + | None -> ( + ); continue__ := false + | Some (1, Pbrt.Varint) -> begin + v.rejected_log_records <- Pbrt.Decoder.int64_as_varint d; + end + | Some (1, pk) -> + Pbrt.Decoder.unexpected_payload "Message(export_logs_partial_success), field(1)" pk + | Some (2, Pbrt.Bytes) -> begin + v.error_message <- Pbrt.Decoder.string d; + end + | Some (2, pk) -> + Pbrt.Decoder.unexpected_payload "Message(export_logs_partial_success), field(2)" pk + | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind + done; + ({ + Logs_service_types.rejected_log_records = v.rejected_log_records; + Logs_service_types.error_message = v.error_message; + } : Logs_service_types.export_logs_partial_success) + +let rec decode_export_logs_service_response d = + let v = default_export_logs_service_response_mutable () in + let continue__= ref true in + while !continue__ do + match Pbrt.Decoder.key d with + | None -> ( + ); continue__ := false + | Some (1, Pbrt.Bytes) -> begin + v.partial_success <- Some (decode_export_logs_partial_success (Pbrt.Decoder.nested d)); + end + | Some (1, pk) -> + Pbrt.Decoder.unexpected_payload "Message(export_logs_service_response), field(1)" pk + | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind + done; + ({ + Logs_service_types.partial_success = v.partial_success; + } : Logs_service_types.export_logs_service_response) + let rec encode_export_logs_service_request (v:Logs_service_types.export_logs_service_request) encoder = List.iter (fun x -> Pbrt.Encoder.key (1, Pbrt.Bytes) encoder; Pbrt.Encoder.nested (Logs_pb.encode_resource_logs x) encoder; ) v.Logs_service_types.resource_logs; () + +let rec encode_export_logs_partial_success (v:Logs_service_types.export_logs_partial_success) encoder = + Pbrt.Encoder.key (1, Pbrt.Varint) encoder; + Pbrt.Encoder.int64_as_varint v.Logs_service_types.rejected_log_records encoder; + Pbrt.Encoder.key (2, Pbrt.Bytes) encoder; + Pbrt.Encoder.string v.Logs_service_types.error_message encoder; + () + +let rec encode_export_logs_service_response (v:Logs_service_types.export_logs_service_response) encoder = + begin match v.Logs_service_types.partial_success with + | Some x -> + Pbrt.Encoder.key (1, Pbrt.Bytes) encoder; + Pbrt.Encoder.nested (encode_export_logs_partial_success x) encoder; + | None -> (); + end; + () diff --git a/src/logs_service_pb.mli b/src/logs_service_pb.mli index ce1c2c9a..db4d8c89 100644 --- a/src/logs_service_pb.mli +++ b/src/logs_service_pb.mli @@ -6,8 +6,20 @@ val encode_export_logs_service_request : Logs_service_types.export_logs_service_request -> Pbrt.Encoder.t -> unit (** [encode_export_logs_service_request v encoder] encodes [v] with the given [encoder] *) +val encode_export_logs_partial_success : Logs_service_types.export_logs_partial_success -> Pbrt.Encoder.t -> unit +(** [encode_export_logs_partial_success v encoder] encodes [v] with the given [encoder] *) + +val encode_export_logs_service_response : Logs_service_types.export_logs_service_response -> Pbrt.Encoder.t -> unit +(** [encode_export_logs_service_response v encoder] encodes [v] with the given [encoder] *) + (** {2 Protobuf Decoding} *) val decode_export_logs_service_request : Pbrt.Decoder.t -> Logs_service_types.export_logs_service_request (** [decode_export_logs_service_request decoder] decodes a [export_logs_service_request] value from [decoder] *) + +val decode_export_logs_partial_success : Pbrt.Decoder.t -> Logs_service_types.export_logs_partial_success +(** [decode_export_logs_partial_success decoder] decodes a [export_logs_partial_success] value from [decoder] *) + +val decode_export_logs_service_response : Pbrt.Decoder.t -> Logs_service_types.export_logs_service_response +(** [decode_export_logs_service_response decoder] decodes a [export_logs_service_response] value from [decoder] *) diff --git a/src/logs_service_pp.ml b/src/logs_service_pp.ml index 1372330e..19830e4c 100644 --- a/src/logs_service_pp.ml +++ b/src/logs_service_pp.ml @@ -5,3 +5,16 @@ let rec pp_export_logs_service_request fmt (v:Logs_service_types.export_logs_ser Pbrt.Pp.pp_record_field ~first:true "resource_logs" (Pbrt.Pp.pp_list Logs_pp.pp_resource_logs) fmt v.Logs_service_types.resource_logs; in Pbrt.Pp.pp_brk pp_i fmt () + +let rec pp_export_logs_partial_success fmt (v:Logs_service_types.export_logs_partial_success) = + let pp_i fmt () = + Pbrt.Pp.pp_record_field ~first:true "rejected_log_records" Pbrt.Pp.pp_int64 fmt v.Logs_service_types.rejected_log_records; + Pbrt.Pp.pp_record_field ~first:false "error_message" Pbrt.Pp.pp_string fmt v.Logs_service_types.error_message; + in + Pbrt.Pp.pp_brk pp_i fmt () + +let rec pp_export_logs_service_response fmt (v:Logs_service_types.export_logs_service_response) = + let pp_i fmt () = + Pbrt.Pp.pp_record_field ~first:true "partial_success" (Pbrt.Pp.pp_option pp_export_logs_partial_success) fmt v.Logs_service_types.partial_success; + in + Pbrt.Pp.pp_brk pp_i fmt () diff --git a/src/logs_service_pp.mli b/src/logs_service_pp.mli index d282ea85..6aa6319f 100644 --- a/src/logs_service_pp.mli +++ b/src/logs_service_pp.mli @@ -5,3 +5,9 @@ val pp_export_logs_service_request : Format.formatter -> Logs_service_types.export_logs_service_request -> unit (** [pp_export_logs_service_request v] formats v *) + +val pp_export_logs_partial_success : Format.formatter -> Logs_service_types.export_logs_partial_success -> unit +(** [pp_export_logs_partial_success v] formats v *) + +val pp_export_logs_service_response : Format.formatter -> Logs_service_types.export_logs_service_response -> unit +(** [pp_export_logs_service_response v] formats v *) diff --git a/src/logs_service_types.ml b/src/logs_service_types.ml index 36b9a306..9bf19974 100644 --- a/src/logs_service_types.ml +++ b/src/logs_service_types.ml @@ -5,8 +5,31 @@ type export_logs_service_request = { resource_logs : Logs_types.resource_logs list; } +type export_logs_partial_success = { + rejected_log_records : int64; + error_message : string; +} + +type export_logs_service_response = { + partial_success : export_logs_partial_success option; +} + let rec default_export_logs_service_request ?resource_logs:((resource_logs:Logs_types.resource_logs list) = []) () : export_logs_service_request = { resource_logs; } + +let rec default_export_logs_partial_success + ?rejected_log_records:((rejected_log_records:int64) = 0L) + ?error_message:((error_message:string) = "") + () : export_logs_partial_success = { + rejected_log_records; + error_message; +} + +let rec default_export_logs_service_response + ?partial_success:((partial_success:export_logs_partial_success option) = None) + () : export_logs_service_response = { + partial_success; +} diff --git a/src/logs_service_types.mli b/src/logs_service_types.mli index 571d6c7a..beef4fd3 100644 --- a/src/logs_service_types.mli +++ b/src/logs_service_types.mli @@ -8,6 +8,15 @@ type export_logs_service_request = { resource_logs : Logs_types.resource_logs list; } +type export_logs_partial_success = { + rejected_log_records : int64; + error_message : string; +} + +type export_logs_service_response = { + partial_success : export_logs_partial_success option; +} + (** {2 Default values} *) @@ -16,3 +25,16 @@ val default_export_logs_service_request : unit -> export_logs_service_request (** [default_export_logs_service_request ()] is the default value for type [export_logs_service_request] *) + +val default_export_logs_partial_success : + ?rejected_log_records:int64 -> + ?error_message:string -> + unit -> + export_logs_partial_success +(** [default_export_logs_partial_success ()] is the default value for type [export_logs_partial_success] *) + +val default_export_logs_service_response : + ?partial_success:export_logs_partial_success option -> + unit -> + export_logs_service_response +(** [default_export_logs_service_response ()] is the default value for type [export_logs_service_response] *) diff --git a/src/logs_types.ml b/src/logs_types.ml index 894bf662..49c11502 100644 --- a/src/logs_types.ml +++ b/src/logs_types.ml @@ -33,7 +33,6 @@ type log_record = { observed_time_unix_nano : int64; severity_number : severity_number; severity_text : string; - name : string; body : Common_types.any_value option; attributes : Common_types.key_value list; dropped_attributes_count : int32; @@ -42,15 +41,15 @@ type log_record = { span_id : bytes; } -type instrumentation_library_logs = { - instrumentation_library : Common_types.instrumentation_library option; +type scope_logs = { + scope : Common_types.instrumentation_scope option; log_records : log_record list; schema_url : string; } type resource_logs = { resource : Resource_types.resource option; - instrumentation_library_logs : instrumentation_library_logs list; + scope_logs : scope_logs list; schema_url : string; } @@ -69,7 +68,6 @@ let rec default_log_record ?observed_time_unix_nano:((observed_time_unix_nano:int64) = 0L) ?severity_number:((severity_number:severity_number) = default_severity_number ()) ?severity_text:((severity_text:string) = "") - ?name:((name:string) = "") ?body:((body:Common_types.any_value option) = None) ?attributes:((attributes:Common_types.key_value list) = []) ?dropped_attributes_count:((dropped_attributes_count:int32) = 0l) @@ -81,7 +79,6 @@ let rec default_log_record observed_time_unix_nano; severity_number; severity_text; - name; body; attributes; dropped_attributes_count; @@ -90,23 +87,23 @@ let rec default_log_record span_id; } -let rec default_instrumentation_library_logs - ?instrumentation_library:((instrumentation_library:Common_types.instrumentation_library option) = None) +let rec default_scope_logs + ?scope:((scope:Common_types.instrumentation_scope option) = None) ?log_records:((log_records:log_record list) = []) ?schema_url:((schema_url:string) = "") - () : instrumentation_library_logs = { - instrumentation_library; + () : scope_logs = { + scope; log_records; schema_url; } let rec default_resource_logs ?resource:((resource:Resource_types.resource option) = None) - ?instrumentation_library_logs:((instrumentation_library_logs:instrumentation_library_logs list) = []) + ?scope_logs:((scope_logs:scope_logs list) = []) ?schema_url:((schema_url:string) = "") () : resource_logs = { resource; - instrumentation_library_logs; + scope_logs; schema_url; } diff --git a/src/logs_types.mli b/src/logs_types.mli index 2f9694de..ab599f1c 100644 --- a/src/logs_types.mli +++ b/src/logs_types.mli @@ -36,7 +36,6 @@ type log_record = { observed_time_unix_nano : int64; severity_number : severity_number; severity_text : string; - name : string; body : Common_types.any_value option; attributes : Common_types.key_value list; dropped_attributes_count : int32; @@ -45,15 +44,15 @@ type log_record = { span_id : bytes; } -type instrumentation_library_logs = { - instrumentation_library : Common_types.instrumentation_library option; +type scope_logs = { + scope : Common_types.instrumentation_scope option; log_records : log_record list; schema_url : string; } type resource_logs = { resource : Resource_types.resource option; - instrumentation_library_logs : instrumentation_library_logs list; + scope_logs : scope_logs list; schema_url : string; } @@ -76,7 +75,6 @@ val default_log_record : ?observed_time_unix_nano:int64 -> ?severity_number:severity_number -> ?severity_text:string -> - ?name:string -> ?body:Common_types.any_value option -> ?attributes:Common_types.key_value list -> ?dropped_attributes_count:int32 -> @@ -87,17 +85,17 @@ val default_log_record : log_record (** [default_log_record ()] is the default value for type [log_record] *) -val default_instrumentation_library_logs : - ?instrumentation_library:Common_types.instrumentation_library option -> +val default_scope_logs : + ?scope:Common_types.instrumentation_scope option -> ?log_records:log_record list -> ?schema_url:string -> unit -> - instrumentation_library_logs -(** [default_instrumentation_library_logs ()] is the default value for type [instrumentation_library_logs] *) + scope_logs +(** [default_scope_logs ()] is the default value for type [scope_logs] *) val default_resource_logs : ?resource:Resource_types.resource option -> - ?instrumentation_library_logs:instrumentation_library_logs list -> + ?scope_logs:scope_logs list -> ?schema_url:string -> unit -> resource_logs diff --git a/src/metrics_pb.ml b/src/metrics_pb.ml index bc512f26..56362ba7 100644 --- a/src/metrics_pb.ml +++ b/src/metrics_pb.ml @@ -59,11 +59,13 @@ type histogram_data_point_mutable = { mutable start_time_unix_nano : int64; mutable time_unix_nano : int64; mutable count : int64; - mutable sum : float; + mutable sum : float option; mutable bucket_counts : int64 list; mutable explicit_bounds : float list; mutable exemplars : Metrics_types.exemplar list; mutable flags : int32; + mutable min : float option; + mutable max : float option; } let default_histogram_data_point_mutable () : histogram_data_point_mutable = { @@ -71,11 +73,13 @@ let default_histogram_data_point_mutable () : histogram_data_point_mutable = { start_time_unix_nano = 0L; time_unix_nano = 0L; count = 0L; - sum = 0.; + sum = None; bucket_counts = []; explicit_bounds = []; exemplars = []; flags = 0l; + min = None; + max = None; } type histogram_mutable = { @@ -103,13 +107,15 @@ type exponential_histogram_data_point_mutable = { mutable start_time_unix_nano : int64; mutable time_unix_nano : int64; mutable count : int64; - mutable sum : float; + mutable sum : float option; mutable scale : int32; mutable zero_count : int64; mutable positive : Metrics_types.exponential_histogram_data_point_buckets option; mutable negative : Metrics_types.exponential_histogram_data_point_buckets option; mutable flags : int32; mutable exemplars : Metrics_types.exemplar list; + mutable min : float option; + mutable max : float option; } let default_exponential_histogram_data_point_mutable () : exponential_histogram_data_point_mutable = { @@ -117,13 +123,15 @@ let default_exponential_histogram_data_point_mutable () : exponential_histogram_ start_time_unix_nano = 0L; time_unix_nano = 0L; count = 0L; - sum = 0.; + sum = None; scale = 0l; zero_count = 0L; positive = None; negative = None; flags = 0l; exemplars = []; + min = None; + max = None; } type exponential_histogram_mutable = { @@ -188,27 +196,27 @@ let default_metric_mutable () : metric_mutable = { data = Metrics_types.Gauge (Metrics_types.default_gauge ()); } -type instrumentation_library_metrics_mutable = { - mutable instrumentation_library : Common_types.instrumentation_library option; +type scope_metrics_mutable = { + mutable scope : Common_types.instrumentation_scope option; mutable metrics : Metrics_types.metric list; mutable schema_url : string; } -let default_instrumentation_library_metrics_mutable () : instrumentation_library_metrics_mutable = { - instrumentation_library = None; +let default_scope_metrics_mutable () : scope_metrics_mutable = { + scope = None; metrics = []; schema_url = ""; } type resource_metrics_mutable = { mutable resource : Resource_types.resource option; - mutable instrumentation_library_metrics : Metrics_types.instrumentation_library_metrics list; + mutable scope_metrics : Metrics_types.scope_metrics list; mutable schema_url : string; } let default_resource_metrics_mutable () : resource_metrics_mutable = { resource = None; - instrumentation_library_metrics = []; + scope_metrics = []; schema_url = ""; } @@ -443,7 +451,7 @@ let rec decode_histogram_data_point d = | Some (4, pk) -> Pbrt.Decoder.unexpected_payload "Message(histogram_data_point), field(4)" pk | Some (5, Pbrt.Bits64) -> begin - v.sum <- Pbrt.Decoder.float_as_bits64 d; + v.sum <- Some (Pbrt.Decoder.float_as_bits64 d); end | Some (5, pk) -> Pbrt.Decoder.unexpected_payload "Message(histogram_data_point), field(5)" pk @@ -467,6 +475,16 @@ let rec decode_histogram_data_point d = end | Some (10, pk) -> Pbrt.Decoder.unexpected_payload "Message(histogram_data_point), field(10)" pk + | Some (11, Pbrt.Bits64) -> begin + v.min <- Some (Pbrt.Decoder.float_as_bits64 d); + end + | Some (11, pk) -> + Pbrt.Decoder.unexpected_payload "Message(histogram_data_point), field(11)" pk + | Some (12, Pbrt.Bits64) -> begin + v.max <- Some (Pbrt.Decoder.float_as_bits64 d); + end + | Some (12, pk) -> + Pbrt.Decoder.unexpected_payload "Message(histogram_data_point), field(12)" pk | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind done; ({ @@ -479,6 +497,8 @@ let rec decode_histogram_data_point d = Metrics_types.explicit_bounds = v.explicit_bounds; Metrics_types.exemplars = v.exemplars; Metrics_types.flags = v.flags; + Metrics_types.min = v.min; + Metrics_types.max = v.max; } : Metrics_types.histogram_data_point) let rec decode_histogram d = @@ -561,7 +581,7 @@ let rec decode_exponential_histogram_data_point d = | Some (4, pk) -> Pbrt.Decoder.unexpected_payload "Message(exponential_histogram_data_point), field(4)" pk | Some (5, Pbrt.Bits64) -> begin - v.sum <- Pbrt.Decoder.float_as_bits64 d; + v.sum <- Some (Pbrt.Decoder.float_as_bits64 d); end | Some (5, pk) -> Pbrt.Decoder.unexpected_payload "Message(exponential_histogram_data_point), field(5)" pk @@ -595,6 +615,16 @@ let rec decode_exponential_histogram_data_point d = end | Some (11, pk) -> Pbrt.Decoder.unexpected_payload "Message(exponential_histogram_data_point), field(11)" pk + | Some (12, Pbrt.Bits64) -> begin + v.min <- Some (Pbrt.Decoder.float_as_bits64 d); + end + | Some (12, pk) -> + Pbrt.Decoder.unexpected_payload "Message(exponential_histogram_data_point), field(12)" pk + | Some (13, Pbrt.Bits64) -> begin + v.max <- Some (Pbrt.Decoder.float_as_bits64 d); + end + | Some (13, pk) -> + Pbrt.Decoder.unexpected_payload "Message(exponential_histogram_data_point), field(13)" pk | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind done; ({ @@ -609,6 +639,8 @@ let rec decode_exponential_histogram_data_point d = Metrics_types.negative = v.negative; Metrics_types.flags = v.flags; Metrics_types.exemplars = v.exemplars; + Metrics_types.min = v.min; + Metrics_types.max = v.max; } : Metrics_types.exponential_histogram_data_point) let rec decode_exponential_histogram d = @@ -809,8 +841,8 @@ and decode_metric d = Metrics_types.data = v.data; } : Metrics_types.metric) -let rec decode_instrumentation_library_metrics d = - let v = default_instrumentation_library_metrics_mutable () in +let rec decode_scope_metrics d = + let v = default_scope_metrics_mutable () in let continue__= ref true in while !continue__ do match Pbrt.Decoder.key d with @@ -818,27 +850,27 @@ let rec decode_instrumentation_library_metrics d = v.metrics <- List.rev v.metrics; ); continue__ := false | Some (1, Pbrt.Bytes) -> begin - v.instrumentation_library <- Some (Common_pb.decode_instrumentation_library (Pbrt.Decoder.nested d)); + v.scope <- Some (Common_pb.decode_instrumentation_scope (Pbrt.Decoder.nested d)); end | Some (1, pk) -> - Pbrt.Decoder.unexpected_payload "Message(instrumentation_library_metrics), field(1)" pk + Pbrt.Decoder.unexpected_payload "Message(scope_metrics), field(1)" pk | Some (2, Pbrt.Bytes) -> begin v.metrics <- (decode_metric (Pbrt.Decoder.nested d)) :: v.metrics; end | Some (2, pk) -> - Pbrt.Decoder.unexpected_payload "Message(instrumentation_library_metrics), field(2)" pk + Pbrt.Decoder.unexpected_payload "Message(scope_metrics), field(2)" pk | Some (3, Pbrt.Bytes) -> begin v.schema_url <- Pbrt.Decoder.string d; end | Some (3, pk) -> - Pbrt.Decoder.unexpected_payload "Message(instrumentation_library_metrics), field(3)" pk + Pbrt.Decoder.unexpected_payload "Message(scope_metrics), field(3)" pk | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind done; ({ - Metrics_types.instrumentation_library = v.instrumentation_library; + Metrics_types.scope = v.scope; Metrics_types.metrics = v.metrics; Metrics_types.schema_url = v.schema_url; - } : Metrics_types.instrumentation_library_metrics) + } : Metrics_types.scope_metrics) let rec decode_resource_metrics d = let v = default_resource_metrics_mutable () in @@ -846,7 +878,7 @@ let rec decode_resource_metrics d = while !continue__ do match Pbrt.Decoder.key d with | None -> ( - v.instrumentation_library_metrics <- List.rev v.instrumentation_library_metrics; + v.scope_metrics <- List.rev v.scope_metrics; ); continue__ := false | Some (1, Pbrt.Bytes) -> begin v.resource <- Some (Resource_pb.decode_resource (Pbrt.Decoder.nested d)); @@ -854,7 +886,7 @@ let rec decode_resource_metrics d = | Some (1, pk) -> Pbrt.Decoder.unexpected_payload "Message(resource_metrics), field(1)" pk | Some (2, Pbrt.Bytes) -> begin - v.instrumentation_library_metrics <- (decode_instrumentation_library_metrics (Pbrt.Decoder.nested d)) :: v.instrumentation_library_metrics; + v.scope_metrics <- (decode_scope_metrics (Pbrt.Decoder.nested d)) :: v.scope_metrics; end | Some (2, pk) -> Pbrt.Decoder.unexpected_payload "Message(resource_metrics), field(2)" pk @@ -867,7 +899,7 @@ let rec decode_resource_metrics d = done; ({ Metrics_types.resource = v.resource; - Metrics_types.instrumentation_library_metrics = v.instrumentation_library_metrics; + Metrics_types.scope_metrics = v.scope_metrics; Metrics_types.schema_url = v.schema_url; } : Metrics_types.resource_metrics) @@ -997,8 +1029,12 @@ let rec encode_histogram_data_point (v:Metrics_types.histogram_data_point) encod Pbrt.Encoder.int64_as_bits64 v.Metrics_types.time_unix_nano encoder; Pbrt.Encoder.key (4, Pbrt.Bits64) encoder; Pbrt.Encoder.int64_as_bits64 v.Metrics_types.count encoder; - Pbrt.Encoder.key (5, Pbrt.Bits64) encoder; - Pbrt.Encoder.float_as_bits64 v.Metrics_types.sum encoder; + begin match v.Metrics_types.sum with + | Some x -> + Pbrt.Encoder.key (5, Pbrt.Bits64) encoder; + Pbrt.Encoder.float_as_bits64 x encoder; + | None -> (); + end; Pbrt.Encoder.key (6, Pbrt.Bytes) encoder; Pbrt.Encoder.nested (fun encoder -> List.iter (fun x -> @@ -1017,6 +1053,18 @@ let rec encode_histogram_data_point (v:Metrics_types.histogram_data_point) encod ) v.Metrics_types.exemplars; Pbrt.Encoder.key (10, Pbrt.Varint) encoder; Pbrt.Encoder.int32_as_varint v.Metrics_types.flags encoder; + begin match v.Metrics_types.min with + | Some x -> + Pbrt.Encoder.key (11, Pbrt.Bits64) encoder; + Pbrt.Encoder.float_as_bits64 x encoder; + | None -> (); + end; + begin match v.Metrics_types.max with + | Some x -> + Pbrt.Encoder.key (12, Pbrt.Bits64) encoder; + Pbrt.Encoder.float_as_bits64 x encoder; + | None -> (); + end; () let rec encode_histogram (v:Metrics_types.histogram) encoder = @@ -1050,8 +1098,12 @@ let rec encode_exponential_histogram_data_point (v:Metrics_types.exponential_his Pbrt.Encoder.int64_as_bits64 v.Metrics_types.time_unix_nano encoder; Pbrt.Encoder.key (4, Pbrt.Bits64) encoder; Pbrt.Encoder.int64_as_bits64 v.Metrics_types.count encoder; - Pbrt.Encoder.key (5, Pbrt.Bits64) encoder; - Pbrt.Encoder.float_as_bits64 v.Metrics_types.sum encoder; + begin match v.Metrics_types.sum with + | Some x -> + Pbrt.Encoder.key (5, Pbrt.Bits64) encoder; + Pbrt.Encoder.float_as_bits64 x encoder; + | None -> (); + end; Pbrt.Encoder.key (6, Pbrt.Varint) encoder; Pbrt.Encoder.int32_as_zigzag v.Metrics_types.scale encoder; Pbrt.Encoder.key (7, Pbrt.Bits64) encoder; @@ -1074,6 +1126,18 @@ let rec encode_exponential_histogram_data_point (v:Metrics_types.exponential_his Pbrt.Encoder.key (11, Pbrt.Bytes) encoder; Pbrt.Encoder.nested (encode_exemplar x) encoder; ) v.Metrics_types.exemplars; + begin match v.Metrics_types.min with + | Some x -> + Pbrt.Encoder.key (12, Pbrt.Bits64) encoder; + Pbrt.Encoder.float_as_bits64 x encoder; + | None -> (); + end; + begin match v.Metrics_types.max with + | Some x -> + Pbrt.Encoder.key (13, Pbrt.Bits64) encoder; + Pbrt.Encoder.float_as_bits64 x encoder; + | None -> (); + end; () let rec encode_exponential_histogram (v:Metrics_types.exponential_histogram) encoder = @@ -1165,11 +1229,11 @@ and encode_metric (v:Metrics_types.metric) encoder = end; () -let rec encode_instrumentation_library_metrics (v:Metrics_types.instrumentation_library_metrics) encoder = - begin match v.Metrics_types.instrumentation_library with +let rec encode_scope_metrics (v:Metrics_types.scope_metrics) encoder = + begin match v.Metrics_types.scope with | Some x -> Pbrt.Encoder.key (1, Pbrt.Bytes) encoder; - Pbrt.Encoder.nested (Common_pb.encode_instrumentation_library x) encoder; + Pbrt.Encoder.nested (Common_pb.encode_instrumentation_scope x) encoder; | None -> (); end; List.iter (fun x -> @@ -1189,8 +1253,8 @@ let rec encode_resource_metrics (v:Metrics_types.resource_metrics) encoder = end; List.iter (fun x -> Pbrt.Encoder.key (2, Pbrt.Bytes) encoder; - Pbrt.Encoder.nested (encode_instrumentation_library_metrics x) encoder; - ) v.Metrics_types.instrumentation_library_metrics; + Pbrt.Encoder.nested (encode_scope_metrics x) encoder; + ) v.Metrics_types.scope_metrics; Pbrt.Encoder.key (3, Pbrt.Bytes) encoder; Pbrt.Encoder.string v.Metrics_types.schema_url encoder; () diff --git a/src/metrics_pb.mli b/src/metrics_pb.mli index 4a1e447a..6393cedd 100644 --- a/src/metrics_pb.mli +++ b/src/metrics_pb.mli @@ -54,8 +54,8 @@ val encode_metric_data : Metrics_types.metric_data -> Pbrt.Encoder.t -> unit val encode_metric : Metrics_types.metric -> Pbrt.Encoder.t -> unit (** [encode_metric v encoder] encodes [v] with the given [encoder] *) -val encode_instrumentation_library_metrics : Metrics_types.instrumentation_library_metrics -> Pbrt.Encoder.t -> unit -(** [encode_instrumentation_library_metrics v encoder] encodes [v] with the given [encoder] *) +val encode_scope_metrics : Metrics_types.scope_metrics -> Pbrt.Encoder.t -> unit +(** [encode_scope_metrics v encoder] encodes [v] with the given [encoder] *) val encode_resource_metrics : Metrics_types.resource_metrics -> Pbrt.Encoder.t -> unit (** [encode_resource_metrics v encoder] encodes [v] with the given [encoder] *) @@ -120,8 +120,8 @@ val decode_metric_data : Pbrt.Decoder.t -> Metrics_types.metric_data val decode_metric : Pbrt.Decoder.t -> Metrics_types.metric (** [decode_metric decoder] decodes a [metric] value from [decoder] *) -val decode_instrumentation_library_metrics : Pbrt.Decoder.t -> Metrics_types.instrumentation_library_metrics -(** [decode_instrumentation_library_metrics decoder] decodes a [instrumentation_library_metrics] value from [decoder] *) +val decode_scope_metrics : Pbrt.Decoder.t -> Metrics_types.scope_metrics +(** [decode_scope_metrics decoder] decodes a [scope_metrics] value from [decoder] *) val decode_resource_metrics : Pbrt.Decoder.t -> Metrics_types.resource_metrics (** [decode_resource_metrics decoder] decodes a [resource_metrics] value from [decoder] *) diff --git a/src/metrics_pp.ml b/src/metrics_pp.ml index b94711a7..b0bf4a25 100644 --- a/src/metrics_pp.ml +++ b/src/metrics_pp.ml @@ -57,11 +57,13 @@ let rec pp_histogram_data_point fmt (v:Metrics_types.histogram_data_point) = Pbrt.Pp.pp_record_field ~first:false "start_time_unix_nano" Pbrt.Pp.pp_int64 fmt v.Metrics_types.start_time_unix_nano; Pbrt.Pp.pp_record_field ~first:false "time_unix_nano" Pbrt.Pp.pp_int64 fmt v.Metrics_types.time_unix_nano; Pbrt.Pp.pp_record_field ~first:false "count" Pbrt.Pp.pp_int64 fmt v.Metrics_types.count; - Pbrt.Pp.pp_record_field ~first:false "sum" Pbrt.Pp.pp_float fmt v.Metrics_types.sum; + Pbrt.Pp.pp_record_field ~first:false "sum" (Pbrt.Pp.pp_option Pbrt.Pp.pp_float) fmt v.Metrics_types.sum; Pbrt.Pp.pp_record_field ~first:false "bucket_counts" (Pbrt.Pp.pp_list Pbrt.Pp.pp_int64) fmt v.Metrics_types.bucket_counts; Pbrt.Pp.pp_record_field ~first:false "explicit_bounds" (Pbrt.Pp.pp_list Pbrt.Pp.pp_float) fmt v.Metrics_types.explicit_bounds; Pbrt.Pp.pp_record_field ~first:false "exemplars" (Pbrt.Pp.pp_list pp_exemplar) fmt v.Metrics_types.exemplars; Pbrt.Pp.pp_record_field ~first:false "flags" Pbrt.Pp.pp_int32 fmt v.Metrics_types.flags; + Pbrt.Pp.pp_record_field ~first:false "min" (Pbrt.Pp.pp_option Pbrt.Pp.pp_float) fmt v.Metrics_types.min; + Pbrt.Pp.pp_record_field ~first:false "max" (Pbrt.Pp.pp_option Pbrt.Pp.pp_float) fmt v.Metrics_types.max; in Pbrt.Pp.pp_brk pp_i fmt () @@ -85,13 +87,15 @@ let rec pp_exponential_histogram_data_point fmt (v:Metrics_types.exponential_his Pbrt.Pp.pp_record_field ~first:false "start_time_unix_nano" Pbrt.Pp.pp_int64 fmt v.Metrics_types.start_time_unix_nano; Pbrt.Pp.pp_record_field ~first:false "time_unix_nano" Pbrt.Pp.pp_int64 fmt v.Metrics_types.time_unix_nano; Pbrt.Pp.pp_record_field ~first:false "count" Pbrt.Pp.pp_int64 fmt v.Metrics_types.count; - Pbrt.Pp.pp_record_field ~first:false "sum" Pbrt.Pp.pp_float fmt v.Metrics_types.sum; + Pbrt.Pp.pp_record_field ~first:false "sum" (Pbrt.Pp.pp_option Pbrt.Pp.pp_float) fmt v.Metrics_types.sum; Pbrt.Pp.pp_record_field ~first:false "scale" Pbrt.Pp.pp_int32 fmt v.Metrics_types.scale; Pbrt.Pp.pp_record_field ~first:false "zero_count" Pbrt.Pp.pp_int64 fmt v.Metrics_types.zero_count; Pbrt.Pp.pp_record_field ~first:false "positive" (Pbrt.Pp.pp_option pp_exponential_histogram_data_point_buckets) fmt v.Metrics_types.positive; Pbrt.Pp.pp_record_field ~first:false "negative" (Pbrt.Pp.pp_option pp_exponential_histogram_data_point_buckets) fmt v.Metrics_types.negative; Pbrt.Pp.pp_record_field ~first:false "flags" Pbrt.Pp.pp_int32 fmt v.Metrics_types.flags; Pbrt.Pp.pp_record_field ~first:false "exemplars" (Pbrt.Pp.pp_list pp_exemplar) fmt v.Metrics_types.exemplars; + Pbrt.Pp.pp_record_field ~first:false "min" (Pbrt.Pp.pp_option Pbrt.Pp.pp_float) fmt v.Metrics_types.min; + Pbrt.Pp.pp_record_field ~first:false "max" (Pbrt.Pp.pp_option Pbrt.Pp.pp_float) fmt v.Metrics_types.max; in Pbrt.Pp.pp_brk pp_i fmt () @@ -144,9 +148,9 @@ and pp_metric fmt (v:Metrics_types.metric) = in Pbrt.Pp.pp_brk pp_i fmt () -let rec pp_instrumentation_library_metrics fmt (v:Metrics_types.instrumentation_library_metrics) = +let rec pp_scope_metrics fmt (v:Metrics_types.scope_metrics) = let pp_i fmt () = - Pbrt.Pp.pp_record_field ~first:true "instrumentation_library" (Pbrt.Pp.pp_option Common_pp.pp_instrumentation_library) fmt v.Metrics_types.instrumentation_library; + Pbrt.Pp.pp_record_field ~first:true "scope" (Pbrt.Pp.pp_option Common_pp.pp_instrumentation_scope) fmt v.Metrics_types.scope; Pbrt.Pp.pp_record_field ~first:false "metrics" (Pbrt.Pp.pp_list pp_metric) fmt v.Metrics_types.metrics; Pbrt.Pp.pp_record_field ~first:false "schema_url" Pbrt.Pp.pp_string fmt v.Metrics_types.schema_url; in @@ -155,7 +159,7 @@ let rec pp_instrumentation_library_metrics fmt (v:Metrics_types.instrumentation_ let rec pp_resource_metrics fmt (v:Metrics_types.resource_metrics) = let pp_i fmt () = Pbrt.Pp.pp_record_field ~first:true "resource" (Pbrt.Pp.pp_option Resource_pp.pp_resource) fmt v.Metrics_types.resource; - Pbrt.Pp.pp_record_field ~first:false "instrumentation_library_metrics" (Pbrt.Pp.pp_list pp_instrumentation_library_metrics) fmt v.Metrics_types.instrumentation_library_metrics; + Pbrt.Pp.pp_record_field ~first:false "scope_metrics" (Pbrt.Pp.pp_list pp_scope_metrics) fmt v.Metrics_types.scope_metrics; Pbrt.Pp.pp_record_field ~first:false "schema_url" Pbrt.Pp.pp_string fmt v.Metrics_types.schema_url; in Pbrt.Pp.pp_brk pp_i fmt () diff --git a/src/metrics_pp.mli b/src/metrics_pp.mli index d40d622e..c506e897 100644 --- a/src/metrics_pp.mli +++ b/src/metrics_pp.mli @@ -54,8 +54,8 @@ val pp_metric_data : Format.formatter -> Metrics_types.metric_data -> unit val pp_metric : Format.formatter -> Metrics_types.metric -> unit (** [pp_metric v] formats v *) -val pp_instrumentation_library_metrics : Format.formatter -> Metrics_types.instrumentation_library_metrics -> unit -(** [pp_instrumentation_library_metrics v] formats v *) +val pp_scope_metrics : Format.formatter -> Metrics_types.scope_metrics -> unit +(** [pp_scope_metrics v] formats v *) val pp_resource_metrics : Format.formatter -> Metrics_types.resource_metrics -> unit (** [pp_resource_metrics v] formats v *) diff --git a/src/metrics_service_pb.ml b/src/metrics_service_pb.ml index eda8e857..dd839d9b 100644 --- a/src/metrics_service_pb.ml +++ b/src/metrics_service_pb.ml @@ -8,6 +8,24 @@ let default_export_metrics_service_request_mutable () : export_metrics_service_r resource_metrics = []; } +type export_metrics_partial_success_mutable = { + mutable rejected_data_points : int64; + mutable error_message : string; +} + +let default_export_metrics_partial_success_mutable () : export_metrics_partial_success_mutable = { + rejected_data_points = 0L; + error_message = ""; +} + +type export_metrics_service_response_mutable = { + mutable partial_success : Metrics_service_types.export_metrics_partial_success option; +} + +let default_export_metrics_service_response_mutable () : export_metrics_service_response_mutable = { + partial_success = None; +} + let rec decode_export_metrics_service_request d = let v = default_export_metrics_service_request_mutable () in @@ -28,9 +46,67 @@ let rec decode_export_metrics_service_request d = Metrics_service_types.resource_metrics = v.resource_metrics; } : Metrics_service_types.export_metrics_service_request) +let rec decode_export_metrics_partial_success d = + let v = default_export_metrics_partial_success_mutable () in + let continue__= ref true in + while !continue__ do + match Pbrt.Decoder.key d with + | None -> ( + ); continue__ := false + | Some (1, Pbrt.Varint) -> begin + v.rejected_data_points <- Pbrt.Decoder.int64_as_varint d; + end + | Some (1, pk) -> + Pbrt.Decoder.unexpected_payload "Message(export_metrics_partial_success), field(1)" pk + | Some (2, Pbrt.Bytes) -> begin + v.error_message <- Pbrt.Decoder.string d; + end + | Some (2, pk) -> + Pbrt.Decoder.unexpected_payload "Message(export_metrics_partial_success), field(2)" pk + | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind + done; + ({ + Metrics_service_types.rejected_data_points = v.rejected_data_points; + Metrics_service_types.error_message = v.error_message; + } : Metrics_service_types.export_metrics_partial_success) + +let rec decode_export_metrics_service_response d = + let v = default_export_metrics_service_response_mutable () in + let continue__= ref true in + while !continue__ do + match Pbrt.Decoder.key d with + | None -> ( + ); continue__ := false + | Some (1, Pbrt.Bytes) -> begin + v.partial_success <- Some (decode_export_metrics_partial_success (Pbrt.Decoder.nested d)); + end + | Some (1, pk) -> + Pbrt.Decoder.unexpected_payload "Message(export_metrics_service_response), field(1)" pk + | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind + done; + ({ + Metrics_service_types.partial_success = v.partial_success; + } : Metrics_service_types.export_metrics_service_response) + let rec encode_export_metrics_service_request (v:Metrics_service_types.export_metrics_service_request) encoder = List.iter (fun x -> Pbrt.Encoder.key (1, Pbrt.Bytes) encoder; Pbrt.Encoder.nested (Metrics_pb.encode_resource_metrics x) encoder; ) v.Metrics_service_types.resource_metrics; () + +let rec encode_export_metrics_partial_success (v:Metrics_service_types.export_metrics_partial_success) encoder = + Pbrt.Encoder.key (1, Pbrt.Varint) encoder; + Pbrt.Encoder.int64_as_varint v.Metrics_service_types.rejected_data_points encoder; + Pbrt.Encoder.key (2, Pbrt.Bytes) encoder; + Pbrt.Encoder.string v.Metrics_service_types.error_message encoder; + () + +let rec encode_export_metrics_service_response (v:Metrics_service_types.export_metrics_service_response) encoder = + begin match v.Metrics_service_types.partial_success with + | Some x -> + Pbrt.Encoder.key (1, Pbrt.Bytes) encoder; + Pbrt.Encoder.nested (encode_export_metrics_partial_success x) encoder; + | None -> (); + end; + () diff --git a/src/metrics_service_pb.mli b/src/metrics_service_pb.mli index 51c69601..ed839b04 100644 --- a/src/metrics_service_pb.mli +++ b/src/metrics_service_pb.mli @@ -6,8 +6,20 @@ val encode_export_metrics_service_request : Metrics_service_types.export_metrics_service_request -> Pbrt.Encoder.t -> unit (** [encode_export_metrics_service_request v encoder] encodes [v] with the given [encoder] *) +val encode_export_metrics_partial_success : Metrics_service_types.export_metrics_partial_success -> Pbrt.Encoder.t -> unit +(** [encode_export_metrics_partial_success v encoder] encodes [v] with the given [encoder] *) + +val encode_export_metrics_service_response : Metrics_service_types.export_metrics_service_response -> Pbrt.Encoder.t -> unit +(** [encode_export_metrics_service_response v encoder] encodes [v] with the given [encoder] *) + (** {2 Protobuf Decoding} *) val decode_export_metrics_service_request : Pbrt.Decoder.t -> Metrics_service_types.export_metrics_service_request (** [decode_export_metrics_service_request decoder] decodes a [export_metrics_service_request] value from [decoder] *) + +val decode_export_metrics_partial_success : Pbrt.Decoder.t -> Metrics_service_types.export_metrics_partial_success +(** [decode_export_metrics_partial_success decoder] decodes a [export_metrics_partial_success] value from [decoder] *) + +val decode_export_metrics_service_response : Pbrt.Decoder.t -> Metrics_service_types.export_metrics_service_response +(** [decode_export_metrics_service_response decoder] decodes a [export_metrics_service_response] value from [decoder] *) diff --git a/src/metrics_service_pp.ml b/src/metrics_service_pp.ml index e528afbd..bb0f7a3b 100644 --- a/src/metrics_service_pp.ml +++ b/src/metrics_service_pp.ml @@ -5,3 +5,16 @@ let rec pp_export_metrics_service_request fmt (v:Metrics_service_types.export_me Pbrt.Pp.pp_record_field ~first:true "resource_metrics" (Pbrt.Pp.pp_list Metrics_pp.pp_resource_metrics) fmt v.Metrics_service_types.resource_metrics; in Pbrt.Pp.pp_brk pp_i fmt () + +let rec pp_export_metrics_partial_success fmt (v:Metrics_service_types.export_metrics_partial_success) = + let pp_i fmt () = + Pbrt.Pp.pp_record_field ~first:true "rejected_data_points" Pbrt.Pp.pp_int64 fmt v.Metrics_service_types.rejected_data_points; + Pbrt.Pp.pp_record_field ~first:false "error_message" Pbrt.Pp.pp_string fmt v.Metrics_service_types.error_message; + in + Pbrt.Pp.pp_brk pp_i fmt () + +let rec pp_export_metrics_service_response fmt (v:Metrics_service_types.export_metrics_service_response) = + let pp_i fmt () = + Pbrt.Pp.pp_record_field ~first:true "partial_success" (Pbrt.Pp.pp_option pp_export_metrics_partial_success) fmt v.Metrics_service_types.partial_success; + in + Pbrt.Pp.pp_brk pp_i fmt () diff --git a/src/metrics_service_pp.mli b/src/metrics_service_pp.mli index 5ca12bb1..90301da8 100644 --- a/src/metrics_service_pp.mli +++ b/src/metrics_service_pp.mli @@ -5,3 +5,9 @@ val pp_export_metrics_service_request : Format.formatter -> Metrics_service_types.export_metrics_service_request -> unit (** [pp_export_metrics_service_request v] formats v *) + +val pp_export_metrics_partial_success : Format.formatter -> Metrics_service_types.export_metrics_partial_success -> unit +(** [pp_export_metrics_partial_success v] formats v *) + +val pp_export_metrics_service_response : Format.formatter -> Metrics_service_types.export_metrics_service_response -> unit +(** [pp_export_metrics_service_response v] formats v *) diff --git a/src/metrics_service_types.ml b/src/metrics_service_types.ml index f82397a7..8b252a24 100644 --- a/src/metrics_service_types.ml +++ b/src/metrics_service_types.ml @@ -5,8 +5,31 @@ type export_metrics_service_request = { resource_metrics : Metrics_types.resource_metrics list; } +type export_metrics_partial_success = { + rejected_data_points : int64; + error_message : string; +} + +type export_metrics_service_response = { + partial_success : export_metrics_partial_success option; +} + let rec default_export_metrics_service_request ?resource_metrics:((resource_metrics:Metrics_types.resource_metrics list) = []) () : export_metrics_service_request = { resource_metrics; } + +let rec default_export_metrics_partial_success + ?rejected_data_points:((rejected_data_points:int64) = 0L) + ?error_message:((error_message:string) = "") + () : export_metrics_partial_success = { + rejected_data_points; + error_message; +} + +let rec default_export_metrics_service_response + ?partial_success:((partial_success:export_metrics_partial_success option) = None) + () : export_metrics_service_response = { + partial_success; +} diff --git a/src/metrics_service_types.mli b/src/metrics_service_types.mli index 7078fe62..cbcddfed 100644 --- a/src/metrics_service_types.mli +++ b/src/metrics_service_types.mli @@ -8,6 +8,15 @@ type export_metrics_service_request = { resource_metrics : Metrics_types.resource_metrics list; } +type export_metrics_partial_success = { + rejected_data_points : int64; + error_message : string; +} + +type export_metrics_service_response = { + partial_success : export_metrics_partial_success option; +} + (** {2 Default values} *) @@ -16,3 +25,16 @@ val default_export_metrics_service_request : unit -> export_metrics_service_request (** [default_export_metrics_service_request ()] is the default value for type [export_metrics_service_request] *) + +val default_export_metrics_partial_success : + ?rejected_data_points:int64 -> + ?error_message:string -> + unit -> + export_metrics_partial_success +(** [default_export_metrics_partial_success ()] is the default value for type [export_metrics_partial_success] *) + +val default_export_metrics_service_response : + ?partial_success:export_metrics_partial_success option -> + unit -> + export_metrics_service_response +(** [default_export_metrics_service_response ()] is the default value for type [export_metrics_service_response] *) diff --git a/src/metrics_types.ml b/src/metrics_types.ml index 1c955c74..bc923ef4 100644 --- a/src/metrics_types.ml +++ b/src/metrics_types.ml @@ -46,11 +46,13 @@ type histogram_data_point = { start_time_unix_nano : int64; time_unix_nano : int64; count : int64; - sum : float; + sum : float option; bucket_counts : int64 list; explicit_bounds : float list; exemplars : exemplar list; flags : int32; + min : float option; + max : float option; } type histogram = { @@ -68,13 +70,15 @@ type exponential_histogram_data_point = { start_time_unix_nano : int64; time_unix_nano : int64; count : int64; - sum : float; + sum : float option; scale : int32; zero_count : int64; positive : exponential_histogram_data_point_buckets option; negative : exponential_histogram_data_point_buckets option; flags : int32; exemplars : exemplar list; + min : float option; + max : float option; } type exponential_histogram = { @@ -115,15 +119,15 @@ and metric = { data : metric_data; } -type instrumentation_library_metrics = { - instrumentation_library : Common_types.instrumentation_library option; +type scope_metrics = { + scope : Common_types.instrumentation_scope option; metrics : metric list; schema_url : string; } type resource_metrics = { resource : Resource_types.resource option; - instrumentation_library_metrics : instrumentation_library_metrics list; + scope_metrics : scope_metrics list; schema_url : string; } @@ -192,11 +196,13 @@ let rec default_histogram_data_point ?start_time_unix_nano:((start_time_unix_nano:int64) = 0L) ?time_unix_nano:((time_unix_nano:int64) = 0L) ?count:((count:int64) = 0L) - ?sum:((sum:float) = 0.) + ?sum:((sum:float option) = None) ?bucket_counts:((bucket_counts:int64 list) = []) ?explicit_bounds:((explicit_bounds:float list) = []) ?exemplars:((exemplars:exemplar list) = []) ?flags:((flags:int32) = 0l) + ?min:((min:float option) = None) + ?max:((max:float option) = None) () : histogram_data_point = { attributes; start_time_unix_nano; @@ -207,6 +213,8 @@ let rec default_histogram_data_point explicit_bounds; exemplars; flags; + min; + max; } let rec default_histogram @@ -230,13 +238,15 @@ let rec default_exponential_histogram_data_point ?start_time_unix_nano:((start_time_unix_nano:int64) = 0L) ?time_unix_nano:((time_unix_nano:int64) = 0L) ?count:((count:int64) = 0L) - ?sum:((sum:float) = 0.) + ?sum:((sum:float option) = None) ?scale:((scale:int32) = 0l) ?zero_count:((zero_count:int64) = 0L) ?positive:((positive:exponential_histogram_data_point_buckets option) = None) ?negative:((negative:exponential_histogram_data_point_buckets option) = None) ?flags:((flags:int32) = 0l) ?exemplars:((exemplars:exemplar list) = []) + ?min:((min:float option) = None) + ?max:((max:float option) = None) () : exponential_histogram_data_point = { attributes; start_time_unix_nano; @@ -249,6 +259,8 @@ let rec default_exponential_histogram_data_point negative; flags; exemplars; + min; + max; } let rec default_exponential_histogram @@ -305,23 +317,23 @@ and default_metric data; } -let rec default_instrumentation_library_metrics - ?instrumentation_library:((instrumentation_library:Common_types.instrumentation_library option) = None) +let rec default_scope_metrics + ?scope:((scope:Common_types.instrumentation_scope option) = None) ?metrics:((metrics:metric list) = []) ?schema_url:((schema_url:string) = "") - () : instrumentation_library_metrics = { - instrumentation_library; + () : scope_metrics = { + scope; metrics; schema_url; } let rec default_resource_metrics ?resource:((resource:Resource_types.resource option) = None) - ?instrumentation_library_metrics:((instrumentation_library_metrics:instrumentation_library_metrics list) = []) + ?scope_metrics:((scope_metrics:scope_metrics list) = []) ?schema_url:((schema_url:string) = "") () : resource_metrics = { resource; - instrumentation_library_metrics; + scope_metrics; schema_url; } diff --git a/src/metrics_types.mli b/src/metrics_types.mli index d911c1e1..5e045f98 100644 --- a/src/metrics_types.mli +++ b/src/metrics_types.mli @@ -49,11 +49,13 @@ type histogram_data_point = { start_time_unix_nano : int64; time_unix_nano : int64; count : int64; - sum : float; + sum : float option; bucket_counts : int64 list; explicit_bounds : float list; exemplars : exemplar list; flags : int32; + min : float option; + max : float option; } type histogram = { @@ -71,13 +73,15 @@ type exponential_histogram_data_point = { start_time_unix_nano : int64; time_unix_nano : int64; count : int64; - sum : float; + sum : float option; scale : int32; zero_count : int64; positive : exponential_histogram_data_point_buckets option; negative : exponential_histogram_data_point_buckets option; flags : int32; exemplars : exemplar list; + min : float option; + max : float option; } type exponential_histogram = { @@ -118,15 +122,15 @@ and metric = { data : metric_data; } -type instrumentation_library_metrics = { - instrumentation_library : Common_types.instrumentation_library option; +type scope_metrics = { + scope : Common_types.instrumentation_scope option; metrics : metric list; schema_url : string; } type resource_metrics = { resource : Resource_types.resource option; - instrumentation_library_metrics : instrumentation_library_metrics list; + scope_metrics : scope_metrics list; schema_url : string; } @@ -190,11 +194,13 @@ val default_histogram_data_point : ?start_time_unix_nano:int64 -> ?time_unix_nano:int64 -> ?count:int64 -> - ?sum:float -> + ?sum:float option -> ?bucket_counts:int64 list -> ?explicit_bounds:float list -> ?exemplars:exemplar list -> ?flags:int32 -> + ?min:float option -> + ?max:float option -> unit -> histogram_data_point (** [default_histogram_data_point ()] is the default value for type [histogram_data_point] *) @@ -218,13 +224,15 @@ val default_exponential_histogram_data_point : ?start_time_unix_nano:int64 -> ?time_unix_nano:int64 -> ?count:int64 -> - ?sum:float -> + ?sum:float option -> ?scale:int32 -> ?zero_count:int64 -> ?positive:exponential_histogram_data_point_buckets option -> ?negative:exponential_histogram_data_point_buckets option -> ?flags:int32 -> ?exemplars:exemplar list -> + ?min:float option -> + ?max:float option -> unit -> exponential_histogram_data_point (** [default_exponential_histogram_data_point ()] is the default value for type [exponential_histogram_data_point] *) @@ -273,17 +281,17 @@ val default_metric : metric (** [default_metric ()] is the default value for type [metric] *) -val default_instrumentation_library_metrics : - ?instrumentation_library:Common_types.instrumentation_library option -> +val default_scope_metrics : + ?scope:Common_types.instrumentation_scope option -> ?metrics:metric list -> ?schema_url:string -> unit -> - instrumentation_library_metrics -(** [default_instrumentation_library_metrics ()] is the default value for type [instrumentation_library_metrics] *) + scope_metrics +(** [default_scope_metrics ()] is the default value for type [scope_metrics] *) val default_resource_metrics : ?resource:Resource_types.resource option -> - ?instrumentation_library_metrics:instrumentation_library_metrics list -> + ?scope_metrics:scope_metrics list -> ?schema_url:string -> unit -> resource_metrics diff --git a/src/trace_pb.ml b/src/trace_pb.ml index e292f726..1d2acfd9 100644 --- a/src/trace_pb.ml +++ b/src/trace_pb.ml @@ -76,27 +76,27 @@ let default_span_mutable () : span_mutable = { status = None; } -type instrumentation_library_spans_mutable = { - mutable instrumentation_library : Common_types.instrumentation_library option; +type scope_spans_mutable = { + mutable scope : Common_types.instrumentation_scope option; mutable spans : Trace_types.span list; mutable schema_url : string; } -let default_instrumentation_library_spans_mutable () : instrumentation_library_spans_mutable = { - instrumentation_library = None; +let default_scope_spans_mutable () : scope_spans_mutable = { + scope = None; spans = []; schema_url = ""; } type resource_spans_mutable = { mutable resource : Resource_types.resource option; - mutable instrumentation_library_spans : Trace_types.instrumentation_library_spans list; + mutable scope_spans : Trace_types.scope_spans list; mutable schema_url : string; } let default_resource_spans_mutable () : resource_spans_mutable = { resource = None; - instrumentation_library_spans = []; + scope_spans = []; schema_url = ""; } @@ -335,8 +335,8 @@ let rec decode_span d = Trace_types.status = v.status; } : Trace_types.span) -let rec decode_instrumentation_library_spans d = - let v = default_instrumentation_library_spans_mutable () in +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 @@ -344,27 +344,27 @@ let rec decode_instrumentation_library_spans d = v.spans <- List.rev v.spans; ); continue__ := false | Some (1, Pbrt.Bytes) -> begin - v.instrumentation_library <- Some (Common_pb.decode_instrumentation_library (Pbrt.Decoder.nested d)); + v.scope <- Some (Common_pb.decode_instrumentation_scope (Pbrt.Decoder.nested d)); end | Some (1, pk) -> - Pbrt.Decoder.unexpected_payload "Message(instrumentation_library_spans), field(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(instrumentation_library_spans), field(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(instrumentation_library_spans), field(3)" pk + Pbrt.Decoder.unexpected_payload "Message(scope_spans), field(3)" pk | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind done; ({ - Trace_types.instrumentation_library = v.instrumentation_library; + Trace_types.scope = v.scope; Trace_types.spans = v.spans; Trace_types.schema_url = v.schema_url; - } : Trace_types.instrumentation_library_spans) + } : Trace_types.scope_spans) let rec decode_resource_spans d = let v = default_resource_spans_mutable () in @@ -372,7 +372,7 @@ let rec decode_resource_spans d = while !continue__ do match Pbrt.Decoder.key d with | None -> ( - v.instrumentation_library_spans <- List.rev v.instrumentation_library_spans; + 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)); @@ -380,7 +380,7 @@ let rec decode_resource_spans d = | Some (1, pk) -> Pbrt.Decoder.unexpected_payload "Message(resource_spans), field(1)" pk | Some (2, Pbrt.Bytes) -> begin - v.instrumentation_library_spans <- (decode_instrumentation_library_spans (Pbrt.Decoder.nested d)) :: v.instrumentation_library_spans; + 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 @@ -393,7 +393,7 @@ let rec decode_resource_spans d = done; ({ Trace_types.resource = v.resource; - Trace_types.instrumentation_library_spans = v.instrumentation_library_spans; + Trace_types.scope_spans = v.scope_spans; Trace_types.schema_url = v.schema_url; } : Trace_types.resource_spans) @@ -509,11 +509,11 @@ let rec encode_span (v:Trace_types.span) encoder = end; () -let rec encode_instrumentation_library_spans (v:Trace_types.instrumentation_library_spans) encoder = - begin match v.Trace_types.instrumentation_library with +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_library x) encoder; + Pbrt.Encoder.nested (Common_pb.encode_instrumentation_scope x) encoder; | None -> (); end; List.iter (fun x -> @@ -533,8 +533,8 @@ let rec encode_resource_spans (v:Trace_types.resource_spans) encoder = end; List.iter (fun x -> Pbrt.Encoder.key (2, Pbrt.Bytes) encoder; - Pbrt.Encoder.nested (encode_instrumentation_library_spans x) encoder; - ) v.Trace_types.instrumentation_library_spans; + 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; () diff --git a/src/trace_pb.mli b/src/trace_pb.mli index 500c5644..8e93dba6 100644 --- a/src/trace_pb.mli +++ b/src/trace_pb.mli @@ -21,8 +21,8 @@ val encode_status : Trace_types.status -> Pbrt.Encoder.t -> unit val encode_span : Trace_types.span -> Pbrt.Encoder.t -> unit (** [encode_span v encoder] encodes [v] with the given [encoder] *) -val encode_instrumentation_library_spans : Trace_types.instrumentation_library_spans -> Pbrt.Encoder.t -> unit -(** [encode_instrumentation_library_spans v encoder] encodes [v] with the given [encoder] *) +val encode_scope_spans : Trace_types.scope_spans -> Pbrt.Encoder.t -> unit +(** [encode_scope_spans v encoder] encodes [v] with the given [encoder] *) val encode_resource_spans : Trace_types.resource_spans -> Pbrt.Encoder.t -> unit (** [encode_resource_spans v encoder] encodes [v] with the given [encoder] *) @@ -51,8 +51,8 @@ val decode_status : Pbrt.Decoder.t -> Trace_types.status val decode_span : Pbrt.Decoder.t -> Trace_types.span (** [decode_span decoder] decodes a [span] value from [decoder] *) -val decode_instrumentation_library_spans : Pbrt.Decoder.t -> Trace_types.instrumentation_library_spans -(** [decode_instrumentation_library_spans decoder] decodes a [instrumentation_library_spans] value from [decoder] *) +val decode_scope_spans : Pbrt.Decoder.t -> Trace_types.scope_spans +(** [decode_scope_spans decoder] decodes a [scope_spans] value from [decoder] *) val decode_resource_spans : Pbrt.Decoder.t -> Trace_types.resource_spans (** [decode_resource_spans decoder] decodes a [resource_spans] value from [decoder] *) diff --git a/src/trace_pp.ml b/src/trace_pp.ml index 06515c86..97faa78b 100644 --- a/src/trace_pp.ml +++ b/src/trace_pp.ml @@ -61,9 +61,9 @@ let rec pp_span fmt (v:Trace_types.span) = in Pbrt.Pp.pp_brk pp_i fmt () -let rec pp_instrumentation_library_spans fmt (v:Trace_types.instrumentation_library_spans) = +let rec pp_scope_spans fmt (v:Trace_types.scope_spans) = let pp_i fmt () = - Pbrt.Pp.pp_record_field ~first:true "instrumentation_library" (Pbrt.Pp.pp_option Common_pp.pp_instrumentation_library) fmt v.Trace_types.instrumentation_library; + Pbrt.Pp.pp_record_field ~first:true "scope" (Pbrt.Pp.pp_option Common_pp.pp_instrumentation_scope) fmt v.Trace_types.scope; Pbrt.Pp.pp_record_field ~first:false "spans" (Pbrt.Pp.pp_list pp_span) fmt v.Trace_types.spans; Pbrt.Pp.pp_record_field ~first:false "schema_url" Pbrt.Pp.pp_string fmt v.Trace_types.schema_url; in @@ -72,7 +72,7 @@ let rec pp_instrumentation_library_spans fmt (v:Trace_types.instrumentation_libr let rec pp_resource_spans fmt (v:Trace_types.resource_spans) = let pp_i fmt () = Pbrt.Pp.pp_record_field ~first:true "resource" (Pbrt.Pp.pp_option Resource_pp.pp_resource) fmt v.Trace_types.resource; - Pbrt.Pp.pp_record_field ~first:false "instrumentation_library_spans" (Pbrt.Pp.pp_list pp_instrumentation_library_spans) fmt v.Trace_types.instrumentation_library_spans; + Pbrt.Pp.pp_record_field ~first:false "scope_spans" (Pbrt.Pp.pp_list pp_scope_spans) fmt v.Trace_types.scope_spans; Pbrt.Pp.pp_record_field ~first:false "schema_url" Pbrt.Pp.pp_string fmt v.Trace_types.schema_url; in Pbrt.Pp.pp_brk pp_i fmt () diff --git a/src/trace_pp.mli b/src/trace_pp.mli index 608cefc6..047f5207 100644 --- a/src/trace_pp.mli +++ b/src/trace_pp.mli @@ -21,8 +21,8 @@ val pp_status : Format.formatter -> Trace_types.status -> unit val pp_span : Format.formatter -> Trace_types.span -> unit (** [pp_span v] formats v *) -val pp_instrumentation_library_spans : Format.formatter -> Trace_types.instrumentation_library_spans -> unit -(** [pp_instrumentation_library_spans v] formats v *) +val pp_scope_spans : Format.formatter -> Trace_types.scope_spans -> unit +(** [pp_scope_spans v] formats v *) val pp_resource_spans : Format.formatter -> Trace_types.resource_spans -> unit (** [pp_resource_spans v] formats v *) diff --git a/src/trace_service_pb.ml b/src/trace_service_pb.ml index 0ad75e7c..68733bcf 100644 --- a/src/trace_service_pb.ml +++ b/src/trace_service_pb.ml @@ -8,6 +8,24 @@ let default_export_trace_service_request_mutable () : export_trace_service_reque resource_spans = []; } +type export_trace_partial_success_mutable = { + mutable rejected_spans : int64; + mutable error_message : string; +} + +let default_export_trace_partial_success_mutable () : export_trace_partial_success_mutable = { + rejected_spans = 0L; + error_message = ""; +} + +type export_trace_service_response_mutable = { + mutable partial_success : Trace_service_types.export_trace_partial_success option; +} + +let default_export_trace_service_response_mutable () : export_trace_service_response_mutable = { + partial_success = None; +} + let rec decode_export_trace_service_request d = let v = default_export_trace_service_request_mutable () in @@ -28,9 +46,67 @@ let rec decode_export_trace_service_request d = Trace_service_types.resource_spans = v.resource_spans; } : Trace_service_types.export_trace_service_request) +let rec decode_export_trace_partial_success d = + let v = default_export_trace_partial_success_mutable () in + let continue__= ref true in + while !continue__ do + match Pbrt.Decoder.key d with + | None -> ( + ); continue__ := false + | Some (1, Pbrt.Varint) -> begin + v.rejected_spans <- Pbrt.Decoder.int64_as_varint d; + end + | Some (1, pk) -> + Pbrt.Decoder.unexpected_payload "Message(export_trace_partial_success), field(1)" pk + | Some (2, Pbrt.Bytes) -> begin + v.error_message <- Pbrt.Decoder.string d; + end + | Some (2, pk) -> + Pbrt.Decoder.unexpected_payload "Message(export_trace_partial_success), field(2)" pk + | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind + done; + ({ + Trace_service_types.rejected_spans = v.rejected_spans; + Trace_service_types.error_message = v.error_message; + } : Trace_service_types.export_trace_partial_success) + +let rec decode_export_trace_service_response d = + let v = default_export_trace_service_response_mutable () in + let continue__= ref true in + while !continue__ do + match Pbrt.Decoder.key d with + | None -> ( + ); continue__ := false + | Some (1, Pbrt.Bytes) -> begin + v.partial_success <- Some (decode_export_trace_partial_success (Pbrt.Decoder.nested d)); + end + | Some (1, pk) -> + Pbrt.Decoder.unexpected_payload "Message(export_trace_service_response), field(1)" pk + | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind + done; + ({ + Trace_service_types.partial_success = v.partial_success; + } : Trace_service_types.export_trace_service_response) + let rec encode_export_trace_service_request (v:Trace_service_types.export_trace_service_request) encoder = List.iter (fun x -> Pbrt.Encoder.key (1, Pbrt.Bytes) encoder; Pbrt.Encoder.nested (Trace_pb.encode_resource_spans x) encoder; ) v.Trace_service_types.resource_spans; () + +let rec encode_export_trace_partial_success (v:Trace_service_types.export_trace_partial_success) encoder = + Pbrt.Encoder.key (1, Pbrt.Varint) encoder; + Pbrt.Encoder.int64_as_varint v.Trace_service_types.rejected_spans encoder; + Pbrt.Encoder.key (2, Pbrt.Bytes) encoder; + Pbrt.Encoder.string v.Trace_service_types.error_message encoder; + () + +let rec encode_export_trace_service_response (v:Trace_service_types.export_trace_service_response) encoder = + begin match v.Trace_service_types.partial_success with + | Some x -> + Pbrt.Encoder.key (1, Pbrt.Bytes) encoder; + Pbrt.Encoder.nested (encode_export_trace_partial_success x) encoder; + | None -> (); + end; + () diff --git a/src/trace_service_pb.mli b/src/trace_service_pb.mli index 86f1218a..afd94a31 100644 --- a/src/trace_service_pb.mli +++ b/src/trace_service_pb.mli @@ -6,8 +6,20 @@ val encode_export_trace_service_request : Trace_service_types.export_trace_service_request -> Pbrt.Encoder.t -> unit (** [encode_export_trace_service_request v encoder] encodes [v] with the given [encoder] *) +val encode_export_trace_partial_success : Trace_service_types.export_trace_partial_success -> Pbrt.Encoder.t -> unit +(** [encode_export_trace_partial_success v encoder] encodes [v] with the given [encoder] *) + +val encode_export_trace_service_response : Trace_service_types.export_trace_service_response -> Pbrt.Encoder.t -> unit +(** [encode_export_trace_service_response v encoder] encodes [v] with the given [encoder] *) + (** {2 Protobuf Decoding} *) val decode_export_trace_service_request : Pbrt.Decoder.t -> Trace_service_types.export_trace_service_request (** [decode_export_trace_service_request decoder] decodes a [export_trace_service_request] value from [decoder] *) + +val decode_export_trace_partial_success : Pbrt.Decoder.t -> Trace_service_types.export_trace_partial_success +(** [decode_export_trace_partial_success decoder] decodes a [export_trace_partial_success] value from [decoder] *) + +val decode_export_trace_service_response : Pbrt.Decoder.t -> Trace_service_types.export_trace_service_response +(** [decode_export_trace_service_response decoder] decodes a [export_trace_service_response] value from [decoder] *) diff --git a/src/trace_service_pp.ml b/src/trace_service_pp.ml index f262dc19..edc069f2 100644 --- a/src/trace_service_pp.ml +++ b/src/trace_service_pp.ml @@ -5,3 +5,16 @@ let rec pp_export_trace_service_request fmt (v:Trace_service_types.export_trace_ Pbrt.Pp.pp_record_field ~first:true "resource_spans" (Pbrt.Pp.pp_list Trace_pp.pp_resource_spans) fmt v.Trace_service_types.resource_spans; in Pbrt.Pp.pp_brk pp_i fmt () + +let rec pp_export_trace_partial_success fmt (v:Trace_service_types.export_trace_partial_success) = + let pp_i fmt () = + Pbrt.Pp.pp_record_field ~first:true "rejected_spans" Pbrt.Pp.pp_int64 fmt v.Trace_service_types.rejected_spans; + Pbrt.Pp.pp_record_field ~first:false "error_message" Pbrt.Pp.pp_string fmt v.Trace_service_types.error_message; + in + Pbrt.Pp.pp_brk pp_i fmt () + +let rec pp_export_trace_service_response fmt (v:Trace_service_types.export_trace_service_response) = + let pp_i fmt () = + Pbrt.Pp.pp_record_field ~first:true "partial_success" (Pbrt.Pp.pp_option pp_export_trace_partial_success) fmt v.Trace_service_types.partial_success; + in + Pbrt.Pp.pp_brk pp_i fmt () diff --git a/src/trace_service_pp.mli b/src/trace_service_pp.mli index 0875af16..d7d52f99 100644 --- a/src/trace_service_pp.mli +++ b/src/trace_service_pp.mli @@ -5,3 +5,9 @@ val pp_export_trace_service_request : Format.formatter -> Trace_service_types.export_trace_service_request -> unit (** [pp_export_trace_service_request v] formats v *) + +val pp_export_trace_partial_success : Format.formatter -> Trace_service_types.export_trace_partial_success -> unit +(** [pp_export_trace_partial_success v] formats v *) + +val pp_export_trace_service_response : Format.formatter -> Trace_service_types.export_trace_service_response -> unit +(** [pp_export_trace_service_response v] formats v *) diff --git a/src/trace_service_types.ml b/src/trace_service_types.ml index 52afae3e..6476d53c 100644 --- a/src/trace_service_types.ml +++ b/src/trace_service_types.ml @@ -5,8 +5,31 @@ type export_trace_service_request = { resource_spans : Trace_types.resource_spans list; } +type export_trace_partial_success = { + rejected_spans : int64; + error_message : string; +} + +type export_trace_service_response = { + partial_success : export_trace_partial_success option; +} + let rec default_export_trace_service_request ?resource_spans:((resource_spans:Trace_types.resource_spans list) = []) () : export_trace_service_request = { resource_spans; } + +let rec default_export_trace_partial_success + ?rejected_spans:((rejected_spans:int64) = 0L) + ?error_message:((error_message:string) = "") + () : export_trace_partial_success = { + rejected_spans; + error_message; +} + +let rec default_export_trace_service_response + ?partial_success:((partial_success:export_trace_partial_success option) = None) + () : export_trace_service_response = { + partial_success; +} diff --git a/src/trace_service_types.mli b/src/trace_service_types.mli index 86bb7e81..e7480e77 100644 --- a/src/trace_service_types.mli +++ b/src/trace_service_types.mli @@ -8,6 +8,15 @@ type export_trace_service_request = { resource_spans : Trace_types.resource_spans list; } +type export_trace_partial_success = { + rejected_spans : int64; + error_message : string; +} + +type export_trace_service_response = { + partial_success : export_trace_partial_success option; +} + (** {2 Default values} *) @@ -16,3 +25,16 @@ val default_export_trace_service_request : unit -> export_trace_service_request (** [default_export_trace_service_request ()] is the default value for type [export_trace_service_request] *) + +val default_export_trace_partial_success : + ?rejected_spans:int64 -> + ?error_message:string -> + unit -> + export_trace_partial_success +(** [default_export_trace_partial_success ()] is the default value for type [export_trace_partial_success] *) + +val default_export_trace_service_response : + ?partial_success:export_trace_partial_success option -> + unit -> + export_trace_service_response +(** [default_export_trace_service_response ()] is the default value for type [export_trace_service_response] *) diff --git a/src/trace_types.ml b/src/trace_types.ml index 557adefb..3e51df35 100644 --- a/src/trace_types.ml +++ b/src/trace_types.ml @@ -52,15 +52,15 @@ type span = { status : status option; } -type instrumentation_library_spans = { - instrumentation_library : Common_types.instrumentation_library option; +type scope_spans = { + scope : Common_types.instrumentation_scope option; spans : span list; schema_url : string; } type resource_spans = { resource : Resource_types.resource option; - instrumentation_library_spans : instrumentation_library_spans list; + scope_spans : scope_spans list; schema_url : string; } @@ -140,23 +140,23 @@ let rec default_span status; } -let rec default_instrumentation_library_spans - ?instrumentation_library:((instrumentation_library:Common_types.instrumentation_library option) = None) +let rec default_scope_spans + ?scope:((scope:Common_types.instrumentation_scope option) = None) ?spans:((spans:span list) = []) ?schema_url:((schema_url:string) = "") - () : instrumentation_library_spans = { - instrumentation_library; + () : scope_spans = { + scope; spans; schema_url; } let rec default_resource_spans ?resource:((resource:Resource_types.resource option) = None) - ?instrumentation_library_spans:((instrumentation_library_spans:instrumentation_library_spans list) = []) + ?scope_spans:((scope_spans:scope_spans list) = []) ?schema_url:((schema_url:string) = "") () : resource_spans = { resource; - instrumentation_library_spans; + scope_spans; schema_url; } diff --git a/src/trace_types.mli b/src/trace_types.mli index cdf0ac86..ef7ac6dc 100644 --- a/src/trace_types.mli +++ b/src/trace_types.mli @@ -55,15 +55,15 @@ type span = { status : status option; } -type instrumentation_library_spans = { - instrumentation_library : Common_types.instrumentation_library option; +type scope_spans = { + scope : Common_types.instrumentation_scope option; spans : span list; schema_url : string; } type resource_spans = { resource : Resource_types.resource option; - instrumentation_library_spans : instrumentation_library_spans list; + scope_spans : scope_spans list; schema_url : string; } @@ -126,17 +126,17 @@ val default_span : span (** [default_span ()] is the default value for type [span] *) -val default_instrumentation_library_spans : - ?instrumentation_library:Common_types.instrumentation_library option -> +val default_scope_spans : + ?scope:Common_types.instrumentation_scope option -> ?spans:span list -> ?schema_url:string -> unit -> - instrumentation_library_spans -(** [default_instrumentation_library_spans ()] is the default value for type [instrumentation_library_spans] *) + scope_spans +(** [default_scope_spans ()] is the default value for type [scope_spans] *) val default_resource_spans : ?resource:Resource_types.resource option -> - ?instrumentation_library_spans:instrumentation_library_spans list -> + ?scope_spans:scope_spans list -> ?schema_url:string -> unit -> resource_spans From 8ea9d205fea23c5833ce98a79b06c967f25025cf Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Mon, 15 Aug 2022 13:53:58 -0400 Subject: [PATCH 3/7] refactor: update opentelemetry to use new codegen --- src/opentelemetry.ml | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/opentelemetry.ml b/src/opentelemetry.ml index 40c4fa98..ed89fd96 100644 --- a/src/opentelemetry.ml +++ b/src/opentelemetry.ml @@ -400,7 +400,7 @@ module Globals = struct let service_instance_id = ref None let instrumentation_library = - default_instrumentation_library ~version:"0.2" ~name:"ocaml-opentelemetry" + default_instrumentation_scope ~version:"0.2" ~name:"ocaml-opentelemetry" () (** Global attributes, initially set @@ -677,14 +677,14 @@ module Trace = struct let make_resource_spans ?service_name ?attrs spans = let ils = - default_instrumentation_library_spans - ~instrumentation_library:(Some Globals.instrumentation_library) ~spans + default_scope_spans + ~scope:(Some Globals.instrumentation_library) ~spans () in let attributes = Globals.mk_attributes ?service_name ?attrs () in let resource = Proto.Resource.default_resource ~attributes () in default_resource_spans ~resource:(Some resource) - ~instrumentation_library_spans:[ ils ] () + ~scope_spans:[ ils ] () (** Sync emitter. @@ -857,13 +857,13 @@ module Metrics = struct let make_resource_metrics ?service_name ?attrs (l : t list) : resource_metrics = let lm = - default_instrumentation_library_metrics - ~instrumentation_library:(Some Globals.instrumentation_library) + default_scope_metrics + ~scope:(Some Globals.instrumentation_library) ~metrics:l () in let attributes = Globals.mk_attributes ?service_name ?attrs () in let resource = Proto.Resource.default_resource ~attributes () in - default_resource_metrics ~instrumentation_library_metrics:[ lm ] + default_resource_metrics ~scope_metrics:[ lm ] ~resource:(Some resource) () (** Emit some metrics to the collector (sync). This blocks until @@ -962,13 +962,13 @@ module Logs = struct let attributes = Globals.mk_attributes ?service_name ?attrs () in let resource = Proto.Resource.default_resource ~attributes () in let ll = - default_instrumentation_library_logs - ~instrumentation_library:(Some Globals.instrumentation_library) + default_scope_logs + ~scope:(Some Globals.instrumentation_library) ~log_records:l () in let rl = default_resource_logs ~resource:(Some resource) - ~instrumentation_library_logs:[ ll ] () + ~scope_logs:[ ll ] () in Collector.send_logs [ rl ] ~ret:ignore end From 1aec277063960b68c24937ee2c6df5534d80ee8a Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Mon, 15 Aug 2022 14:16:39 -0400 Subject: [PATCH 4/7] fix: make sure trace_id/span_id are not all-0 --- src/opentelemetry.ml | 43 ++++++++++++++++++++++++------------------- src/rand_bytes.mli | 12 ++++++++++-- 2 files changed, 34 insertions(+), 21 deletions(-) diff --git a/src/opentelemetry.ml b/src/opentelemetry.ml index ed89fd96..f51d92e3 100644 --- a/src/opentelemetry.ml +++ b/src/opentelemetry.ml @@ -3,10 +3,10 @@ module Thread_local = Thread_local module Lock = Lock -(** Global lock *) +(** Global lock. *) module Rand_bytes = Rand_bytes -(** Generation of random identifiers *) +(** Generation of random identifiers. *) open struct let[@inline] result_bind x f = @@ -17,7 +17,9 @@ end (** {2 Wire format} *) -(** Protobuf types *) +(** Protobuf types. + + This is mostly useful internally. Users should not need to touch it. *) module Proto = struct module Common = struct include Common_types @@ -256,7 +258,12 @@ end = struct let to_bytes self = self - let create () : t = Collector.rand_bytes_16 () + let create () : t = + let b = Collector.rand_bytes_16 () in + assert (Bytes.length b = 16); + (* make sure the identifier is not all 0, which is a dummy identifier. *) + Bytes.set b 0 (Char.unsafe_chr (Char.code (Bytes.get b 0) lor 1)); + b let of_bytes b = if Bytes.length b = 16 then @@ -293,7 +300,12 @@ end = struct let to_bytes self = self - let create () : t = Collector.rand_bytes_8 () + let create () : t = + let b = Collector.rand_bytes_8 () in + assert (Bytes.length b = 8); + (* make sure the identifier is not all 0, which is a dummy identifier. *) + Bytes.set b 0 (Char.unsafe_chr (Char.code (Bytes.get b 0) lor 1)); + b let of_bytes b = if Bytes.length b = 8 then @@ -400,8 +412,7 @@ module Globals = struct let service_instance_id = ref None let instrumentation_library = - default_instrumentation_scope ~version:"0.2" ~name:"ocaml-opentelemetry" - () + default_instrumentation_scope ~version:"0.2" ~name:"ocaml-opentelemetry" () (** Global attributes, initially set via OTEL_RESOURCE_ATTRIBUTES and modifiable @@ -677,14 +688,12 @@ module Trace = struct let make_resource_spans ?service_name ?attrs spans = let ils = - default_scope_spans - ~scope:(Some Globals.instrumentation_library) ~spans + default_scope_spans ~scope:(Some Globals.instrumentation_library) ~spans () in let attributes = Globals.mk_attributes ?service_name ?attrs () in let resource = Proto.Resource.default_resource ~attributes () in - default_resource_spans ~resource:(Some resource) - ~scope_spans:[ ils ] () + default_resource_spans ~resource:(Some resource) ~scope_spans:[ ils ] () (** Sync emitter. @@ -857,14 +866,12 @@ module Metrics = struct let make_resource_metrics ?service_name ?attrs (l : t list) : resource_metrics = let lm = - default_scope_metrics - ~scope:(Some Globals.instrumentation_library) + default_scope_metrics ~scope:(Some Globals.instrumentation_library) ~metrics:l () in let attributes = Globals.mk_attributes ?service_name ?attrs () in let resource = Proto.Resource.default_resource ~attributes () in - default_resource_metrics ~scope_metrics:[ lm ] - ~resource:(Some resource) () + default_resource_metrics ~scope_metrics:[ lm ] ~resource:(Some resource) () (** Emit some metrics to the collector (sync). This blocks until the backend has pushed the metrics into some internal queue, or @@ -962,13 +969,11 @@ module Logs = struct let attributes = Globals.mk_attributes ?service_name ?attrs () in let resource = Proto.Resource.default_resource ~attributes () in let ll = - default_scope_logs - ~scope:(Some Globals.instrumentation_library) + default_scope_logs ~scope:(Some Globals.instrumentation_library) ~log_records:l () in let rl = - default_resource_logs ~resource:(Some resource) - ~scope_logs:[ ll ] () + default_resource_logs ~resource:(Some resource) ~scope_logs:[ ll ] () in Collector.send_logs [ rl ] ~ret:ignore end diff --git a/src/rand_bytes.mli b/src/rand_bytes.mli index b1e4c811..bea76349 100644 --- a/src/rand_bytes.mli +++ b/src/rand_bytes.mli @@ -1,9 +1,17 @@ +(** Generate random identifiers. + + We need random identifiers for trace IDs and span IDs. *) + val rand_bytes_16 : (unit -> bytes) ref -(** Generate 16 bytes of random data *) +(** Generate 16 bytes of random data. + The implementation can be swapped to use any random generator. *) val rand_bytes_8 : (unit -> bytes) ref -(** Generate 16 bytes of random data *) +(** Generate 16 bytes of random data. + The implementation can be swapped to use any random generator. *) val default_rand_bytes_8 : unit -> bytes +(** Default implementation using {!Random} *) val default_rand_bytes_16 : unit -> bytes +(** Default implementation using {!Random} *) From 078b07473488f1313765979d53de126483012ebd Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Wed, 17 Aug 2022 10:28:14 -0400 Subject: [PATCH 5/7] chore: ask for ocaml-protoc 2.3 in CI version that supports optional in proto3 --- .github/workflows/main.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 04898239..3fcb5232 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -41,7 +41,7 @@ jobs: - run: opam exec -- dune build @install -p opentelemetry,opentelemetry-lwt,opentelemetry-client-ocurl,opentelemetry-cohttp-lwt - - run: opam install ocaml-protoc -y + - run: opam pin ocaml-protoc 2.3 -y - run: opam exec -- dune build @lint From 3d00ffc1e06a795232d44f8afdb65adf3d4035f1 Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Wed, 17 Aug 2022 10:28:32 -0400 Subject: [PATCH 6/7] chore: drop dep on ocaml-protoc as the generated code is checked-in --- dune-project | 2 -- opentelemetry-client-ocurl.opam | 1 - opentelemetry.opam | 1 - 3 files changed, 4 deletions(-) diff --git a/dune-project b/dune-project index 544ea3ca..e8134b77 100644 --- a/dune-project +++ b/dune-project @@ -18,7 +18,6 @@ (ocaml (>= "4.08")) ptime (odoc :with-doc) - (ocaml-protoc (>= 2.2)) (pbrt (>= 2.2))) (tags (instrumentation tracing opentelemetry datadog jaeger))) @@ -42,7 +41,6 @@ (mtime (>= "1.4")) ; for spans ; atomic ; vendored (opentelemetry (= :version)) - (ocaml-protoc (>= 2.2)) (pbrt (>= 2.2)) (odoc :with-doc) ocurl) diff --git a/opentelemetry-client-ocurl.opam b/opentelemetry-client-ocurl.opam index 8dff25d9..8c84ae11 100644 --- a/opentelemetry-client-ocurl.opam +++ b/opentelemetry-client-ocurl.opam @@ -13,7 +13,6 @@ depends: [ "ocaml" {>= "4.08"} "mtime" {>= "1.4"} "opentelemetry" {= version} - "ocaml-protoc" {>= "2.2"} "pbrt" {>= "2.2"} "odoc" {with-doc} "ocurl" diff --git a/opentelemetry.opam b/opentelemetry.opam index b530dee1..671d97bd 100644 --- a/opentelemetry.opam +++ b/opentelemetry.opam @@ -14,7 +14,6 @@ depends: [ "ocaml" {>= "4.08"} "ptime" "odoc" {with-doc} - "ocaml-protoc" {>= "2.2"} "pbrt" {>= "2.2"} ] build: [ From deae27d0bd87e6a209ed06a2eda369ca561e5beb Mon Sep 17 00:00:00 2001 From: Simon Cruanes Date: Fri, 30 Sep 2022 14:06:48 -0400 Subject: [PATCH 7/7] update generated code and main library --- dune-project | 4 ++-- opentelemetry-client-ocurl.opam | 2 +- opentelemetry.opam | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/dune-project b/dune-project index e8134b77..272aeb7c 100644 --- a/dune-project +++ b/dune-project @@ -18,7 +18,7 @@ (ocaml (>= "4.08")) ptime (odoc :with-doc) - (pbrt (>= 2.2))) + (pbrt (>= 2.3))) (tags (instrumentation tracing opentelemetry datadog jaeger))) @@ -41,7 +41,7 @@ (mtime (>= "1.4")) ; for spans ; atomic ; vendored (opentelemetry (= :version)) - (pbrt (>= 2.2)) + (pbrt (>= 2.3)) (odoc :with-doc) ocurl) (synopsis "Collector client for opentelemetry, using http + ocurl")) diff --git a/opentelemetry-client-ocurl.opam b/opentelemetry-client-ocurl.opam index 8c84ae11..8f029567 100644 --- a/opentelemetry-client-ocurl.opam +++ b/opentelemetry-client-ocurl.opam @@ -13,7 +13,7 @@ depends: [ "ocaml" {>= "4.08"} "mtime" {>= "1.4"} "opentelemetry" {= version} - "pbrt" {>= "2.2"} + "pbrt" {>= "2.3"} "odoc" {with-doc} "ocurl" ] diff --git a/opentelemetry.opam b/opentelemetry.opam index 671d97bd..6175f05e 100644 --- a/opentelemetry.opam +++ b/opentelemetry.opam @@ -14,7 +14,7 @@ depends: [ "ocaml" {>= "4.08"} "ptime" "odoc" {with-doc} - "pbrt" {>= "2.2"} + "pbrt" {>= "2.3"} ] build: [ ["dune" "subst"] {dev}