[Feature]: Add is_remote flag in exporter for spans and span links (#894)

* feat: added is_remote span flag functionality in exporter

* chore: updated PR for changelog

* fix: define start and end time in tests

* fix: pass attributes in erlang sdk

Author: nikhilmantri0902

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- [Add is_remote flag in exporter for spans and span links](https://github.com/open-telemetry/opentelemetry-erlang/pull/894)
+
 ## API 1.4.1 - 2025-07-31
 
 ### Fixes

apps/opentelemetry/include/otel_span.hrl

@@ -28,6 +28,9 @@
           %% 64 bit int parent span
           parent_span_id          :: opentelemetry:span_id() | undefined | '_',
 
+          %% true if the parent span context came from a remote process
+          parent_span_is_remote   :: boolean() | undefined | '_',
+
           %% name of the span
           name                    :: unicode:unicode_binary() | atom() | '_',
 

apps/opentelemetry/src/otel_span_utils.erl

@@ -50,7 +50,7 @@ start_span(Ctx, Name, Sampler, IdGenerator, Opts) ->
     new_span(Ctx, Name, Sampler, IdGenerator, StartTime, Kind, Attributes, Events, Links).
 
 new_span(Ctx, Name, Sampler, IdGeneratorModule, StartTime, Kind, Attributes, Events, Links) ->
-    {NewSpanCtx, ParentSpanId} = new_span_ctx(Ctx, IdGeneratorModule),
+    {NewSpanCtx, ParentSpanId, ParentIsRemote} = new_span_ctx(Ctx, IdGeneratorModule),
 
     TraceId = NewSpanCtx#span_ctx.trace_id,
     SpanId = NewSpanCtx#span_ctx.span_id,
@@ -63,6 +63,7 @@ new_span(Ctx, Name, Sampler, IdGeneratorModule, StartTime, Kind, Attributes, Eve
                  tracestate=TraceState,
                  start_time=StartTime,
                  parent_span_id=ParentSpanId,
+                 parent_span_is_remote=ParentIsRemote,
                  kind=Kind,
                  name=Name,
                  attributes=otel_attributes:set(SamplerAttributes, Attributes),
@@ -77,16 +78,16 @@ new_span(Ctx, Name, Sampler, IdGeneratorModule, StartTime, Kind, Attributes, Eve
                          is_recording=IsRecording}, Span}.
 
 -spec new_span_ctx(otel_ctx:t(), otel_id_generator:t()) ->
-          {opentelemetry:span_ctx(), opentelemetry:span_id() | undefined}.
+          {opentelemetry:span_ctx(), opentelemetry:span_id() | undefined, boolean() | undefined}.
 new_span_ctx(Ctx, IdGeneratorModule) ->
     case otel_tracer:current_span_ctx(Ctx) of
         undefined ->
-            {root_span_ctx(IdGeneratorModule), undefined};
+            {root_span_ctx(IdGeneratorModule), undefined, undefined};
         #span_ctx{is_valid=false} ->
-            {root_span_ctx(IdGeneratorModule), undefined};
-        ParentSpanCtx=#span_ctx{span_id=ParentSpanId} ->
+            {root_span_ctx(IdGeneratorModule), undefined, undefined};
+        ParentSpanCtx=#span_ctx{span_id=ParentSpanId, is_remote=ParentIsRemote} ->
             %% keep the rest of the parent span ctx, simply need to update the span_id
-            {ParentSpanCtx#span_ctx{span_id=IdGeneratorModule:generate_span_id()}, ParentSpanId}
+            {ParentSpanCtx#span_ctx{span_id=IdGeneratorModule:generate_span_id()}, ParentSpanId, ParentIsRemote}
     end.
 
 root_span_ctx(IdGeneratorModule) ->

apps/opentelemetry/test/otel_batch_processor_SUITE.erl

@@ -99,9 +99,18 @@ shutdown(_) ->
 %% helpers
 
 generate_span() ->
+    StartTime = opentelemetry:timestamp(),
+    EndTime = opentelemetry:timestamp(),
     #span{trace_id = otel_id_generator:generate_trace_id(),
           span_id = otel_id_generator:generate_span_id(),
           name = "test_span",
+          start_time = StartTime,
+          end_time = EndTime,
           trace_flags = 1,
           is_recording = true,
+          parent_span_is_remote = undefined,
+          attributes = otel_attributes:new([], 128, 128),
+          events = otel_events:new(128, 128, 128),
+          links = otel_links:new([], 128, 128, 128),
+          tracestate = otel_tracestate:new([]),
           instrumentation_scope = #instrumentation_scope{name = "test"}}.

apps/opentelemetry_exporter/src/otel_otlp_traces.erl

@@ -22,7 +22,8 @@
 %% for testing
 -ifdef(TEST).
 -export([to_proto_by_instrumentation_scope/1,
-         to_proto/1]).
+         to_proto/1,
+         build_span_flags/2]).
 -endif.
 
 -include_lib("opentelemetry_api/include/opentelemetry.hrl").
@@ -67,6 +68,7 @@ to_proto(#span{trace_id=TraceId,
                span_id=SpanId,
                tracestate=TraceState,
                parent_span_id=MaybeParentSpanId,
+               parent_span_is_remote=ParentIsRemote,
                name=Name,
                kind=Kind,
                start_time=StartTime,
@@ -75,7 +77,7 @@ to_proto(#span{trace_id=TraceId,
                events=TimedEvents,
                links=Links,
                status=Status,
-               trace_flags=_TraceFlags,
+               trace_flags=TraceFlags,
                is_recording=_IsRecording}) when is_integer(TraceId),
                                                 is_integer(SpanId) ->
     ParentSpanId = case MaybeParentSpanId of _ when is_integer(MaybeParentSpanId) -> <<MaybeParentSpanId:64>>; _ -> <<>> end,
@@ -93,7 +95,8 @@ to_proto(#span{trace_id=TraceId,
       dropped_events_count     => otel_events:dropped(TimedEvents),
       links                    => to_links(otel_links:list(Links)),
       dropped_links_count      => otel_links:dropped(Links),
-      status                   => to_status(Status)}.
+      status                   => to_status(Status),
+      flags                    => build_span_flags(ParentIsRemote, TraceFlags)}.
 
 -spec to_status(opentelemetry:status() | undefined) -> opentelemetry_exporter_trace_service_pb:status().
 to_status(#status{code=Code,
@@ -118,10 +121,11 @@ to_links(Links) ->
        span_id => <<SpanId:64>>,
        trace_state => otel_tracestate:encode_header(TraceState),
        attributes => otel_otlp_common:to_attributes(Attributes),
-       dropped_attributes_count => 0} || #link{trace_id=TraceId,
-                                               span_id=SpanId,
-                                               attributes=Attributes,
-                                               tracestate=TraceState} <- Links].
+       dropped_attributes_count => 0,
+       flags => build_span_flags(undefined, 0)} || #link{trace_id=TraceId,
+                                                         span_id=SpanId,
+                                                         attributes=Attributes,
+                                                         tracestate=TraceState} <- Links].
 
 -spec to_otlp_kind(atom()) -> opentelemetry_exporter_trace_service_pb:'span.SpanKind'().
 to_otlp_kind(?SPAN_KIND_INTERNAL) ->
@@ -144,3 +148,21 @@ to_otlp_status(?OTEL_STATUS_OK) ->
     'STATUS_CODE_OK';
 to_otlp_status(?OTEL_STATUS_ERROR) ->
     'STATUS_CODE_ERROR'.
+
+%% @doc Builds span flags based on the parent span context's remote property.
+%% This follows the OTLP specification for span flags.
+%% @param ParentIsRemote boolean() | undefined - whether the parent span context is remote
+%% @param BaseFlags integer() - base flags (typically trace_flags)
+%% @return integer() - computed span flags
+-spec build_span_flags(boolean() | undefined, integer()) -> integer().
+build_span_flags(ParentIsRemote, BaseFlags) ->
+    %% SPAN_FLAGS_CONTEXT_HAS_IS_REMOTE_MASK = 0x100
+    %% SPAN_FLAGS_CONTEXT_IS_REMOTE_MASK = 0x200
+    HasIsRemoteMask = 16#100,
+    IsRemoteMask = 16#200,
+    
+    Flags = BaseFlags bor HasIsRemoteMask,
+    case ParentIsRemote of
+        true -> Flags bor IsRemoteMask;
+        _ -> Flags
+    end.

apps/opentelemetry_exporter/test/opentelemetry_exporter_SUITE.erl

@@ -14,7 +14,7 @@ all() ->
      {group, grpc}, {group, grpc_gzip}].
 
 groups() ->
-    [{functional, [], [configuration, span_round_trip, ets_instrumentation_info, to_attributes]},
+    [{functional, [], [configuration, span_round_trip, span_flags, ets_instrumentation_info, to_attributes]},
      {grpc, [], [verify_export]},
      {grpc_gzip, [], [verify_export]},
      {http_protobuf, [], [verify_export, user_agent]},
@@ -322,6 +322,7 @@ span_round_trip(_Config) ->
                                                 ], 128, 128),
               status = #status{code=?OTEL_STATUS_OK,
                                message = <<"">>},
+              parent_span_is_remote = undefined,
               instrumentation_scope = #instrumentation_scope{name = <<"tracer-1">>,
                                                              version = <<"0.0.1">>}},
 
@@ -335,6 +336,79 @@ span_round_trip(_Config) ->
 
     ok.
 
+span_flags(_Config) ->
+    %% Test build_span_flags function
+    ?assertEqual(16#100, otel_otlp_traces:build_span_flags(false, 0)),   %% 0x100 - local parent
+    ?assertEqual(16#300, otel_otlp_traces:build_span_flags(true, 0)),    %% 0x300 - remote parent
+    ?assertEqual(16#100, otel_otlp_traces:build_span_flags(undefined, 0)), %% 0x100 - no parent
+    ?assertEqual(16#101, otel_otlp_traces:build_span_flags(false, 1)),   %% 0x101 - local parent with sampled flag
+    ?assertEqual(16#301, otel_otlp_traces:build_span_flags(true, 1)),    %% 0x301 - remote parent with sampled flag
+
+    %% Test span with local parent
+    TraceId = otel_id_generator:generate_trace_id(),
+    SpanId = otel_id_generator:generate_span_id(),
+    ParentSpanId = otel_id_generator:generate_span_id(),
+    StartTime = opentelemetry:timestamp(),
+    EndTime = opentelemetry:timestamp(),
+    
+    LocalParentSpan = #span{name = <<"span-with-local-parent">>,
+                           trace_id = TraceId,
+                           span_id = SpanId,
+                           parent_span_id = ParentSpanId,
+                           parent_span_is_remote = false,
+                           kind = ?SPAN_KIND_CLIENT,
+                           start_time = StartTime,
+                           end_time = EndTime,
+                           trace_flags = 1,
+                           is_recording = true,
+                           attributes = otel_attributes:new([], 128, 128),
+                           events = otel_events:new(128, 128, 128),
+                           links = otel_links:new([], 128, 128, 128),
+                           tracestate = otel_tracestate:new([])},
+    
+    PbSpanLocal = otel_otlp_traces:to_proto(LocalParentSpan),
+    ?assertEqual(16#101, maps:get(flags, PbSpanLocal)), %% 0x101 - local parent with sampled flag
+
+    %% Test span with remote parent
+    RemoteParentSpan = #span{name = <<"span-with-remote-parent">>,
+                            trace_id = TraceId,
+                            span_id = SpanId,
+                            parent_span_id = ParentSpanId,
+                            parent_span_is_remote = true,
+                            kind = ?SPAN_KIND_CLIENT,
+                            start_time = StartTime,
+                            end_time = EndTime,
+                            trace_flags = 1,
+                            is_recording = true,
+                            attributes = otel_attributes:new([], 128, 128),
+                            events = otel_events:new(128, 128, 128),
+                            links = otel_links:new([], 128, 128, 128),
+                            tracestate = otel_tracestate:new([])},
+    
+    PbSpanRemote = otel_otlp_traces:to_proto(RemoteParentSpan),
+    ?assertEqual(16#301, maps:get(flags, PbSpanRemote)), %% 0x301 - remote parent with sampled flag
+
+    %% Test span with no parent
+    NoParentSpan = #span{name = <<"span-with-no-parent">>,
+                        trace_id = TraceId,
+                        span_id = SpanId,
+                        parent_span_id = undefined,
+                        parent_span_is_remote = undefined,
+                        kind = ?SPAN_KIND_CLIENT,
+                        start_time = StartTime,
+                        end_time = EndTime,
+                        trace_flags = 1,
+                        is_recording = true,
+                        attributes = otel_attributes:new([], 128, 128),
+                        events = otel_events:new(128, 128, 128),
+                        links = otel_links:new([], 128, 128, 128),
+                        tracestate = otel_tracestate:new([])},
+    
+    PbSpanNoParent = otel_otlp_traces:to_proto(NoParentSpan),
+    ?assertEqual(16#101, maps:get(flags, PbSpanNoParent)), %% 0x101 - no parent with sampled flag
+
+    ok.
+
 %% test conversion of attributes to the map representation of the OTLP protobuf
 to_attributes(_Config) ->
     %% this tests the removal of support for iolists as values in attributes

apps/opentelemetry_zipkin/test/opentelemetry_zipkin_SUITE.erl

@@ -46,7 +46,8 @@ verify_export(_Config) ->
                                                 {<<"map-key-1">>, #{<<"map-key-1">> => 123}},
                                                 {<<"list-key-1">>, [3.14, 9.345]}
                                                 ], 128, 128),
-              status=opentelemetry:status(?SPAN_KIND_INTERNAL, <<"some message about status">>)},
+              status=opentelemetry:status(?SPAN_KIND_INTERNAL, <<"some message about status">>),
+              parent_span_is_remote = undefined},
     true = ets:insert(Tid, ParentSpan),
 
     ChildSpan = #span{name = <<"span-2">>,
@@ -66,7 +67,8 @@ verify_export(_Config) ->
                                                         {attr_3, true},
                                                         {<<"map-key-1">>, #{<<"map-key-1">> => 123}},
                                                         {<<"list-key-1">>, [3.14, 9.345]}
-                                                       ], 128, 128)},
+                                                       ], 128, 128),
+                      parent_span_is_remote = false},
     true = ets:insert(Tid, ChildSpan),
 
     ?assertMatch(ok, opentelemetry_zipkin:export(traces, Tid, Resource, State)),