Source file logs.ml

[@@@ocaml.warning "-23-27-30-39-44"]

type severity_number =
  | Severity_number_unspecified 
  | Severity_number_trace 
  | Severity_number_trace2 
  | Severity_number_trace3 
  | Severity_number_trace4 
  | Severity_number_debug 
  | Severity_number_debug2 
  | Severity_number_debug3 
  | Severity_number_debug4 
  | Severity_number_info 
  | Severity_number_info2 
  | Severity_number_info3 
  | Severity_number_info4 
  | Severity_number_warn 
  | Severity_number_warn2 
  | Severity_number_warn3 
  | Severity_number_warn4 
  | Severity_number_error 
  | Severity_number_error2 
  | Severity_number_error3 
  | Severity_number_error4 
  | Severity_number_fatal 
  | Severity_number_fatal2 
  | Severity_number_fatal3 
  | Severity_number_fatal4 

type log_record = {
  mutable _presence: Pbrt.Bitfield.t; (** presence for 9 fields *)
  mutable time_unix_nano : int64;
  mutable observed_time_unix_nano : int64;
  mutable severity_number : severity_number;
  mutable severity_text : string;
  mutable body : Common.any_value option;
  mutable attributes : Common.key_value list;
  mutable dropped_attributes_count : int32;
  mutable flags : int32;
  mutable trace_id : bytes;
  mutable span_id : bytes;
  mutable event_name : string;
}

type scope_logs = {
  mutable _presence: Pbrt.Bitfield.t; (** presence for 1 fields *)
  mutable scope : Common.instrumentation_scope option;
  mutable log_records : log_record list;
  mutable schema_url : string;
}

type resource_logs = {
  mutable _presence: Pbrt.Bitfield.t; (** presence for 1 fields *)
  mutable resource : Resource.resource option;
  mutable scope_logs : scope_logs list;
  mutable schema_url : string;
}

type logs_data = {
  mutable resource_logs : resource_logs list;
}

type log_record_flags =
  | Log_record_flags_do_not_use 
  | Log_record_flags_trace_flags_mask 

let default_severity_number () = (Severity_number_unspecified:severity_number)

let default_log_record (): log_record =
{
  _presence=Pbrt.Bitfield.empty;
  time_unix_nano=0L;
  observed_time_unix_nano=0L;
  severity_number=default_severity_number ();
  severity_text="";
  body=None;
  attributes=[];
  dropped_attributes_count=0l;
  flags=0l;
  trace_id=Bytes.create 0;
  span_id=Bytes.create 0;
  event_name="";
}

let default_scope_logs (): scope_logs =
{
  _presence=Pbrt.Bitfield.empty;
  scope=None;
  log_records=[];
  schema_url="";
}

let default_resource_logs (): resource_logs =
{
  _presence=Pbrt.Bitfield.empty;
  resource=None;
  scope_logs=[];
  schema_url="";
}

let default_logs_data (): logs_data =
{
  resource_logs=[];
}

let default_log_record_flags () = (Log_record_flags_do_not_use:log_record_flags)


(** {2 Make functions} *)

let[@inline] log_record_has_time_unix_nano (self:log_record) : bool = (Pbrt.Bitfield.get self._presence 0)
let[@inline] log_record_has_observed_time_unix_nano (self:log_record) : bool = (Pbrt.Bitfield.get self._presence 1)
let[@inline] log_record_has_severity_number (self:log_record) : bool = (Pbrt.Bitfield.get self._presence 2)
let[@inline] log_record_has_severity_text (self:log_record) : bool = (Pbrt.Bitfield.get self._presence 3)
let[@inline] log_record_has_dropped_attributes_count (self:log_record) : bool = (Pbrt.Bitfield.get self._presence 4)
let[@inline] log_record_has_flags (self:log_record) : bool = (Pbrt.Bitfield.get self._presence 5)
let[@inline] log_record_has_trace_id (self:log_record) : bool = (Pbrt.Bitfield.get self._presence 6)
let[@inline] log_record_has_span_id (self:log_record) : bool = (Pbrt.Bitfield.get self._presence 7)
let[@inline] log_record_has_event_name (self:log_record) : bool = (Pbrt.Bitfield.get self._presence 8)

let[@inline] log_record_set_time_unix_nano (self:log_record) (x:int64) : unit =
  self._presence <- (Pbrt.Bitfield.set self._presence 0); self.time_unix_nano <- x
let[@inline] log_record_set_observed_time_unix_nano (self:log_record) (x:int64) : unit =
  self._presence <- (Pbrt.Bitfield.set self._presence 1); self.observed_time_unix_nano <- x
let[@inline] log_record_set_severity_number (self:log_record) (x:severity_number) : unit =
  self._presence <- (Pbrt.Bitfield.set self._presence 2); self.severity_number <- x
let[@inline] log_record_set_severity_text (self:log_record) (x:string) : unit =
  self._presence <- (Pbrt.Bitfield.set self._presence 3); self.severity_text <- x
let[@inline] log_record_set_body (self:log_record) (x:Common.any_value) : unit =
  self.body <- Some x
let[@inline] log_record_set_attributes (self:log_record) (x:Common.key_value list) : unit =
  self.attributes <- x
let[@inline] log_record_set_dropped_attributes_count (self:log_record) (x:int32) : unit =
  self._presence <- (Pbrt.Bitfield.set self._presence 4); self.dropped_attributes_count <- x
let[@inline] log_record_set_flags (self:log_record) (x:int32) : unit =
  self._presence <- (Pbrt.Bitfield.set self._presence 5); self.flags <- x
let[@inline] log_record_set_trace_id (self:log_record) (x:bytes) : unit =
  self._presence <- (Pbrt.Bitfield.set self._presence 6); self.trace_id <- x
let[@inline] log_record_set_span_id (self:log_record) (x:bytes) : unit =
  self._presence <- (Pbrt.Bitfield.set self._presence 7); self.span_id <- x
let[@inline] log_record_set_event_name (self:log_record) (x:string) : unit =
  self._presence <- (Pbrt.Bitfield.set self._presence 8); self.event_name <- x

let copy_log_record (self:log_record) : log_record =
  { self with time_unix_nano = self.time_unix_nano }

let make_log_record 
  ?(time_unix_nano:int64 option)
  ?(observed_time_unix_nano:int64 option)
  ?(severity_number:severity_number option)
  ?(severity_text:string option)
  ?(body:Common.any_value option)
  ?(attributes=[])
  ?(dropped_attributes_count:int32 option)
  ?(flags:int32 option)
  ?(trace_id:bytes option)
  ?(span_id:bytes option)
  ?(event_name:string option)
  () : log_record  =
  let _res = default_log_record () in
  (match time_unix_nano with
  | None -> ()
  | Some v -> log_record_set_time_unix_nano _res v);
  (match observed_time_unix_nano with
  | None -> ()
  | Some v -> log_record_set_observed_time_unix_nano _res v);
  (match severity_number with
  | None -> ()
  | Some v -> log_record_set_severity_number _res v);
  (match severity_text with
  | None -> ()
  | Some v -> log_record_set_severity_text _res v);
  (match body with
  | None -> ()
  | Some v -> log_record_set_body _res v);
  log_record_set_attributes _res attributes;
  (match dropped_attributes_count with
  | None -> ()
  | Some v -> log_record_set_dropped_attributes_count _res v);
  (match flags with
  | None -> ()
  | Some v -> log_record_set_flags _res v);
  (match trace_id with
  | None -> ()
  | Some v -> log_record_set_trace_id _res v);
  (match span_id with
  | None -> ()
  | Some v -> log_record_set_span_id _res v);
  (match event_name with
  | None -> ()
  | Some v -> log_record_set_event_name _res v);
  _res

let[@inline] scope_logs_has_schema_url (self:scope_logs) : bool = (Pbrt.Bitfield.get self._presence 0)

let[@inline] scope_logs_set_scope (self:scope_logs) (x:Common.instrumentation_scope) : unit =
  self.scope <- Some x
let[@inline] scope_logs_set_log_records (self:scope_logs) (x:log_record list) : unit =
  self.log_records <- x
let[@inline] scope_logs_set_schema_url (self:scope_logs) (x:string) : unit =
  self._presence <- (Pbrt.Bitfield.set self._presence 0); self.schema_url <- x

let copy_scope_logs (self:scope_logs) : scope_logs =
  { self with scope = self.scope }

let make_scope_logs 
  ?(scope:Common.instrumentation_scope option)
  ?(log_records=[])
  ?(schema_url:string option)
  () : scope_logs  =
  let _res = default_scope_logs () in
  (match scope with
  | None -> ()
  | Some v -> scope_logs_set_scope _res v);
  scope_logs_set_log_records _res log_records;
  (match schema_url with
  | None -> ()
  | Some v -> scope_logs_set_schema_url _res v);
  _res

let[@inline] resource_logs_has_schema_url (self:resource_logs) : bool = (Pbrt.Bitfield.get self._presence 0)

let[@inline] resource_logs_set_resource (self:resource_logs) (x:Resource.resource) : unit =
  self.resource <- Some x
let[@inline] resource_logs_set_scope_logs (self:resource_logs) (x:scope_logs list) : unit =
  self.scope_logs <- x
let[@inline] resource_logs_set_schema_url (self:resource_logs) (x:string) : unit =
  self._presence <- (Pbrt.Bitfield.set self._presence 0); self.schema_url <- x

let copy_resource_logs (self:resource_logs) : resource_logs =
  { self with resource = self.resource }

let make_resource_logs 
  ?(resource:Resource.resource option)
  ?(scope_logs=[])
  ?(schema_url:string option)
  () : resource_logs  =
  let _res = default_resource_logs () in
  (match resource with
  | None -> ()
  | Some v -> resource_logs_set_resource _res v);
  resource_logs_set_scope_logs _res scope_logs;
  (match schema_url with
  | None -> ()
  | Some v -> resource_logs_set_schema_url _res v);
  _res


let[@inline] logs_data_set_resource_logs (self:logs_data) (x:resource_logs list) : unit =
  self.resource_logs <- x

let copy_logs_data (self:logs_data) : logs_data =
  { self with resource_logs = self.resource_logs }

let make_logs_data 
  ?(resource_logs=[])
  () : logs_data  =
  let _res = default_logs_data () in
  logs_data_set_resource_logs _res resource_logs;
  _res

[@@@ocaml.warning "-23-27-30-39"]

(** {2 Formatters} *)

let rec pp_severity_number fmt (v:severity_number) =
  match v with
  | Severity_number_unspecified -> Format.fprintf fmt "Severity_number_unspecified"
  | Severity_number_trace -> Format.fprintf fmt "Severity_number_trace"
  | Severity_number_trace2 -> Format.fprintf fmt "Severity_number_trace2"
  | Severity_number_trace3 -> Format.fprintf fmt "Severity_number_trace3"
  | Severity_number_trace4 -> Format.fprintf fmt "Severity_number_trace4"
  | Severity_number_debug -> Format.fprintf fmt "Severity_number_debug"
  | Severity_number_debug2 -> Format.fprintf fmt "Severity_number_debug2"
  | Severity_number_debug3 -> Format.fprintf fmt "Severity_number_debug3"
  | Severity_number_debug4 -> Format.fprintf fmt "Severity_number_debug4"
  | Severity_number_info -> Format.fprintf fmt "Severity_number_info"
  | Severity_number_info2 -> Format.fprintf fmt "Severity_number_info2"
  | Severity_number_info3 -> Format.fprintf fmt "Severity_number_info3"
  | Severity_number_info4 -> Format.fprintf fmt "Severity_number_info4"
  | Severity_number_warn -> Format.fprintf fmt "Severity_number_warn"
  | Severity_number_warn2 -> Format.fprintf fmt "Severity_number_warn2"
  | Severity_number_warn3 -> Format.fprintf fmt "Severity_number_warn3"
  | Severity_number_warn4 -> Format.fprintf fmt "Severity_number_warn4"
  | Severity_number_error -> Format.fprintf fmt "Severity_number_error"
  | Severity_number_error2 -> Format.fprintf fmt "Severity_number_error2"
  | Severity_number_error3 -> Format.fprintf fmt "Severity_number_error3"
  | Severity_number_error4 -> Format.fprintf fmt "Severity_number_error4"
  | Severity_number_fatal -> Format.fprintf fmt "Severity_number_fatal"
  | Severity_number_fatal2 -> Format.fprintf fmt "Severity_number_fatal2"
  | Severity_number_fatal3 -> Format.fprintf fmt "Severity_number_fatal3"
  | Severity_number_fatal4 -> Format.fprintf fmt "Severity_number_fatal4"

let rec pp_log_record fmt (v:log_record) = 
  let pp_i fmt () =
    Pbrt.Pp.pp_record_field ~absent:(not (log_record_has_time_unix_nano v)) ~first:true "time_unix_nano" Pbrt.Pp.pp_int64 fmt v.time_unix_nano;
    Pbrt.Pp.pp_record_field ~absent:(not (log_record_has_observed_time_unix_nano v)) ~first:false "observed_time_unix_nano" Pbrt.Pp.pp_int64 fmt v.observed_time_unix_nano;
    Pbrt.Pp.pp_record_field ~absent:(not (log_record_has_severity_number v)) ~first:false "severity_number" pp_severity_number fmt v.severity_number;
    Pbrt.Pp.pp_record_field ~absent:(not (log_record_has_severity_text v)) ~first:false "severity_text" Pbrt.Pp.pp_string fmt v.severity_text;
    Pbrt.Pp.pp_record_field ~first:false "body" (Pbrt.Pp.pp_option Common.pp_any_value) fmt v.body;
    Pbrt.Pp.pp_record_field ~first:false "attributes" (Pbrt.Pp.pp_list Common.pp_key_value) fmt v.attributes;
    Pbrt.Pp.pp_record_field ~absent:(not (log_record_has_dropped_attributes_count v)) ~first:false "dropped_attributes_count" Pbrt.Pp.pp_int32 fmt v.dropped_attributes_count;
    Pbrt.Pp.pp_record_field ~absent:(not (log_record_has_flags v)) ~first:false "flags" Pbrt.Pp.pp_int32 fmt v.flags;
    Pbrt.Pp.pp_record_field ~absent:(not (log_record_has_trace_id v)) ~first:false "trace_id" Pbrt.Pp.pp_bytes fmt v.trace_id;
    Pbrt.Pp.pp_record_field ~absent:(not (log_record_has_span_id v)) ~first:false "span_id" Pbrt.Pp.pp_bytes fmt v.span_id;
    Pbrt.Pp.pp_record_field ~absent:(not (log_record_has_event_name v)) ~first:false "event_name" Pbrt.Pp.pp_string fmt v.event_name;
  in
  Pbrt.Pp.pp_brk pp_i fmt ()

let rec pp_scope_logs fmt (v:scope_logs) = 
  let pp_i fmt () =
    Pbrt.Pp.pp_record_field ~first:true "scope" (Pbrt.Pp.pp_option Common.pp_instrumentation_scope) fmt v.scope;
    Pbrt.Pp.pp_record_field ~first:false "log_records" (Pbrt.Pp.pp_list pp_log_record) fmt v.log_records;
    Pbrt.Pp.pp_record_field ~absent:(not (scope_logs_has_schema_url v)) ~first:false "schema_url" Pbrt.Pp.pp_string fmt v.schema_url;
  in
  Pbrt.Pp.pp_brk pp_i fmt ()

let rec pp_resource_logs fmt (v:resource_logs) = 
  let pp_i fmt () =
    Pbrt.Pp.pp_record_field ~first:true "resource" (Pbrt.Pp.pp_option Resource.pp_resource) fmt v.resource;
    Pbrt.Pp.pp_record_field ~first:false "scope_logs" (Pbrt.Pp.pp_list pp_scope_logs) fmt v.scope_logs;
    Pbrt.Pp.pp_record_field ~absent:(not (resource_logs_has_schema_url v)) ~first:false "schema_url" Pbrt.Pp.pp_string fmt v.schema_url;
  in
  Pbrt.Pp.pp_brk pp_i fmt ()

let rec pp_logs_data fmt (v:logs_data) = 
  let pp_i fmt () =
    Pbrt.Pp.pp_record_field ~first:true "resource_logs" (Pbrt.Pp.pp_list pp_resource_logs) fmt v.resource_logs;
  in
  Pbrt.Pp.pp_brk pp_i fmt ()

let rec pp_log_record_flags fmt (v:log_record_flags) =
  match v with
  | Log_record_flags_do_not_use -> Format.fprintf fmt "Log_record_flags_do_not_use"
  | Log_record_flags_trace_flags_mask -> Format.fprintf fmt "Log_record_flags_trace_flags_mask"

[@@@ocaml.warning "-23-27-30-39"]

(** {2 Protobuf Encoding} *)

let rec encode_pb_severity_number (v:severity_number) encoder =
  match v with
  | Severity_number_unspecified -> Pbrt.Encoder.int_as_varint (0) encoder
  | Severity_number_trace -> Pbrt.Encoder.int_as_varint 1 encoder
  | Severity_number_trace2 -> Pbrt.Encoder.int_as_varint 2 encoder
  | Severity_number_trace3 -> Pbrt.Encoder.int_as_varint 3 encoder
  | Severity_number_trace4 -> Pbrt.Encoder.int_as_varint 4 encoder
  | Severity_number_debug -> Pbrt.Encoder.int_as_varint 5 encoder
  | Severity_number_debug2 -> Pbrt.Encoder.int_as_varint 6 encoder
  | Severity_number_debug3 -> Pbrt.Encoder.int_as_varint 7 encoder
  | Severity_number_debug4 -> Pbrt.Encoder.int_as_varint 8 encoder
  | Severity_number_info -> Pbrt.Encoder.int_as_varint 9 encoder
  | Severity_number_info2 -> Pbrt.Encoder.int_as_varint 10 encoder
  | Severity_number_info3 -> Pbrt.Encoder.int_as_varint 11 encoder
  | Severity_number_info4 -> Pbrt.Encoder.int_as_varint 12 encoder
  | Severity_number_warn -> Pbrt.Encoder.int_as_varint 13 encoder
  | Severity_number_warn2 -> Pbrt.Encoder.int_as_varint 14 encoder
  | Severity_number_warn3 -> Pbrt.Encoder.int_as_varint 15 encoder
  | Severity_number_warn4 -> Pbrt.Encoder.int_as_varint 16 encoder
  | Severity_number_error -> Pbrt.Encoder.int_as_varint 17 encoder
  | Severity_number_error2 -> Pbrt.Encoder.int_as_varint 18 encoder
  | Severity_number_error3 -> Pbrt.Encoder.int_as_varint 19 encoder
  | Severity_number_error4 -> Pbrt.Encoder.int_as_varint 20 encoder
  | Severity_number_fatal -> Pbrt.Encoder.int_as_varint 21 encoder
  | Severity_number_fatal2 -> Pbrt.Encoder.int_as_varint 22 encoder
  | Severity_number_fatal3 -> Pbrt.Encoder.int_as_varint 23 encoder
  | Severity_number_fatal4 -> Pbrt.Encoder.int_as_varint 24 encoder

let rec encode_pb_log_record (v:log_record) encoder = 
  if log_record_has_time_unix_nano v then (
    Pbrt.Encoder.int64_as_bits64 v.time_unix_nano encoder;
    Pbrt.Encoder.key 1 Pbrt.Bits64 encoder; 
  );
  if log_record_has_observed_time_unix_nano v then (
    Pbrt.Encoder.int64_as_bits64 v.observed_time_unix_nano encoder;
    Pbrt.Encoder.key 11 Pbrt.Bits64 encoder; 
  );
  if log_record_has_severity_number v then (
    encode_pb_severity_number v.severity_number encoder;
    Pbrt.Encoder.key 2 Pbrt.Varint encoder; 
  );
  if log_record_has_severity_text v then (
    Pbrt.Encoder.string v.severity_text encoder;
    Pbrt.Encoder.key 3 Pbrt.Bytes encoder; 
  );
  begin match v.body with
  | Some x -> 
    Pbrt.Encoder.nested Common.encode_pb_any_value x encoder;
    Pbrt.Encoder.key 5 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  Pbrt.List_util.rev_iter_with (fun x encoder ->
    Pbrt.Encoder.nested Common.encode_pb_key_value x encoder;
    Pbrt.Encoder.key 6 Pbrt.Bytes encoder; 
  ) v.attributes encoder;
  if log_record_has_dropped_attributes_count v then (
    Pbrt.Encoder.int32_as_varint v.dropped_attributes_count encoder;
    Pbrt.Encoder.key 7 Pbrt.Varint encoder; 
  );
  if log_record_has_flags v then (
    Pbrt.Encoder.int32_as_bits32 v.flags encoder;
    Pbrt.Encoder.key 8 Pbrt.Bits32 encoder; 
  );
  if log_record_has_trace_id v then (
    Pbrt.Encoder.bytes v.trace_id encoder;
    Pbrt.Encoder.key 9 Pbrt.Bytes encoder; 
  );
  if log_record_has_span_id v then (
    Pbrt.Encoder.bytes v.span_id encoder;
    Pbrt.Encoder.key 10 Pbrt.Bytes encoder; 
  );
  if log_record_has_event_name v then (
    Pbrt.Encoder.string v.event_name encoder;
    Pbrt.Encoder.key 12 Pbrt.Bytes encoder; 
  );
  ()

let rec encode_pb_scope_logs (v:scope_logs) encoder = 
  begin match v.scope with
  | Some x -> 
    Pbrt.Encoder.nested Common.encode_pb_instrumentation_scope x encoder;
    Pbrt.Encoder.key 1 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  Pbrt.List_util.rev_iter_with (fun x encoder ->
    Pbrt.Encoder.nested encode_pb_log_record x encoder;
    Pbrt.Encoder.key 2 Pbrt.Bytes encoder; 
  ) v.log_records encoder;
  if scope_logs_has_schema_url v then (
    Pbrt.Encoder.string v.schema_url encoder;
    Pbrt.Encoder.key 3 Pbrt.Bytes encoder; 
  );
  ()

let rec encode_pb_resource_logs (v:resource_logs) encoder = 
  begin match v.resource with
  | Some x -> 
    Pbrt.Encoder.nested Resource.encode_pb_resource x encoder;
    Pbrt.Encoder.key 1 Pbrt.Bytes encoder; 
  | None -> ();
  end;
  Pbrt.List_util.rev_iter_with (fun x encoder ->
    Pbrt.Encoder.nested encode_pb_scope_logs x encoder;
    Pbrt.Encoder.key 2 Pbrt.Bytes encoder; 
  ) v.scope_logs encoder;
  if resource_logs_has_schema_url v then (
    Pbrt.Encoder.string v.schema_url encoder;
    Pbrt.Encoder.key 3 Pbrt.Bytes encoder; 
  );
  ()

let rec encode_pb_logs_data (v:logs_data) encoder = 
  Pbrt.List_util.rev_iter_with (fun x encoder ->
    Pbrt.Encoder.nested encode_pb_resource_logs x encoder;
    Pbrt.Encoder.key 1 Pbrt.Bytes encoder; 
  ) v.resource_logs encoder;
  ()

let rec encode_pb_log_record_flags (v:log_record_flags) encoder =
  match v with
  | Log_record_flags_do_not_use -> Pbrt.Encoder.int_as_varint (0) encoder
  | Log_record_flags_trace_flags_mask -> Pbrt.Encoder.int_as_varint 255 encoder

[@@@ocaml.warning "-23-27-30-39"]

(** {2 Protobuf Decoding} *)

let rec decode_pb_severity_number d : severity_number = 
  match Pbrt.Decoder.int_as_varint d with
  | 0 -> Severity_number_unspecified
  | 1 -> Severity_number_trace
  | 2 -> Severity_number_trace2
  | 3 -> Severity_number_trace3
  | 4 -> Severity_number_trace4
  | 5 -> Severity_number_debug
  | 6 -> Severity_number_debug2
  | 7 -> Severity_number_debug3
  | 8 -> Severity_number_debug4
  | 9 -> Severity_number_info
  | 10 -> Severity_number_info2
  | 11 -> Severity_number_info3
  | 12 -> Severity_number_info4
  | 13 -> Severity_number_warn
  | 14 -> Severity_number_warn2
  | 15 -> Severity_number_warn3
  | 16 -> Severity_number_warn4
  | 17 -> Severity_number_error
  | 18 -> Severity_number_error2
  | 19 -> Severity_number_error3
  | 20 -> Severity_number_error4
  | 21 -> Severity_number_fatal
  | 22 -> Severity_number_fatal2
  | 23 -> Severity_number_fatal3
  | 24 -> Severity_number_fatal4
  | _ -> Pbrt.Decoder.malformed_variant "severity_number"

let rec decode_pb_log_record d =
  let v = default_log_record () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
      (* put lists in the correct order *)
      log_record_set_attributes v (List.rev v.attributes);
    ); continue__ := false
    | Some (1, Pbrt.Bits64) -> begin
      log_record_set_time_unix_nano v (Pbrt.Decoder.int64_as_bits64 d);
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "log_record" 1 pk
    | Some (11, Pbrt.Bits64) -> begin
      log_record_set_observed_time_unix_nano v (Pbrt.Decoder.int64_as_bits64 d);
    end
    | Some (11, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "log_record" 11 pk
    | Some (2, Pbrt.Varint) -> begin
      log_record_set_severity_number v (decode_pb_severity_number d);
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "log_record" 2 pk
    | Some (3, Pbrt.Bytes) -> begin
      log_record_set_severity_text v (Pbrt.Decoder.string d);
    end
    | Some (3, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "log_record" 3 pk
    | Some (5, Pbrt.Bytes) -> begin
      log_record_set_body v (Common.decode_pb_any_value (Pbrt.Decoder.nested d));
    end
    | Some (5, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "log_record" 5 pk
    | Some (6, Pbrt.Bytes) -> begin
      log_record_set_attributes v ((Common.decode_pb_key_value (Pbrt.Decoder.nested d)) :: v.attributes);
    end
    | Some (6, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "log_record" 6 pk
    | Some (7, Pbrt.Varint) -> begin
      log_record_set_dropped_attributes_count v (Pbrt.Decoder.int32_as_varint d);
    end
    | Some (7, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "log_record" 7 pk
    | Some (8, Pbrt.Bits32) -> begin
      log_record_set_flags v (Pbrt.Decoder.int32_as_bits32 d);
    end
    | Some (8, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "log_record" 8 pk
    | Some (9, Pbrt.Bytes) -> begin
      log_record_set_trace_id v (Pbrt.Decoder.bytes d);
    end
    | Some (9, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "log_record" 9 pk
    | Some (10, Pbrt.Bytes) -> begin
      log_record_set_span_id v (Pbrt.Decoder.bytes d);
    end
    | Some (10, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "log_record" 10 pk
    | Some (12, Pbrt.Bytes) -> begin
      log_record_set_event_name v (Pbrt.Decoder.string d);
    end
    | Some (12, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "log_record" 12 pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  (v : log_record)

let rec decode_pb_scope_logs d =
  let v = default_scope_logs () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
      (* put lists in the correct order *)
      scope_logs_set_log_records v (List.rev v.log_records);
    ); continue__ := false
    | Some (1, Pbrt.Bytes) -> begin
      scope_logs_set_scope v (Common.decode_pb_instrumentation_scope (Pbrt.Decoder.nested d));
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "scope_logs" 1 pk
    | Some (2, Pbrt.Bytes) -> begin
      scope_logs_set_log_records v ((decode_pb_log_record (Pbrt.Decoder.nested d)) :: v.log_records);
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "scope_logs" 2 pk
    | Some (3, Pbrt.Bytes) -> begin
      scope_logs_set_schema_url v (Pbrt.Decoder.string d);
    end
    | Some (3, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "scope_logs" 3 pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  (v : scope_logs)

let rec decode_pb_resource_logs d =
  let v = default_resource_logs () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
      (* put lists in the correct order *)
      resource_logs_set_scope_logs v (List.rev v.scope_logs);
    ); continue__ := false
    | Some (1, Pbrt.Bytes) -> begin
      resource_logs_set_resource v (Resource.decode_pb_resource (Pbrt.Decoder.nested d));
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "resource_logs" 1 pk
    | Some (2, Pbrt.Bytes) -> begin
      resource_logs_set_scope_logs v ((decode_pb_scope_logs (Pbrt.Decoder.nested d)) :: v.scope_logs);
    end
    | Some (2, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "resource_logs" 2 pk
    | Some (3, Pbrt.Bytes) -> begin
      resource_logs_set_schema_url v (Pbrt.Decoder.string d);
    end
    | Some (3, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "resource_logs" 3 pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  (v : resource_logs)

let rec decode_pb_logs_data d =
  let v = default_logs_data () in
  let continue__= ref true in
  while !continue__ do
    match Pbrt.Decoder.key d with
    | None -> (
      (* put lists in the correct order *)
      logs_data_set_resource_logs v (List.rev v.resource_logs);
    ); continue__ := false
    | Some (1, Pbrt.Bytes) -> begin
      logs_data_set_resource_logs v ((decode_pb_resource_logs (Pbrt.Decoder.nested d)) :: v.resource_logs);
    end
    | Some (1, pk) -> 
      Pbrt.Decoder.unexpected_payload_message "logs_data" 1 pk
    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
  done;
  (v : logs_data)

let rec decode_pb_log_record_flags d : log_record_flags = 
  match Pbrt.Decoder.int_as_varint d with
  | 0 -> Log_record_flags_do_not_use
  | 255 -> Log_record_flags_trace_flags_mask
  | _ -> Pbrt.Decoder.malformed_variant "log_record_flags"

[@@@ocaml.warning "-23-27-30-39"]

(** {2 Protobuf YoJson Encoding} *)

let rec encode_json_severity_number (v:severity_number) = 
  match v with
  | Severity_number_unspecified -> `String "SEVERITY_NUMBER_UNSPECIFIED"
  | Severity_number_trace -> `String "SEVERITY_NUMBER_TRACE"
  | Severity_number_trace2 -> `String "SEVERITY_NUMBER_TRACE2"
  | Severity_number_trace3 -> `String "SEVERITY_NUMBER_TRACE3"
  | Severity_number_trace4 -> `String "SEVERITY_NUMBER_TRACE4"
  | Severity_number_debug -> `String "SEVERITY_NUMBER_DEBUG"
  | Severity_number_debug2 -> `String "SEVERITY_NUMBER_DEBUG2"
  | Severity_number_debug3 -> `String "SEVERITY_NUMBER_DEBUG3"
  | Severity_number_debug4 -> `String "SEVERITY_NUMBER_DEBUG4"
  | Severity_number_info -> `String "SEVERITY_NUMBER_INFO"
  | Severity_number_info2 -> `String "SEVERITY_NUMBER_INFO2"
  | Severity_number_info3 -> `String "SEVERITY_NUMBER_INFO3"
  | Severity_number_info4 -> `String "SEVERITY_NUMBER_INFO4"
  | Severity_number_warn -> `String "SEVERITY_NUMBER_WARN"
  | Severity_number_warn2 -> `String "SEVERITY_NUMBER_WARN2"
  | Severity_number_warn3 -> `String "SEVERITY_NUMBER_WARN3"
  | Severity_number_warn4 -> `String "SEVERITY_NUMBER_WARN4"
  | Severity_number_error -> `String "SEVERITY_NUMBER_ERROR"
  | Severity_number_error2 -> `String "SEVERITY_NUMBER_ERROR2"
  | Severity_number_error3 -> `String "SEVERITY_NUMBER_ERROR3"
  | Severity_number_error4 -> `String "SEVERITY_NUMBER_ERROR4"
  | Severity_number_fatal -> `String "SEVERITY_NUMBER_FATAL"
  | Severity_number_fatal2 -> `String "SEVERITY_NUMBER_FATAL2"
  | Severity_number_fatal3 -> `String "SEVERITY_NUMBER_FATAL3"
  | Severity_number_fatal4 -> `String "SEVERITY_NUMBER_FATAL4"

let rec encode_json_log_record (v:log_record) = 
  let assoc = ref [] in
  if log_record_has_time_unix_nano v then (
    assoc := ("timeUnixNano", Pbrt_yojson.make_string (Int64.to_string v.time_unix_nano)) :: !assoc;
  );
  if log_record_has_observed_time_unix_nano v then (
    assoc := ("observedTimeUnixNano", Pbrt_yojson.make_string (Int64.to_string v.observed_time_unix_nano)) :: !assoc;
  );
  if log_record_has_severity_number v then (
    assoc := ("severityNumber", encode_json_severity_number v.severity_number) :: !assoc;
  );
  if log_record_has_severity_text v then (
    assoc := ("severityText", Pbrt_yojson.make_string v.severity_text) :: !assoc;
  );
  assoc := (match v.body with
    | None -> !assoc
    | Some v -> ("body", Common.encode_json_any_value v) :: !assoc);
  assoc := (
    let l = v.attributes |> List.map Common.encode_json_key_value in
    ("attributes", `List l) :: !assoc 
  );
  if log_record_has_dropped_attributes_count v then (
    assoc := ("droppedAttributesCount", Pbrt_yojson.make_int (Int32.to_int v.dropped_attributes_count)) :: !assoc;
  );
  if log_record_has_flags v then (
    assoc := ("flags", Pbrt_yojson.make_int (Int32.to_int v.flags)) :: !assoc;
  );
  if log_record_has_trace_id v then (
    assoc := ("traceId", Pbrt_yojson.make_bytes v.trace_id) :: !assoc;
  );
  if log_record_has_span_id v then (
    assoc := ("spanId", Pbrt_yojson.make_bytes v.span_id) :: !assoc;
  );
  if log_record_has_event_name v then (
    assoc := ("eventName", Pbrt_yojson.make_string v.event_name) :: !assoc;
  );
  `Assoc !assoc

let rec encode_json_scope_logs (v:scope_logs) = 
  let assoc = ref [] in
  assoc := (match v.scope with
    | None -> !assoc
    | Some v -> ("scope", Common.encode_json_instrumentation_scope v) :: !assoc);
  assoc := (
    let l = v.log_records |> List.map encode_json_log_record in
    ("logRecords", `List l) :: !assoc 
  );
  if scope_logs_has_schema_url v then (
    assoc := ("schemaUrl", Pbrt_yojson.make_string v.schema_url) :: !assoc;
  );
  `Assoc !assoc

let rec encode_json_resource_logs (v:resource_logs) = 
  let assoc = ref [] in
  assoc := (match v.resource with
    | None -> !assoc
    | Some v -> ("resource", Resource.encode_json_resource v) :: !assoc);
  assoc := (
    let l = v.scope_logs |> List.map encode_json_scope_logs in
    ("scopeLogs", `List l) :: !assoc 
  );
  if resource_logs_has_schema_url v then (
    assoc := ("schemaUrl", Pbrt_yojson.make_string v.schema_url) :: !assoc;
  );
  `Assoc !assoc

let rec encode_json_logs_data (v:logs_data) = 
  let assoc = ref [] in
  assoc := (
    let l = v.resource_logs |> List.map encode_json_resource_logs in
    ("resourceLogs", `List l) :: !assoc 
  );
  `Assoc !assoc

let rec encode_json_log_record_flags (v:log_record_flags) = 
  match v with
  | Log_record_flags_do_not_use -> `String "LOG_RECORD_FLAGS_DO_NOT_USE"
  | Log_record_flags_trace_flags_mask -> `String "LOG_RECORD_FLAGS_TRACE_FLAGS_MASK"

[@@@ocaml.warning "-23-27-30-39"]

(** {2 JSON Decoding} *)

let rec decode_json_severity_number json =
  match json with
  | `String "SEVERITY_NUMBER_UNSPECIFIED" -> (Severity_number_unspecified : severity_number)
  | `String "SEVERITY_NUMBER_TRACE" -> (Severity_number_trace : severity_number)
  | `String "SEVERITY_NUMBER_TRACE2" -> (Severity_number_trace2 : severity_number)
  | `String "SEVERITY_NUMBER_TRACE3" -> (Severity_number_trace3 : severity_number)
  | `String "SEVERITY_NUMBER_TRACE4" -> (Severity_number_trace4 : severity_number)
  | `String "SEVERITY_NUMBER_DEBUG" -> (Severity_number_debug : severity_number)
  | `String "SEVERITY_NUMBER_DEBUG2" -> (Severity_number_debug2 : severity_number)
  | `String "SEVERITY_NUMBER_DEBUG3" -> (Severity_number_debug3 : severity_number)
  | `String "SEVERITY_NUMBER_DEBUG4" -> (Severity_number_debug4 : severity_number)
  | `String "SEVERITY_NUMBER_INFO" -> (Severity_number_info : severity_number)
  | `String "SEVERITY_NUMBER_INFO2" -> (Severity_number_info2 : severity_number)
  | `String "SEVERITY_NUMBER_INFO3" -> (Severity_number_info3 : severity_number)
  | `String "SEVERITY_NUMBER_INFO4" -> (Severity_number_info4 : severity_number)
  | `String "SEVERITY_NUMBER_WARN" -> (Severity_number_warn : severity_number)
  | `String "SEVERITY_NUMBER_WARN2" -> (Severity_number_warn2 : severity_number)
  | `String "SEVERITY_NUMBER_WARN3" -> (Severity_number_warn3 : severity_number)
  | `String "SEVERITY_NUMBER_WARN4" -> (Severity_number_warn4 : severity_number)
  | `String "SEVERITY_NUMBER_ERROR" -> (Severity_number_error : severity_number)
  | `String "SEVERITY_NUMBER_ERROR2" -> (Severity_number_error2 : severity_number)
  | `String "SEVERITY_NUMBER_ERROR3" -> (Severity_number_error3 : severity_number)
  | `String "SEVERITY_NUMBER_ERROR4" -> (Severity_number_error4 : severity_number)
  | `String "SEVERITY_NUMBER_FATAL" -> (Severity_number_fatal : severity_number)
  | `String "SEVERITY_NUMBER_FATAL2" -> (Severity_number_fatal2 : severity_number)
  | `String "SEVERITY_NUMBER_FATAL3" -> (Severity_number_fatal3 : severity_number)
  | `String "SEVERITY_NUMBER_FATAL4" -> (Severity_number_fatal4 : severity_number)
  | _ -> Pbrt_yojson.E.malformed_variant "severity_number"

let rec decode_json_log_record d =
  let v = default_log_record () in
  let assoc = match d with
    | `Assoc assoc -> assoc
    | _ -> assert(false)
  in
  List.iter (function 
    | ("timeUnixNano", json_value) -> 
      log_record_set_time_unix_nano v (Pbrt_yojson.int64 json_value "log_record" "time_unix_nano")
    | ("observedTimeUnixNano", json_value) -> 
      log_record_set_observed_time_unix_nano v (Pbrt_yojson.int64 json_value "log_record" "observed_time_unix_nano")
    | ("severityNumber", json_value) -> 
      log_record_set_severity_number v ((decode_json_severity_number json_value))
    | ("severityText", json_value) -> 
      log_record_set_severity_text v (Pbrt_yojson.string json_value "log_record" "severity_text")
    | ("body", json_value) -> 
      log_record_set_body v (Common.decode_json_any_value json_value)
    | ("attributes", `List l) -> begin
      log_record_set_attributes v @@ List.map (function
        | json_value -> (Common.decode_json_key_value json_value)
      ) l;
    end
    | ("droppedAttributesCount", json_value) -> 
      log_record_set_dropped_attributes_count v (Pbrt_yojson.int32 json_value "log_record" "dropped_attributes_count")
    | ("flags", json_value) -> 
      log_record_set_flags v (Pbrt_yojson.int32 json_value "log_record" "flags")
    | ("traceId", json_value) -> 
      log_record_set_trace_id v (Pbrt_yojson.bytes json_value "log_record" "trace_id")
    | ("spanId", json_value) -> 
      log_record_set_span_id v (Pbrt_yojson.bytes json_value "log_record" "span_id")
    | ("eventName", json_value) -> 
      log_record_set_event_name v (Pbrt_yojson.string json_value "log_record" "event_name")
    
    | (_, _) -> () (*Unknown fields are ignored*)
  ) assoc;
  ({
    _presence = v._presence;
    time_unix_nano = v.time_unix_nano;
    observed_time_unix_nano = v.observed_time_unix_nano;
    severity_number = v.severity_number;
    severity_text = v.severity_text;
    body = v.body;
    attributes = v.attributes;
    dropped_attributes_count = v.dropped_attributes_count;
    flags = v.flags;
    trace_id = v.trace_id;
    span_id = v.span_id;
    event_name = v.event_name;
  } : log_record)

let rec decode_json_scope_logs d =
  let v = default_scope_logs () in
  let assoc = match d with
    | `Assoc assoc -> assoc
    | _ -> assert(false)
  in
  List.iter (function 
    | ("scope", json_value) -> 
      scope_logs_set_scope v (Common.decode_json_instrumentation_scope json_value)
    | ("logRecords", `List l) -> begin
      scope_logs_set_log_records v @@ List.map (function
        | json_value -> (decode_json_log_record json_value)
      ) l;
    end
    | ("schemaUrl", json_value) -> 
      scope_logs_set_schema_url v (Pbrt_yojson.string json_value "scope_logs" "schema_url")
    
    | (_, _) -> () (*Unknown fields are ignored*)
  ) assoc;
  ({
    _presence = v._presence;
    scope = v.scope;
    log_records = v.log_records;
    schema_url = v.schema_url;
  } : scope_logs)

let rec decode_json_resource_logs d =
  let v = default_resource_logs () in
  let assoc = match d with
    | `Assoc assoc -> assoc
    | _ -> assert(false)
  in
  List.iter (function 
    | ("resource", json_value) -> 
      resource_logs_set_resource v (Resource.decode_json_resource json_value)
    | ("scopeLogs", `List l) -> begin
      resource_logs_set_scope_logs v @@ List.map (function
        | json_value -> (decode_json_scope_logs json_value)
      ) l;
    end
    | ("schemaUrl", json_value) -> 
      resource_logs_set_schema_url v (Pbrt_yojson.string json_value "resource_logs" "schema_url")
    
    | (_, _) -> () (*Unknown fields are ignored*)
  ) assoc;
  ({
    _presence = v._presence;
    resource = v.resource;
    scope_logs = v.scope_logs;
    schema_url = v.schema_url;
  } : resource_logs)

let rec decode_json_logs_data d =
  let v = default_logs_data () in
  let assoc = match d with
    | `Assoc assoc -> assoc
    | _ -> assert(false)
  in
  List.iter (function 
    | ("resourceLogs", `List l) -> begin
      logs_data_set_resource_logs v @@ List.map (function
        | json_value -> (decode_json_resource_logs json_value)
      ) l;
    end
    
    | (_, _) -> () (*Unknown fields are ignored*)
  ) assoc;
  ({
    resource_logs = v.resource_logs;
  } : logs_data)

let rec decode_json_log_record_flags json =
  match json with
  | `String "LOG_RECORD_FLAGS_DO_NOT_USE" -> (Log_record_flags_do_not_use : log_record_flags)
  | `String "LOG_RECORD_FLAGS_TRACE_FLAGS_MASK" -> (Log_record_flags_trace_flags_mask : log_record_flags)
  | _ -> Pbrt_yojson.E.malformed_variant "log_record_flags"