diff --git a/src/proto/common.ml b/src/proto/common.ml
index dfc79970..c403f65a 100644
--- a/src/proto/common.ml
+++ b/src/proto/common.ml
@@ -33,6 +33,15 @@ type instrumentation_scope = {
   mutable dropped_attributes_count : int32;
 }
 
+type entity_ref = {
+  mutable _presence: Pbrt.Bitfield.t;
+  (** tracking presence for 2 fields *)
+  mutable schema_url : string;
+  mutable type_ : string;
+  mutable id_keys : string list;
+  mutable description_keys : string list;
+}
+
 let default_any_value (): any_value = String_value ("")
 
 let default_array_value (): array_value = 
@@ -61,6 +70,15 @@ let default_instrumentation_scope (): instrumentation_scope =
   dropped_attributes_count=0l;
 }
 
+let default_entity_ref (): entity_ref = 
+{
+  _presence=Pbrt.Bitfield.empty;
+  schema_url="";
+  type_="";
+  id_keys=[];
+  description_keys=[];
+}
+
 
 (** {2 Make functions} *)
 
@@ -151,6 +169,38 @@ let make_instrumentation_scope
   | Some v -> set_instrumentation_scope_dropped_attributes_count _res v);
   _res
 
+let[@inline] has_entity_ref_schema_url (self:entity_ref) : bool = (Pbrt.Bitfield.get self._presence 0)
+let[@inline] has_entity_ref_type_ (self:entity_ref) : bool = (Pbrt.Bitfield.get self._presence 1)
+
+let[@inline] set_entity_ref_schema_url (self:entity_ref) (x:string) : unit =
+  self._presence <- (Pbrt.Bitfield.set self._presence 0); self.schema_url <- x
+let[@inline] set_entity_ref_type_ (self:entity_ref) (x:string) : unit =
+  self._presence <- (Pbrt.Bitfield.set self._presence 1); self.type_ <- x
+let[@inline] set_entity_ref_id_keys (self:entity_ref) (x:string list) : unit =
+  self.id_keys <- x
+let[@inline] set_entity_ref_description_keys (self:entity_ref) (x:string list) : unit =
+  self.description_keys <- x
+
+let copy_entity_ref (self:entity_ref) : entity_ref =
+  { self with schema_url = self.schema_url }
+
+let make_entity_ref 
+  ?(schema_url:string option)
+  ?(type_:string option)
+  ~(id_keys:string list) 
+  ~(description_keys:string list) 
+  () : entity_ref  =
+  let _res = default_entity_ref () in
+  (match schema_url with
+  | None -> ()
+  | Some v -> set_entity_ref_schema_url _res v);
+  (match type_ with
+  | None -> ()
+  | Some v -> set_entity_ref_type_ _res v);
+  set_entity_ref_id_keys _res id_keys;
+  set_entity_ref_description_keys _res description_keys;
+  _res
+
 [@@@ocaml.warning "-23-27-30-39"]
 
 (** {2 Formatters} *)
@@ -197,6 +247,17 @@ let rec pp_instrumentation_scope fmt (v:instrumentation_scope) =
   in
   Pbrt.Pp.pp_brk pp_i fmt ()
 
+let rec pp_entity_ref fmt (v:entity_ref) = 
+  let pp_i fmt () =
+    Pbrt.Pp.pp_record_field ~first:true "schema_url" Pbrt.Pp.pp_string fmt v.schema_url;
+    if not (Pbrt.Bitfield.get v._presence 0) then Format.pp_print_string fmt "(* absent *)";
+    Pbrt.Pp.pp_record_field ~first:false "type_" Pbrt.Pp.pp_string fmt v.type_;
+    if not (Pbrt.Bitfield.get v._presence 1) then Format.pp_print_string fmt "(* absent *)";
+    Pbrt.Pp.pp_record_field ~first:false "id_keys" (Pbrt.Pp.pp_list Pbrt.Pp.pp_string) fmt v.id_keys;
+    Pbrt.Pp.pp_record_field ~first:false "description_keys" (Pbrt.Pp.pp_list Pbrt.Pp.pp_string) fmt v.description_keys;
+  in
+  Pbrt.Pp.pp_brk pp_i fmt ()
+
 [@@@ocaml.warning "-23-27-30-39"]
 
 (** {2 Protobuf Encoding} *)
@@ -272,6 +333,25 @@ let rec encode_pb_instrumentation_scope (v:instrumentation_scope) encoder =
   );
   ()
 
+let rec encode_pb_entity_ref (v:entity_ref) encoder = 
+  if (Pbrt.Bitfield.get v._presence 0) then (
+    Pbrt.Encoder.string v.schema_url encoder;
+    Pbrt.Encoder.key 1 Pbrt.Bytes encoder; 
+  );
+  if (Pbrt.Bitfield.get v._presence 1) then (
+    Pbrt.Encoder.string v.type_ encoder;
+    Pbrt.Encoder.key 2 Pbrt.Bytes encoder; 
+  );
+  Pbrt.List_util.rev_iter_with (fun x encoder ->
+    Pbrt.Encoder.string x encoder;
+    Pbrt.Encoder.key 3 Pbrt.Bytes encoder; 
+  ) v.id_keys encoder;
+  Pbrt.List_util.rev_iter_with (fun x encoder ->
+    Pbrt.Encoder.string x encoder;
+    Pbrt.Encoder.key 4 Pbrt.Bytes encoder; 
+  ) v.description_keys encoder;
+  ()
+
 [@@@ocaml.warning "-23-27-30-39"]
 
 (** {2 Protobuf Decoding} *)
@@ -385,3 +465,37 @@ let rec decode_pb_instrumentation_scope d =
     | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
   done;
   (v : instrumentation_scope)
+
+let rec decode_pb_entity_ref d =
+  let v = default_entity_ref () in
+  let continue__= ref true in
+  while !continue__ do
+    match Pbrt.Decoder.key d with
+    | None -> (
+      (* put lists in the correct order *)
+      set_entity_ref_description_keys v (List.rev v.description_keys);
+      set_entity_ref_id_keys v (List.rev v.id_keys);
+    ); continue__ := false
+    | Some (1, Pbrt.Bytes) -> begin
+      set_entity_ref_schema_url v (Pbrt.Decoder.string d);
+    end
+    | Some (1, pk) -> 
+      Pbrt.Decoder.unexpected_payload "Message(entity_ref), field(1)" pk
+    | Some (2, Pbrt.Bytes) -> begin
+      set_entity_ref_type_ v (Pbrt.Decoder.string d);
+    end
+    | Some (2, pk) -> 
+      Pbrt.Decoder.unexpected_payload "Message(entity_ref), field(2)" pk
+    | Some (3, Pbrt.Bytes) -> begin
+      set_entity_ref_id_keys v ((Pbrt.Decoder.string d) :: v.id_keys);
+    end
+    | Some (3, pk) -> 
+      Pbrt.Decoder.unexpected_payload "Message(entity_ref), field(3)" pk
+    | Some (4, Pbrt.Bytes) -> begin
+      set_entity_ref_description_keys v ((Pbrt.Decoder.string d) :: v.description_keys);
+    end
+    | Some (4, pk) -> 
+      Pbrt.Decoder.unexpected_payload "Message(entity_ref), field(4)" pk
+    | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
+  done;
+  (v : entity_ref)
diff --git a/src/proto/common.mli b/src/proto/common.mli
index 9036b23c..e74eedd5 100644
--- a/src/proto/common.mli
+++ b/src/proto/common.mli
@@ -40,6 +40,15 @@ type instrumentation_scope = private {
   mutable dropped_attributes_count : int32;
 }
 
+type entity_ref = private {
+  mutable _presence: Pbrt.Bitfield.t;
+  (** tracking presence for 2 fields *)
+  mutable schema_url : string;
+  mutable type_ : string;
+  mutable id_keys : string list;
+  mutable description_keys : string list;
+}
+
 
 (** {2 Basic values} *)
 
@@ -58,6 +67,9 @@ val default_key_value : unit -> key_value
 val default_instrumentation_scope : unit -> instrumentation_scope 
 (** [default_instrumentation_scope ()] is a new empty value for type [instrumentation_scope] *)
 
+val default_entity_ref : unit -> entity_ref 
+(** [default_entity_ref ()] is a new empty value for type [entity_ref] *)
+
 
 (** {2 Make functions} *)
 
@@ -134,6 +146,35 @@ val has_instrumentation_scope_dropped_attributes_count : instrumentation_scope -
 val set_instrumentation_scope_dropped_attributes_count : instrumentation_scope -> int32 -> unit
   (** set field dropped_attributes_count in instrumentation_scope *)
 
+val make_entity_ref : 
+  ?schema_url:string ->
+  ?type_:string ->
+  id_keys:string list ->
+  description_keys:string list ->
+  unit ->
+  entity_ref
+(** [make_entity_ref … ()] is a builder for type [entity_ref] *)
+
+val copy_entity_ref : entity_ref -> entity_ref
+
+val has_entity_ref_schema_url : entity_ref -> bool
+  (** presence of field "schema_url" in [entity_ref] *)
+
+val set_entity_ref_schema_url : entity_ref -> string -> unit
+  (** set field schema_url in entity_ref *)
+
+val has_entity_ref_type_ : entity_ref -> bool
+  (** presence of field "type_" in [entity_ref] *)
+
+val set_entity_ref_type_ : entity_ref -> string -> unit
+  (** set field type_ in entity_ref *)
+
+val set_entity_ref_id_keys : entity_ref -> string list -> unit
+  (** set field id_keys in entity_ref *)
+
+val set_entity_ref_description_keys : entity_ref -> string list -> unit
+  (** set field description_keys in entity_ref *)
+
 
 (** {2 Formatters} *)
 
@@ -152,6 +193,9 @@ val pp_key_value : Format.formatter -> key_value -> unit
 val pp_instrumentation_scope : Format.formatter -> instrumentation_scope -> unit 
 (** [pp_instrumentation_scope v] formats v *)
 
+val pp_entity_ref : Format.formatter -> entity_ref -> unit 
+(** [pp_entity_ref v] formats v *)
+
 
 (** {2 Protobuf Encoding} *)
 
@@ -170,6 +214,9 @@ val encode_pb_key_value : key_value -> Pbrt.Encoder.t -> unit
 val encode_pb_instrumentation_scope : instrumentation_scope -> Pbrt.Encoder.t -> unit
 (** [encode_pb_instrumentation_scope v encoder] encodes [v] with the given [encoder] *)
 
+val encode_pb_entity_ref : entity_ref -> Pbrt.Encoder.t -> unit
+(** [encode_pb_entity_ref v encoder] encodes [v] with the given [encoder] *)
+
 
 (** {2 Protobuf Decoding} *)
 
@@ -187,3 +234,6 @@ val decode_pb_key_value : Pbrt.Decoder.t -> key_value
 
 val decode_pb_instrumentation_scope : Pbrt.Decoder.t -> instrumentation_scope
 (** [decode_pb_instrumentation_scope decoder] decodes a [instrumentation_scope] binary value from [decoder] *)
+
+val decode_pb_entity_ref : Pbrt.Decoder.t -> entity_ref
+(** [decode_pb_entity_ref decoder] decodes a [entity_ref] binary value from [decoder] *)
diff --git a/src/proto/logs.ml b/src/proto/logs.ml
index 183ef422..bd8857be 100644
--- a/src/proto/logs.ml
+++ b/src/proto/logs.ml
@@ -29,7 +29,7 @@ type severity_number =
 
 type log_record = {
   mutable _presence: Pbrt.Bitfield.t;
-  (** tracking presence for 8 fields *)
+  (** tracking presence for 9 fields *)
   mutable time_unix_nano : int64;
   mutable observed_time_unix_nano : int64;
   mutable severity_number : severity_number;
@@ -40,6 +40,7 @@ type log_record = {
   mutable flags : int32;
   mutable trace_id : bytes;
   mutable span_id : bytes;
+  mutable event_name : string;
 }
 
 type scope_logs = {
@@ -81,6 +82,7 @@ let default_log_record (): log_record =
   flags=0l;
   trace_id=Bytes.create 0;
   span_id=Bytes.create 0;
+  event_name="";
 }
 
 let default_scope_logs (): scope_logs = 
@@ -118,6 +120,7 @@ let[@inline] has_log_record_dropped_attributes_count (self:log_record) : bool =
 let[@inline] has_log_record_flags (self:log_record) : bool = (Pbrt.Bitfield.get self._presence 5)
 let[@inline] has_log_record_trace_id (self:log_record) : bool = (Pbrt.Bitfield.get self._presence 6)
 let[@inline] has_log_record_span_id (self:log_record) : bool = (Pbrt.Bitfield.get self._presence 7)
+let[@inline] has_log_record_event_name (self:log_record) : bool = (Pbrt.Bitfield.get self._presence 8)
 
 let[@inline] set_log_record_time_unix_nano (self:log_record) (x:int64) : unit =
   self._presence <- (Pbrt.Bitfield.set self._presence 0); self.time_unix_nano <- x
@@ -139,6 +142,8 @@ let[@inline] set_log_record_trace_id (self:log_record) (x:bytes) : unit =
   self._presence <- (Pbrt.Bitfield.set self._presence 6); self.trace_id <- x
 let[@inline] set_log_record_span_id (self:log_record) (x:bytes) : unit =
   self._presence <- (Pbrt.Bitfield.set self._presence 7); self.span_id <- x
+let[@inline] set_log_record_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 }
@@ -154,6 +159,7 @@ let make_log_record
   ?(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
@@ -184,6 +190,9 @@ let make_log_record
   (match span_id with
   | None -> ()
   | Some v -> set_log_record_span_id _res v);
+  (match event_name with
+  | None -> ()
+  | Some v -> set_log_record_event_name _res v);
   _res
 
 let[@inline] has_scope_logs_schema_url (self:scope_logs) : bool = (Pbrt.Bitfield.get self._presence 0)
@@ -307,6 +316,8 @@ let rec pp_log_record fmt (v:log_record) =
     if not (Pbrt.Bitfield.get v._presence 6) then Format.pp_print_string fmt "(* absent *)";
     Pbrt.Pp.pp_record_field ~first:false "span_id" Pbrt.Pp.pp_bytes fmt v.span_id;
     if not (Pbrt.Bitfield.get v._presence 7) then Format.pp_print_string fmt "(* absent *)";
+    Pbrt.Pp.pp_record_field ~first:false "event_name" Pbrt.Pp.pp_string fmt v.event_name;
+    if not (Pbrt.Bitfield.get v._presence 8) then Format.pp_print_string fmt "(* absent *)";
   in
   Pbrt.Pp.pp_brk pp_i fmt ()
 
@@ -414,6 +425,10 @@ let rec encode_pb_log_record (v:log_record) encoder =
     Pbrt.Encoder.bytes v.span_id encoder;
     Pbrt.Encoder.key 10 Pbrt.Bytes encoder; 
   );
+  if (Pbrt.Bitfield.get v._presence 8) 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 = 
@@ -554,6 +569,11 @@ let rec decode_pb_log_record d =
     end
     | Some (10, pk) -> 
       Pbrt.Decoder.unexpected_payload "Message(log_record), field(10)" pk
+    | Some (12, Pbrt.Bytes) -> begin
+      set_log_record_event_name v (Pbrt.Decoder.string d);
+    end
+    | Some (12, pk) -> 
+      Pbrt.Decoder.unexpected_payload "Message(log_record), field(12)" pk
     | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
   done;
   (v : log_record)
diff --git a/src/proto/logs.mli b/src/proto/logs.mli
index c040b666..4cc12a49 100644
--- a/src/proto/logs.mli
+++ b/src/proto/logs.mli
@@ -36,7 +36,7 @@ type severity_number =
 
 type log_record = private {
   mutable _presence: Pbrt.Bitfield.t;
-  (** tracking presence for 8 fields *)
+  (** tracking presence for 9 fields *)
   mutable time_unix_nano : int64;
   mutable observed_time_unix_nano : int64;
   mutable severity_number : severity_number;
@@ -47,6 +47,7 @@ type log_record = private {
   mutable flags : int32;
   mutable trace_id : bytes;
   mutable span_id : bytes;
+  mutable event_name : string;
 }
 
 type scope_logs = private {
@@ -109,6 +110,7 @@ val make_log_record :
   ?flags:int32 ->
   ?trace_id:bytes ->
   ?span_id:bytes ->
+  ?event_name:string ->
   unit ->
   log_record
 (** [make_log_record … ()] is a builder for type [log_record] *)
@@ -169,6 +171,12 @@ val has_log_record_span_id : log_record -> bool
 val set_log_record_span_id : log_record -> bytes -> unit
   (** set field span_id in log_record *)
 
+val has_log_record_event_name : log_record -> bool
+  (** presence of field "event_name" in [log_record] *)
+
+val set_log_record_event_name : log_record -> string -> unit
+  (** set field event_name in log_record *)
+
 val make_scope_logs : 
   ?scope:Common.instrumentation_scope ->
   log_records:log_record list ->
diff --git a/src/proto/metrics.ml b/src/proto/metrics.ml
index 9a7ded11..8e81d221 100644
--- a/src/proto/metrics.ml
+++ b/src/proto/metrics.ml
@@ -139,6 +139,7 @@ and metric = {
   mutable description : string;
   mutable unit_ : string;
   mutable data : metric_data option;
+  mutable metadata : Common.key_value list;
 }
 
 type scope_metrics = {
@@ -294,6 +295,7 @@ let default_metric (): metric =
   description="";
   unit_="";
   data=None;
+  metadata=[];
 }
 
 let default_scope_metrics (): scope_metrics = 
@@ -789,6 +791,8 @@ let[@inline] set_metric_unit_ (self:metric) (x:string) : unit =
   self._presence <- (Pbrt.Bitfield.set self._presence 2); self.unit_ <- x
 let[@inline] set_metric_data (self:metric) (x:metric_data) : unit =
   self.data <- Some x
+let[@inline] set_metric_metadata (self:metric) (x:Common.key_value list) : unit =
+  self.metadata <- x
 
 let copy_metric (self:metric) : metric =
   { self with name = self.name }
@@ -798,6 +802,7 @@ let make_metric
   ?(description:string option)
   ?(unit_:string option)
   ?(data:metric_data option)
+  ~(metadata:Common.key_value list) 
   () : metric  =
   let _res = default_metric () in
   (match name with
@@ -812,6 +817,7 @@ let make_metric
   (match data with
   | None -> ()
   | Some v -> set_metric_data _res v);
+  set_metric_metadata _res metadata;
   _res
 
 let[@inline] has_scope_metrics_schema_url (self:scope_metrics) : bool = (Pbrt.Bitfield.get self._presence 0)
@@ -1065,6 +1071,7 @@ and pp_metric fmt (v:metric) =
     Pbrt.Pp.pp_record_field ~first:false "unit_" Pbrt.Pp.pp_string fmt v.unit_;
     if not (Pbrt.Bitfield.get v._presence 2) then Format.pp_print_string fmt "(* absent *)";
     Pbrt.Pp.pp_record_field ~first:false "data" (Pbrt.Pp.pp_option pp_metric_data) fmt v.data;
+    Pbrt.Pp.pp_record_field ~first:false "metadata" (Pbrt.Pp.pp_list Common.pp_key_value) fmt v.metadata;
   in
   Pbrt.Pp.pp_brk pp_i fmt ()
 
@@ -1469,6 +1476,10 @@ and encode_pb_metric (v:metric) encoder =
     Pbrt.Encoder.nested encode_pb_summary x encoder;
     Pbrt.Encoder.key 11 Pbrt.Bytes encoder; 
   end;
+  Pbrt.List_util.rev_iter_with (fun x encoder ->
+    Pbrt.Encoder.nested Common.encode_pb_key_value x encoder;
+    Pbrt.Encoder.key 12 Pbrt.Bytes encoder; 
+  ) v.metadata encoder;
   ()
 
 let rec encode_pb_scope_metrics (v:scope_metrics) encoder = 
@@ -2032,6 +2043,8 @@ and decode_pb_metric d =
   while !continue__ do
     match Pbrt.Decoder.key d with
     | None -> (
+      (* put lists in the correct order *)
+      set_metric_metadata v (List.rev v.metadata);
     ); continue__ := false
     | Some (1, Pbrt.Bytes) -> begin
       set_metric_name v (Pbrt.Decoder.string d);
@@ -2073,6 +2086,11 @@ and decode_pb_metric d =
     end
     | Some (11, pk) -> 
       Pbrt.Decoder.unexpected_payload "Message(metric), field(11)" pk
+    | Some (12, Pbrt.Bytes) -> begin
+      set_metric_metadata v ((Common.decode_pb_key_value (Pbrt.Decoder.nested d)) :: v.metadata);
+    end
+    | Some (12, pk) -> 
+      Pbrt.Decoder.unexpected_payload "Message(metric), field(12)" pk
     | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
   done;
   (v : metric)
diff --git a/src/proto/metrics.mli b/src/proto/metrics.mli
index 3244e854..5e8b1543 100644
--- a/src/proto/metrics.mli
+++ b/src/proto/metrics.mli
@@ -146,6 +146,7 @@ and metric = private {
   mutable description : string;
   mutable unit_ : string;
   mutable data : metric_data option;
+  mutable metadata : Common.key_value list;
 }
 
 type scope_metrics = private {
@@ -645,6 +646,7 @@ val make_metric :
   ?description:string ->
   ?unit_:string ->
   ?data:metric_data ->
+  metadata:Common.key_value list ->
   unit ->
   metric
 (** [make_metric … ()] is a builder for type [metric] *)
@@ -672,6 +674,9 @@ val set_metric_unit_ : metric -> string -> unit
 val set_metric_data : metric -> metric_data -> unit
   (** set field data in metric *)
 
+val set_metric_metadata : metric -> Common.key_value list -> unit
+  (** set field metadata in metric *)
+
 val make_scope_metrics : 
   ?scope:Common.instrumentation_scope ->
   metrics:metric list ->
diff --git a/src/proto/resource.ml b/src/proto/resource.ml
index 1b81b28e..b8667170 100644
--- a/src/proto/resource.ml
+++ b/src/proto/resource.ml
@@ -5,6 +5,7 @@ type resource = {
   (** tracking presence for 1 fields *)
   mutable attributes : Common.key_value list;
   mutable dropped_attributes_count : int32;
+  mutable entity_refs : Common.entity_ref list;
 }
 
 let default_resource (): resource = 
@@ -12,6 +13,7 @@ let default_resource (): resource =
   _presence=Pbrt.Bitfield.empty;
   attributes=[];
   dropped_attributes_count=0l;
+  entity_refs=[];
 }
 
 
@@ -23,6 +25,8 @@ let[@inline] set_resource_attributes (self:resource) (x:Common.key_value list) :
   self.attributes <- x
 let[@inline] set_resource_dropped_attributes_count (self:resource) (x:int32) : unit =
   self._presence <- (Pbrt.Bitfield.set self._presence 0); self.dropped_attributes_count <- x
+let[@inline] set_resource_entity_refs (self:resource) (x:Common.entity_ref list) : unit =
+  self.entity_refs <- x
 
 let copy_resource (self:resource) : resource =
   { self with attributes = self.attributes }
@@ -30,12 +34,14 @@ let copy_resource (self:resource) : resource =
 let make_resource 
   ~(attributes:Common.key_value list) 
   ?(dropped_attributes_count:int32 option)
+  ~(entity_refs:Common.entity_ref list) 
   () : resource  =
   let _res = default_resource () in
   set_resource_attributes _res attributes;
   (match dropped_attributes_count with
   | None -> ()
   | Some v -> set_resource_dropped_attributes_count _res v);
+  set_resource_entity_refs _res entity_refs;
   _res
 
 [@@@ocaml.warning "-23-27-30-39"]
@@ -47,6 +53,7 @@ let rec pp_resource fmt (v:resource) =
     Pbrt.Pp.pp_record_field ~first:true "attributes" (Pbrt.Pp.pp_list Common.pp_key_value) fmt v.attributes;
     Pbrt.Pp.pp_record_field ~first:false "dropped_attributes_count" Pbrt.Pp.pp_int32 fmt v.dropped_attributes_count;
     if not (Pbrt.Bitfield.get v._presence 0) then Format.pp_print_string fmt "(* absent *)";
+    Pbrt.Pp.pp_record_field ~first:false "entity_refs" (Pbrt.Pp.pp_list Common.pp_entity_ref) fmt v.entity_refs;
   in
   Pbrt.Pp.pp_brk pp_i fmt ()
 
@@ -63,6 +70,10 @@ let rec encode_pb_resource (v:resource) encoder =
     Pbrt.Encoder.int32_as_varint v.dropped_attributes_count encoder;
     Pbrt.Encoder.key 2 Pbrt.Varint encoder; 
   );
+  Pbrt.List_util.rev_iter_with (fun x encoder ->
+    Pbrt.Encoder.nested Common.encode_pb_entity_ref x encoder;
+    Pbrt.Encoder.key 3 Pbrt.Bytes encoder; 
+  ) v.entity_refs encoder;
   ()
 
 [@@@ocaml.warning "-23-27-30-39"]
@@ -76,6 +87,7 @@ let rec decode_pb_resource d =
     match Pbrt.Decoder.key d with
     | None -> (
       (* put lists in the correct order *)
+      set_resource_entity_refs v (List.rev v.entity_refs);
       set_resource_attributes v (List.rev v.attributes);
     ); continue__ := false
     | Some (1, Pbrt.Bytes) -> begin
@@ -88,6 +100,11 @@ let rec decode_pb_resource d =
     end
     | Some (2, pk) -> 
       Pbrt.Decoder.unexpected_payload "Message(resource), field(2)" pk
+    | Some (3, Pbrt.Bytes) -> begin
+      set_resource_entity_refs v ((Common.decode_pb_entity_ref (Pbrt.Decoder.nested d)) :: v.entity_refs);
+    end
+    | Some (3, pk) -> 
+      Pbrt.Decoder.unexpected_payload "Message(resource), field(3)" pk
     | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
   done;
   (v : resource)
diff --git a/src/proto/resource.mli b/src/proto/resource.mli
index 978b41f8..8090808a 100644
--- a/src/proto/resource.mli
+++ b/src/proto/resource.mli
@@ -12,6 +12,7 @@ type resource = private {
   (** tracking presence for 1 fields *)
   mutable attributes : Common.key_value list;
   mutable dropped_attributes_count : int32;
+  mutable entity_refs : Common.entity_ref list;
 }
 
 
@@ -26,6 +27,7 @@ val default_resource : unit -> resource
 val make_resource : 
   attributes:Common.key_value list ->
   ?dropped_attributes_count:int32 ->
+  entity_refs:Common.entity_ref list ->
   unit ->
   resource
 (** [make_resource … ()] is a builder for type [resource] *)
@@ -41,6 +43,9 @@ val has_resource_dropped_attributes_count : resource -> bool
 val set_resource_dropped_attributes_count : resource -> int32 -> unit
   (** set field dropped_attributes_count in resource *)
 
+val set_resource_entity_refs : resource -> Common.entity_ref list -> unit
+  (** set field entity_refs in resource *)
+
 
 (** {2 Formatters} *)
 
diff --git a/src/proto/trace.ml b/src/proto/trace.ml
index 4493b824..12780c8b 100644
--- a/src/proto/trace.ml
+++ b/src/proto/trace.ml
@@ -19,12 +19,13 @@ type span_event = {
 
 type span_link = {
   mutable _presence: Pbrt.Bitfield.t;
-  (** tracking presence for 4 fields *)
+  (** tracking presence for 5 fields *)
   mutable trace_id : bytes;
   mutable span_id : bytes;
   mutable trace_state : string;
   mutable attributes : Common.key_value list;
   mutable dropped_attributes_count : int32;
+  mutable flags : int32;
 }
 
 type status_status_code =
@@ -41,11 +42,12 @@ type status = {
 
 type span = {
   mutable _presence: Pbrt.Bitfield.t;
-  (** tracking presence for 11 fields *)
+  (** tracking presence for 12 fields *)
   mutable trace_id : bytes;
   mutable span_id : bytes;
   mutable trace_state : string;
   mutable parent_span_id : bytes;
+  mutable flags : int32;
   mutable name : string;
   mutable kind : span_span_kind;
   mutable start_time_unix_nano : int64;
@@ -79,6 +81,12 @@ type traces_data = {
   mutable resource_spans : resource_spans list;
 }
 
+type span_flags =
+  | Span_flags_do_not_use 
+  | Span_flags_trace_flags_mask 
+  | Span_flags_context_has_is_remote_mask 
+  | Span_flags_context_is_remote_mask 
+
 let default_span_span_kind () = (Span_kind_unspecified:span_span_kind)
 
 let default_span_event (): span_event = 
@@ -98,6 +106,7 @@ let default_span_link (): span_link =
   trace_state="";
   attributes=[];
   dropped_attributes_count=0l;
+  flags=0l;
 }
 
 let default_status_status_code () = (Status_code_unset:status_status_code)
@@ -116,6 +125,7 @@ let default_span (): span =
   span_id=Bytes.create 0;
   trace_state="";
   parent_span_id=Bytes.create 0;
+  flags=0l;
   name="";
   kind=default_span_span_kind ();
   start_time_unix_nano=0L;
@@ -150,6 +160,8 @@ let default_traces_data (): traces_data =
   resource_spans=[];
 }
 
+let default_span_flags () = (Span_flags_do_not_use:span_flags)
+
 
 (** {2 Make functions} *)
 
@@ -193,6 +205,7 @@ let[@inline] has_span_link_trace_id (self:span_link) : bool = (Pbrt.Bitfield.get
 let[@inline] has_span_link_span_id (self:span_link) : bool = (Pbrt.Bitfield.get self._presence 1)
 let[@inline] has_span_link_trace_state (self:span_link) : bool = (Pbrt.Bitfield.get self._presence 2)
 let[@inline] has_span_link_dropped_attributes_count (self:span_link) : bool = (Pbrt.Bitfield.get self._presence 3)
+let[@inline] has_span_link_flags (self:span_link) : bool = (Pbrt.Bitfield.get self._presence 4)
 
 let[@inline] set_span_link_trace_id (self:span_link) (x:bytes) : unit =
   self._presence <- (Pbrt.Bitfield.set self._presence 0); self.trace_id <- x
@@ -204,6 +217,8 @@ let[@inline] set_span_link_attributes (self:span_link) (x:Common.key_value list)
   self.attributes <- x
 let[@inline] set_span_link_dropped_attributes_count (self:span_link) (x:int32) : unit =
   self._presence <- (Pbrt.Bitfield.set self._presence 3); self.dropped_attributes_count <- x
+let[@inline] set_span_link_flags (self:span_link) (x:int32) : unit =
+  self._presence <- (Pbrt.Bitfield.set self._presence 4); self.flags <- x
 
 let copy_span_link (self:span_link) : span_link =
   { self with trace_id = self.trace_id }
@@ -214,6 +229,7 @@ let make_span_link
   ?(trace_state:string option)
   ~(attributes:Common.key_value list) 
   ?(dropped_attributes_count:int32 option)
+  ?(flags:int32 option)
   () : span_link  =
   let _res = default_span_link () in
   (match trace_id with
@@ -229,6 +245,9 @@ let make_span_link
   (match dropped_attributes_count with
   | None -> ()
   | Some v -> set_span_link_dropped_attributes_count _res v);
+  (match flags with
+  | None -> ()
+  | Some v -> set_span_link_flags _res v);
   _res
 
 
@@ -260,13 +279,14 @@ let[@inline] has_span_trace_id (self:span) : bool = (Pbrt.Bitfield.get self._pre
 let[@inline] has_span_span_id (self:span) : bool = (Pbrt.Bitfield.get self._presence 1)
 let[@inline] has_span_trace_state (self:span) : bool = (Pbrt.Bitfield.get self._presence 2)
 let[@inline] has_span_parent_span_id (self:span) : bool = (Pbrt.Bitfield.get self._presence 3)
-let[@inline] has_span_name (self:span) : bool = (Pbrt.Bitfield.get self._presence 4)
-let[@inline] has_span_kind (self:span) : bool = (Pbrt.Bitfield.get self._presence 5)
-let[@inline] has_span_start_time_unix_nano (self:span) : bool = (Pbrt.Bitfield.get self._presence 6)
-let[@inline] has_span_end_time_unix_nano (self:span) : bool = (Pbrt.Bitfield.get self._presence 7)
-let[@inline] has_span_dropped_attributes_count (self:span) : bool = (Pbrt.Bitfield.get self._presence 8)
-let[@inline] has_span_dropped_events_count (self:span) : bool = (Pbrt.Bitfield.get self._presence 9)
-let[@inline] has_span_dropped_links_count (self:span) : bool = (Pbrt.Bitfield.get self._presence 10)
+let[@inline] has_span_flags (self:span) : bool = (Pbrt.Bitfield.get self._presence 4)
+let[@inline] has_span_name (self:span) : bool = (Pbrt.Bitfield.get self._presence 5)
+let[@inline] has_span_kind (self:span) : bool = (Pbrt.Bitfield.get self._presence 6)
+let[@inline] has_span_start_time_unix_nano (self:span) : bool = (Pbrt.Bitfield.get self._presence 7)
+let[@inline] has_span_end_time_unix_nano (self:span) : bool = (Pbrt.Bitfield.get self._presence 8)
+let[@inline] has_span_dropped_attributes_count (self:span) : bool = (Pbrt.Bitfield.get self._presence 9)
+let[@inline] has_span_dropped_events_count (self:span) : bool = (Pbrt.Bitfield.get self._presence 10)
+let[@inline] has_span_dropped_links_count (self:span) : bool = (Pbrt.Bitfield.get self._presence 11)
 
 let[@inline] set_span_trace_id (self:span) (x:bytes) : unit =
   self._presence <- (Pbrt.Bitfield.set self._presence 0); self.trace_id <- x
@@ -276,26 +296,28 @@ let[@inline] set_span_trace_state (self:span) (x:string) : unit =
   self._presence <- (Pbrt.Bitfield.set self._presence 2); self.trace_state <- x
 let[@inline] set_span_parent_span_id (self:span) (x:bytes) : unit =
   self._presence <- (Pbrt.Bitfield.set self._presence 3); self.parent_span_id <- x
+let[@inline] set_span_flags (self:span) (x:int32) : unit =
+  self._presence <- (Pbrt.Bitfield.set self._presence 4); self.flags <- x
 let[@inline] set_span_name (self:span) (x:string) : unit =
-  self._presence <- (Pbrt.Bitfield.set self._presence 4); self.name <- x
+  self._presence <- (Pbrt.Bitfield.set self._presence 5); self.name <- x
 let[@inline] set_span_kind (self:span) (x:span_span_kind) : unit =
-  self._presence <- (Pbrt.Bitfield.set self._presence 5); self.kind <- x
+  self._presence <- (Pbrt.Bitfield.set self._presence 6); self.kind <- x
 let[@inline] set_span_start_time_unix_nano (self:span) (x:int64) : unit =
-  self._presence <- (Pbrt.Bitfield.set self._presence 6); self.start_time_unix_nano <- x
+  self._presence <- (Pbrt.Bitfield.set self._presence 7); self.start_time_unix_nano <- x
 let[@inline] set_span_end_time_unix_nano (self:span) (x:int64) : unit =
-  self._presence <- (Pbrt.Bitfield.set self._presence 7); self.end_time_unix_nano <- x
+  self._presence <- (Pbrt.Bitfield.set self._presence 8); self.end_time_unix_nano <- x
 let[@inline] set_span_attributes (self:span) (x:Common.key_value list) : unit =
   self.attributes <- x
 let[@inline] set_span_dropped_attributes_count (self:span) (x:int32) : unit =
-  self._presence <- (Pbrt.Bitfield.set self._presence 8); self.dropped_attributes_count <- x
+  self._presence <- (Pbrt.Bitfield.set self._presence 9); self.dropped_attributes_count <- x
 let[@inline] set_span_events (self:span) (x:span_event list) : unit =
   self.events <- x
 let[@inline] set_span_dropped_events_count (self:span) (x:int32) : unit =
-  self._presence <- (Pbrt.Bitfield.set self._presence 9); self.dropped_events_count <- x
+  self._presence <- (Pbrt.Bitfield.set self._presence 10); self.dropped_events_count <- x
 let[@inline] set_span_links (self:span) (x:span_link list) : unit =
   self.links <- x
 let[@inline] set_span_dropped_links_count (self:span) (x:int32) : unit =
-  self._presence <- (Pbrt.Bitfield.set self._presence 10); self.dropped_links_count <- x
+  self._presence <- (Pbrt.Bitfield.set self._presence 11); self.dropped_links_count <- x
 let[@inline] set_span_status (self:span) (x:status) : unit =
   self.status <- Some x
 
@@ -307,6 +329,7 @@ let make_span
   ?(span_id:bytes option)
   ?(trace_state:string option)
   ?(parent_span_id:bytes option)
+  ?(flags:int32 option)
   ?(name:string option)
   ?(kind:span_span_kind option)
   ?(start_time_unix_nano:int64 option)
@@ -332,6 +355,9 @@ let make_span
   (match parent_span_id with
   | None -> ()
   | Some v -> set_span_parent_span_id _res v);
+  (match flags with
+  | None -> ()
+  | Some v -> set_span_flags _res v);
   (match name with
   | None -> ()
   | Some v -> set_span_name _res v);
@@ -429,6 +455,7 @@ let make_traces_data
   set_traces_data_resource_spans _res resource_spans;
   _res
 
+
 [@@@ocaml.warning "-23-27-30-39"]
 
 (** {2 Formatters} *)
@@ -465,6 +492,8 @@ let rec pp_span_link fmt (v:span_link) =
     Pbrt.Pp.pp_record_field ~first:false "attributes" (Pbrt.Pp.pp_list Common.pp_key_value) fmt v.attributes;
     Pbrt.Pp.pp_record_field ~first:false "dropped_attributes_count" Pbrt.Pp.pp_int32 fmt v.dropped_attributes_count;
     if not (Pbrt.Bitfield.get v._presence 3) then Format.pp_print_string fmt "(* absent *)";
+    Pbrt.Pp.pp_record_field ~first:false "flags" Pbrt.Pp.pp_int32 fmt v.flags;
+    if not (Pbrt.Bitfield.get v._presence 4) then Format.pp_print_string fmt "(* absent *)";
   in
   Pbrt.Pp.pp_brk pp_i fmt ()
 
@@ -493,23 +522,25 @@ let rec pp_span fmt (v:span) =
     if not (Pbrt.Bitfield.get v._presence 2) then Format.pp_print_string fmt "(* absent *)";
     Pbrt.Pp.pp_record_field ~first:false "parent_span_id" Pbrt.Pp.pp_bytes fmt v.parent_span_id;
     if not (Pbrt.Bitfield.get v._presence 3) then Format.pp_print_string fmt "(* absent *)";
-    Pbrt.Pp.pp_record_field ~first:false "name" Pbrt.Pp.pp_string fmt v.name;
+    Pbrt.Pp.pp_record_field ~first:false "flags" Pbrt.Pp.pp_int32 fmt v.flags;
     if not (Pbrt.Bitfield.get v._presence 4) then Format.pp_print_string fmt "(* absent *)";
-    Pbrt.Pp.pp_record_field ~first:false "kind" pp_span_span_kind fmt v.kind;
+    Pbrt.Pp.pp_record_field ~first:false "name" Pbrt.Pp.pp_string fmt v.name;
     if not (Pbrt.Bitfield.get v._presence 5) then Format.pp_print_string fmt "(* absent *)";
-    Pbrt.Pp.pp_record_field ~first:false "start_time_unix_nano" Pbrt.Pp.pp_int64 fmt v.start_time_unix_nano;
+    Pbrt.Pp.pp_record_field ~first:false "kind" pp_span_span_kind fmt v.kind;
     if not (Pbrt.Bitfield.get v._presence 6) then Format.pp_print_string fmt "(* absent *)";
-    Pbrt.Pp.pp_record_field ~first:false "end_time_unix_nano" Pbrt.Pp.pp_int64 fmt v.end_time_unix_nano;
+    Pbrt.Pp.pp_record_field ~first:false "start_time_unix_nano" Pbrt.Pp.pp_int64 fmt v.start_time_unix_nano;
     if not (Pbrt.Bitfield.get v._presence 7) then Format.pp_print_string fmt "(* absent *)";
+    Pbrt.Pp.pp_record_field ~first:false "end_time_unix_nano" Pbrt.Pp.pp_int64 fmt v.end_time_unix_nano;
+    if not (Pbrt.Bitfield.get v._presence 8) then Format.pp_print_string fmt "(* absent *)";
     Pbrt.Pp.pp_record_field ~first:false "attributes" (Pbrt.Pp.pp_list Common.pp_key_value) fmt v.attributes;
     Pbrt.Pp.pp_record_field ~first:false "dropped_attributes_count" Pbrt.Pp.pp_int32 fmt v.dropped_attributes_count;
-    if not (Pbrt.Bitfield.get v._presence 8) then Format.pp_print_string fmt "(* absent *)";
+    if not (Pbrt.Bitfield.get v._presence 9) then Format.pp_print_string fmt "(* absent *)";
     Pbrt.Pp.pp_record_field ~first:false "events" (Pbrt.Pp.pp_list pp_span_event) fmt v.events;
     Pbrt.Pp.pp_record_field ~first:false "dropped_events_count" Pbrt.Pp.pp_int32 fmt v.dropped_events_count;
-    if not (Pbrt.Bitfield.get v._presence 9) then Format.pp_print_string fmt "(* absent *)";
+    if not (Pbrt.Bitfield.get v._presence 10) then Format.pp_print_string fmt "(* absent *)";
     Pbrt.Pp.pp_record_field ~first:false "links" (Pbrt.Pp.pp_list pp_span_link) fmt v.links;
     Pbrt.Pp.pp_record_field ~first:false "dropped_links_count" Pbrt.Pp.pp_int32 fmt v.dropped_links_count;
-    if not (Pbrt.Bitfield.get v._presence 10) then Format.pp_print_string fmt "(* absent *)";
+    if not (Pbrt.Bitfield.get v._presence 11) then Format.pp_print_string fmt "(* absent *)";
     Pbrt.Pp.pp_record_field ~first:false "status" (Pbrt.Pp.pp_option pp_status) fmt v.status;
   in
   Pbrt.Pp.pp_brk pp_i fmt ()
@@ -538,6 +569,13 @@ let rec pp_traces_data fmt (v:traces_data) =
   in
   Pbrt.Pp.pp_brk pp_i fmt ()
 
+let rec pp_span_flags fmt (v:span_flags) =
+  match v with
+  | Span_flags_do_not_use -> Format.fprintf fmt "Span_flags_do_not_use"
+  | Span_flags_trace_flags_mask -> Format.fprintf fmt "Span_flags_trace_flags_mask"
+  | Span_flags_context_has_is_remote_mask -> Format.fprintf fmt "Span_flags_context_has_is_remote_mask"
+  | Span_flags_context_is_remote_mask -> Format.fprintf fmt "Span_flags_context_is_remote_mask"
+
 [@@@ocaml.warning "-23-27-30-39"]
 
 (** {2 Protobuf Encoding} *)
@@ -591,6 +629,10 @@ let rec encode_pb_span_link (v:span_link) encoder =
     Pbrt.Encoder.int32_as_varint v.dropped_attributes_count encoder;
     Pbrt.Encoder.key 5 Pbrt.Varint encoder; 
   );
+  if (Pbrt.Bitfield.get v._presence 4) then (
+    Pbrt.Encoder.int32_as_bits32 v.flags encoder;
+    Pbrt.Encoder.key 6 Pbrt.Bits32 encoder; 
+  );
   ()
 
 let rec encode_pb_status_status_code (v:status_status_code) encoder =
@@ -628,18 +670,22 @@ let rec encode_pb_span (v:span) encoder =
     Pbrt.Encoder.key 4 Pbrt.Bytes encoder; 
   );
   if (Pbrt.Bitfield.get v._presence 4) then (
+    Pbrt.Encoder.int32_as_bits32 v.flags encoder;
+    Pbrt.Encoder.key 16 Pbrt.Bits32 encoder; 
+  );
+  if (Pbrt.Bitfield.get v._presence 5) then (
     Pbrt.Encoder.string v.name encoder;
     Pbrt.Encoder.key 5 Pbrt.Bytes encoder; 
   );
-  if (Pbrt.Bitfield.get v._presence 5) then (
+  if (Pbrt.Bitfield.get v._presence 6) then (
     encode_pb_span_span_kind v.kind encoder;
     Pbrt.Encoder.key 6 Pbrt.Varint encoder; 
   );
-  if (Pbrt.Bitfield.get v._presence 6) then (
+  if (Pbrt.Bitfield.get v._presence 7) then (
     Pbrt.Encoder.int64_as_bits64 v.start_time_unix_nano encoder;
     Pbrt.Encoder.key 7 Pbrt.Bits64 encoder; 
   );
-  if (Pbrt.Bitfield.get v._presence 7) then (
+  if (Pbrt.Bitfield.get v._presence 8) then (
     Pbrt.Encoder.int64_as_bits64 v.end_time_unix_nano encoder;
     Pbrt.Encoder.key 8 Pbrt.Bits64 encoder; 
   );
@@ -647,7 +693,7 @@ let rec encode_pb_span (v:span) encoder =
     Pbrt.Encoder.nested Common.encode_pb_key_value x encoder;
     Pbrt.Encoder.key 9 Pbrt.Bytes encoder; 
   ) v.attributes encoder;
-  if (Pbrt.Bitfield.get v._presence 8) then (
+  if (Pbrt.Bitfield.get v._presence 9) then (
     Pbrt.Encoder.int32_as_varint v.dropped_attributes_count encoder;
     Pbrt.Encoder.key 10 Pbrt.Varint encoder; 
   );
@@ -655,7 +701,7 @@ let rec encode_pb_span (v:span) encoder =
     Pbrt.Encoder.nested encode_pb_span_event x encoder;
     Pbrt.Encoder.key 11 Pbrt.Bytes encoder; 
   ) v.events encoder;
-  if (Pbrt.Bitfield.get v._presence 9) then (
+  if (Pbrt.Bitfield.get v._presence 10) then (
     Pbrt.Encoder.int32_as_varint v.dropped_events_count encoder;
     Pbrt.Encoder.key 12 Pbrt.Varint encoder; 
   );
@@ -663,7 +709,7 @@ let rec encode_pb_span (v:span) encoder =
     Pbrt.Encoder.nested encode_pb_span_link x encoder;
     Pbrt.Encoder.key 13 Pbrt.Bytes encoder; 
   ) v.links encoder;
-  if (Pbrt.Bitfield.get v._presence 10) then (
+  if (Pbrt.Bitfield.get v._presence 11) then (
     Pbrt.Encoder.int32_as_varint v.dropped_links_count encoder;
     Pbrt.Encoder.key 14 Pbrt.Varint encoder; 
   );
@@ -716,6 +762,13 @@ let rec encode_pb_traces_data (v:traces_data) encoder =
   ) v.resource_spans encoder;
   ()
 
+let rec encode_pb_span_flags (v:span_flags) encoder =
+  match v with
+  | Span_flags_do_not_use -> Pbrt.Encoder.int_as_varint (0) encoder
+  | Span_flags_trace_flags_mask -> Pbrt.Encoder.int_as_varint 255 encoder
+  | Span_flags_context_has_is_remote_mask -> Pbrt.Encoder.int_as_varint 256 encoder
+  | Span_flags_context_is_remote_mask -> Pbrt.Encoder.int_as_varint 512 encoder
+
 [@@@ocaml.warning "-23-27-30-39"]
 
 (** {2 Protobuf Decoding} *)
@@ -797,6 +850,11 @@ let rec decode_pb_span_link d =
     end
     | Some (5, pk) -> 
       Pbrt.Decoder.unexpected_payload "Message(span_link), field(5)" pk
+    | Some (6, Pbrt.Bits32) -> begin
+      set_span_link_flags v (Pbrt.Decoder.int32_as_bits32 d);
+    end
+    | Some (6, pk) -> 
+      Pbrt.Decoder.unexpected_payload "Message(span_link), field(6)" pk
     | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
   done;
   (v : span_link)
@@ -860,6 +918,11 @@ let rec decode_pb_span d =
     end
     | Some (4, pk) -> 
       Pbrt.Decoder.unexpected_payload "Message(span), field(4)" pk
+    | Some (16, Pbrt.Bits32) -> begin
+      set_span_flags v (Pbrt.Decoder.int32_as_bits32 d);
+    end
+    | Some (16, pk) -> 
+      Pbrt.Decoder.unexpected_payload "Message(span), field(16)" pk
     | Some (5, Pbrt.Bytes) -> begin
       set_span_name v (Pbrt.Decoder.string d);
     end
@@ -992,3 +1055,11 @@ let rec decode_pb_traces_data d =
     | Some (_, payload_kind) -> Pbrt.Decoder.skip d payload_kind
   done;
   (v : traces_data)
+
+let rec decode_pb_span_flags d = 
+  match Pbrt.Decoder.int_as_varint d with
+  | 0 -> (Span_flags_do_not_use:span_flags)
+  | 255 -> (Span_flags_trace_flags_mask:span_flags)
+  | 256 -> (Span_flags_context_has_is_remote_mask:span_flags)
+  | 512 -> (Span_flags_context_is_remote_mask:span_flags)
+  | _ -> Pbrt.Decoder.malformed_variant "span_flags"
diff --git a/src/proto/trace.mli b/src/proto/trace.mli
index afe573ef..9f9fa49a 100644
--- a/src/proto/trace.mli
+++ b/src/proto/trace.mli
@@ -26,12 +26,13 @@ type span_event = private {
 
 type span_link = private {
   mutable _presence: Pbrt.Bitfield.t;
-  (** tracking presence for 4 fields *)
+  (** tracking presence for 5 fields *)
   mutable trace_id : bytes;
   mutable span_id : bytes;
   mutable trace_state : string;
   mutable attributes : Common.key_value list;
   mutable dropped_attributes_count : int32;
+  mutable flags : int32;
 }
 
 type status_status_code =
@@ -48,11 +49,12 @@ type status = private {
 
 type span = private {
   mutable _presence: Pbrt.Bitfield.t;
-  (** tracking presence for 11 fields *)
+  (** tracking presence for 12 fields *)
   mutable trace_id : bytes;
   mutable span_id : bytes;
   mutable trace_state : string;
   mutable parent_span_id : bytes;
+  mutable flags : int32;
   mutable name : string;
   mutable kind : span_span_kind;
   mutable start_time_unix_nano : int64;
@@ -86,6 +88,12 @@ type traces_data = private {
   mutable resource_spans : resource_spans list;
 }
 
+type span_flags =
+  | Span_flags_do_not_use 
+  | Span_flags_trace_flags_mask 
+  | Span_flags_context_has_is_remote_mask 
+  | Span_flags_context_is_remote_mask 
+
 
 (** {2 Basic values} *)
 
@@ -116,6 +124,9 @@ val default_resource_spans : unit -> resource_spans
 val default_traces_data : unit -> traces_data 
 (** [default_traces_data ()] is a new empty value for type [traces_data] *)
 
+val default_span_flags : unit -> span_flags
+(** [default_span_flags ()] is a new empty value for type [span_flags] *)
+
 
 (** {2 Make functions} *)
 
@@ -158,6 +169,7 @@ val make_span_link :
   ?trace_state:string ->
   attributes:Common.key_value list ->
   ?dropped_attributes_count:int32 ->
+  ?flags:int32 ->
   unit ->
   span_link
 (** [make_span_link … ()] is a builder for type [span_link] *)
@@ -191,6 +203,12 @@ val has_span_link_dropped_attributes_count : span_link -> bool
 val set_span_link_dropped_attributes_count : span_link -> int32 -> unit
   (** set field dropped_attributes_count in span_link *)
 
+val has_span_link_flags : span_link -> bool
+  (** presence of field "flags" in [span_link] *)
+
+val set_span_link_flags : span_link -> int32 -> unit
+  (** set field flags in span_link *)
+
 
 val make_status : 
   ?message:string ->
@@ -218,6 +236,7 @@ val make_span :
   ?span_id:bytes ->
   ?trace_state:string ->
   ?parent_span_id:bytes ->
+  ?flags:int32 ->
   ?name:string ->
   ?kind:span_span_kind ->
   ?start_time_unix_nano:int64 ->
@@ -259,6 +278,12 @@ val has_span_parent_span_id : span -> bool
 val set_span_parent_span_id : span -> bytes -> unit
   (** set field parent_span_id in span *)
 
+val has_span_flags : span -> bool
+  (** presence of field "flags" in [span] *)
+
+val set_span_flags : span -> int32 -> unit
+  (** set field flags in span *)
+
 val has_span_name : span -> bool
   (** presence of field "name" in [span] *)
 
@@ -369,6 +394,7 @@ val set_traces_data_resource_spans : traces_data -> resource_spans list -> unit
   (** set field resource_spans in traces_data *)
 
 
+
 (** {2 Formatters} *)
 
 val pp_span_span_kind : Format.formatter -> span_span_kind -> unit 
@@ -398,6 +424,9 @@ val pp_resource_spans : Format.formatter -> resource_spans -> unit
 val pp_traces_data : Format.formatter -> traces_data -> unit 
 (** [pp_traces_data v] formats v *)
 
+val pp_span_flags : Format.formatter -> span_flags -> unit 
+(** [pp_span_flags v] formats v *)
+
 
 (** {2 Protobuf Encoding} *)
 
@@ -428,6 +457,9 @@ val encode_pb_resource_spans : resource_spans -> Pbrt.Encoder.t -> unit
 val encode_pb_traces_data : traces_data -> Pbrt.Encoder.t -> unit
 (** [encode_pb_traces_data v encoder] encodes [v] with the given [encoder] *)
 
+val encode_pb_span_flags : span_flags -> Pbrt.Encoder.t -> unit
+(** [encode_pb_span_flags v encoder] encodes [v] with the given [encoder] *)
+
 
 (** {2 Protobuf Decoding} *)
 
@@ -457,3 +489,6 @@ val decode_pb_resource_spans : Pbrt.Decoder.t -> resource_spans
 
 val decode_pb_traces_data : Pbrt.Decoder.t -> traces_data
 (** [decode_pb_traces_data decoder] decodes a [traces_data] binary value from [decoder] *)
+
+val decode_pb_span_flags : Pbrt.Decoder.t -> span_flags
+(** [decode_pb_span_flags decoder] decodes a [span_flags] binary value from [decoder] *)