datadog 2.21.0 → 2.38.0

data/lib/datadog/opentelemetry/configuration/settings.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative '../../core/configuration/ext'
+
+module Datadog
+  module OpenTelemetry
+    module Configuration
+      module Settings
+        def self.extended(base)
+          base = base.singleton_class unless base.is_a?(Class)
+          add_settings!(base)
+        end
+
+        def self.normalize_temporality_preference(env_var_name)
+          proc do |value|
+            if value && value.to_s.downcase != 'delta' && value.to_s.downcase != 'cumulative'
+              Datadog.logger.warn("#{env_var_name}=#{value} is not supported. Using delta instead.")
+              'delta'
+            else
+              value
+            end
+          end
+        end
+
+        def self.normalize_protocol(env_var_name)
+          proc do |value|
+            if value && value.to_s.downcase != 'http/protobuf'
+              Datadog.logger.warn("#{env_var_name}=#{value} is not supported. Using http/protobuf instead.")
+            end
+            'http/protobuf'
+          end
+        end
+
+        def self.headers_parser(env_var_name)
+          lambda do |value|
+            return {} if value.nil? || value.empty?
+
+            headers = {}
+            header_items = value.split(',')
+            header_items.each do |key_value|
+              key, header_value = key_value.split('=', 2)
+              # If header is malformed, return an empty hash
+              if key.nil? || header_value.nil?
+                Datadog.logger.warn("#{env_var_name} has malformed header: #{key_value.inspect}")
+                return {}
+              end
+
+              key.strip!
+              header_value.strip!
+              if key.empty? || header_value.empty?
+                Datadog.logger.warn("#{env_var_name} has empty key or value in: #{key_value.inspect}")
+                return {}
+              end
+
+              headers[key] = header_value
+            end
+            headers
+          end
+        end
+
+        def self.add_settings!(base)
+          base.class_eval do
+            settings :opentelemetry do
+              settings :exporter do
+                option :protocol do |o|
+                  o.type :string
+                  o.setter(&Settings.normalize_protocol('OTEL_EXPORTER_OTLP_PROTOCOL'))
+                  o.env 'OTEL_EXPORTER_OTLP_PROTOCOL'
+                  o.default 'http/protobuf'
+                end
+
+                option :timeout_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_EXPORTER_OTLP_TIMEOUT'
+                  o.default 10_000
+                end
+
+                option :headers do |o|
+                  o.skip_telemetry true
+                  o.type :hash
+                  o.env 'OTEL_EXPORTER_OTLP_HEADERS'
+                  o.default { {} }
+                  o.env_parser(&Settings.headers_parser('OTEL_EXPORTER_OTLP_HEADERS'))
+                end
+
+                option :endpoint do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_ENDPOINT'
+                  o.default nil
+                end
+              end
+
+              settings :metrics do
+                # Metrics-specific options default to nil to detect unset state.
+                # If a metrics-specific env var (e.g., OTEL_EXPORTER_OTLP_METRICS_TIMEOUT) is not set,
+                # we fall back to the general OTLP env var (e.g., OTEL_EXPORTER_OTLP_TIMEOUT) per OpenTelemetry spec.
+                option :enabled do |o|
+                  o.type :bool
+                  o.env 'DD_METRICS_OTEL_ENABLED'
+                  o.default false
+                end
+
+                option :exporter do |o|
+                  o.type :string
+                  o.env 'OTEL_METRICS_EXPORTER'
+                  o.default 'otlp'
+                end
+
+                option :export_interval_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_METRIC_EXPORT_INTERVAL'
+                  o.default 10_000
+                end
+
+                option :export_timeout_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_METRIC_EXPORT_TIMEOUT'
+                  o.default 7_500
+                end
+
+                option :temporality_preference do |o|
+                  o.type :string
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'
+                  o.default 'delta'
+                  o.setter(&Settings.normalize_temporality_preference('OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'))
+                end
+
+                option :endpoint do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_ENDPOINT'
+                  o.default nil
+                end
+
+                option :headers do |o|
+                  o.skip_telemetry true
+                  o.type :hash, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_HEADERS'
+                  o.default nil
+                  o.env_parser(&Settings.headers_parser('OTEL_EXPORTER_OTLP_METRICS_HEADERS'))
+                end
+
+                option :timeout_millis do |o|
+                  o.type :int, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_TIMEOUT'
+                  o.default 10000
+                end
+
+                option :protocol do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_PROTOCOL'
+                  o.default "http/protobuf"
+                  o.setter(&Settings.normalize_protocol('OTEL_EXPORTER_OTLP_METRICS_PROTOCOL'))
+                end
+              end
+
+              settings :logs do
+                option :enabled do |o|
+                  o.type :bool
+                  o.env 'DD_LOGS_OTEL_ENABLED'
+                  o.default false
+                end
+
+                option :exporter do |o|
+                  o.type :string
+                  o.env 'OTEL_LOGS_EXPORTER'
+                  o.default 'otlp'
+                end
+
+                option :endpoint do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_LOGS_ENDPOINT'
+                  o.default nil
+                end
+
+                option :headers do |o|
+                  o.skip_telemetry true
+                  o.type :hash, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_LOGS_HEADERS'
+                  o.default nil
+                  o.env_parser(&Settings.headers_parser('OTEL_EXPORTER_OTLP_LOGS_HEADERS'))
+                end
+
+                option :timeout_millis do |o|
+                  o.type :int, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_LOGS_TIMEOUT'
+                  o.default 10_000
+                end
+
+                option :protocol do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_LOGS_PROTOCOL'
+                  o.default "http/protobuf"
+                  o.setter(&Settings.normalize_protocol('OTEL_EXPORTER_OTLP_LOGS_PROTOCOL'))
+                end
+
+                option :max_queue_size do |o|
+                  o.type :int
+                  o.env 'OTEL_BLRP_MAX_QUEUE_SIZE'
+                  o.default 2048
+                end
+
+                option :schedule_delay_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_BLRP_SCHEDULE_DELAY'
+                  o.default 1000
+                end
+
+                option :export_timeout_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_BLRP_EXPORT_TIMEOUT'
+                  o.default 30_000
+                end
+
+                option :max_export_batch_size do |o|
+                  o.type :int
+                  o.env 'OTEL_BLRP_MAX_EXPORT_BATCH_SIZE'
+                  o.default 512
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/ext.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenTelemetry
+    module Ext
+      EXPORTER_NONE = 'none'
+    end
+  end
+end

data/lib/datadog/opentelemetry/logs.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+require_relative 'signal_configuration'
+
+module Datadog
+  module OpenTelemetry
+    class Logs
+      include SignalConfiguration
+
+      def self.initialize!(components)
+        new(components).configure_logs_sdk
+        true
+      rescue => exc
+        components.logger.warn(
+          "Failed to initialize OpenTelemetry logs: #{exc.class}: #{exc.message}\n#{(exc.backtrace || []).join("\n")}"
+        )
+        false
+      end
+
+      def initialize(components)
+        @logger = components.logger
+        @settings = components.settings
+        @agent_host = components.agent_settings.hostname
+        @agent_ssl = components.agent_settings.ssl
+      end
+
+      def configure_logs_sdk
+        provider = ::OpenTelemetry.logger_provider
+        provider.shutdown if provider.is_a?(::OpenTelemetry::SDK::Logs::LoggerProvider)
+
+        resource = create_resource
+        provider = ::OpenTelemetry::SDK::Logs::LoggerProvider.new(resource: resource)
+        processor_configured = configure_log_record_processor(provider)
+        ::OpenTelemetry.logger_provider = provider
+
+        disable_log_injection if processor_configured
+      end
+
+      private
+
+      def disable_log_injection
+        @logger.warn('OTel logs enabled: disabling Datadog log injection to prevent duplicate trace correlation fields')
+        Datadog.configure do |c|
+          c.tracing.log_injection = false # steep:ignore
+        end
+      end
+
+      def configure_log_record_processor(provider)
+        exporter_name = @settings.opentelemetry.logs.exporter
+        return false if exporter_name == Ext::EXPORTER_NONE
+
+        configure_otlp_exporter(provider)
+      rescue => e
+        @logger.warn("Failed to configure OTLP logs exporter: #{e.class}: #{e.message}")
+        false
+      end
+
+      def default_logs_endpoint
+        "#{@agent_ssl ? 'https' : 'http'}://#{@agent_host}:4318/v1/logs"
+      end
+
+      def configure_otlp_exporter(provider)
+        require_relative 'sdk/logs_exporter'
+
+        logs_config = @settings.opentelemetry.logs
+        endpoint = config_or_exporter_fallback(
+          signal: :logs,
+          option_name: :endpoint,
+          computed_default: default_logs_endpoint
+        )
+        timeout = config_or_exporter_fallback(signal: :logs, option_name: :timeout_millis)
+        headers = config_or_exporter_fallback(signal: :logs, option_name: :headers)
+        # opentelemetry-logs-sdk only supports http/protobuf protocol as of 0.5.0.
+        config_or_exporter_fallback(signal: :logs, option_name: :protocol)
+
+        exporter = Datadog::OpenTelemetry::SDK::LogsExporter.new(
+          endpoint: endpoint,
+          timeout: timeout / 1000.0,
+          headers: headers
+        )
+
+        processor = ::OpenTelemetry::SDK::Logs::Export::BatchLogRecordProcessor.new(
+          exporter,
+          max_queue_size: logs_config.max_queue_size,
+          schedule_delay: logs_config.schedule_delay_millis,
+          exporter_timeout: logs_config.export_timeout_millis,
+          max_export_batch_size: logs_config.max_export_batch_size
+        )
+        provider.add_log_record_processor(processor)
+        true
+      rescue LoadError => e
+        @logger.warn("Could not load OTLP logs exporter: #{e.class}: #{e.message}")
+        false
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/metrics.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative '../core/configuration/ext'
+require_relative 'ext'
+require_relative 'signal_configuration'
+
+module Datadog
+  module OpenTelemetry
+    class Metrics
+      include SignalConfiguration
+
+      def self.initialize!(components)
+        new(components).configure_metrics_sdk
+        true
+      rescue => exc
+        components.logger.warn("Failed to initialize OpenTelemetry metrics: #{exc.class}: #{exc.message}: #{exc.backtrace.join("\n")}")
+        false
+      end
+
+      def initialize(components)
+        @logger = components.logger
+        @settings = components.settings
+        @agent_host = components.agent_settings.hostname
+        @agent_ssl = components.agent_settings.ssl
+      end
+
+      def configure_metrics_sdk
+        provider = ::OpenTelemetry.meter_provider
+        provider.shutdown if provider.is_a?(::OpenTelemetry::SDK::Metrics::MeterProvider)
+
+        # The OpenTelemetry SDK defaults to cumulative temporality, but Datadog prefers delta temporality.
+        # Here is an example of how this config is applied: https://github.com/open-telemetry/opentelemetry-ruby/blob/1933d4c18e5f5e45c53fa9e902e58aa91e85cc38/metrics_sdk/lib/opentelemetry/sdk/metrics/aggregation/sum.rb#L14
+        if DATADOG_ENV['OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'].nil?
+          ENV['OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'] = 'delta' # rubocop:disable CustomCops/EnvUsageCop
+        end
+
+        resource = create_resource
+        provider = ::OpenTelemetry::SDK::Metrics::MeterProvider.new(resource: resource)
+        configure_metric_reader(provider)
+        ::OpenTelemetry.meter_provider = provider
+      end
+
+      private
+
+      def configure_metric_reader(provider)
+        exporter_name = @settings.opentelemetry.metrics.exporter
+        return if exporter_name == Ext::EXPORTER_NONE
+
+        configure_otlp_exporter(provider)
+      rescue => e
+        @logger.warn("Failed to configure OTLP metrics exporter:  #{e.class}: #{e.message}")
+      end
+
+      def default_metrics_endpoint
+        "#{@agent_ssl ? "https" : "http"}://#{@agent_host}:4318/v1/metrics"
+      end
+
+      def configure_otlp_exporter(provider)
+        require 'opentelemetry/exporter/otlp_metrics'
+        require_relative 'sdk/metrics_exporter'
+
+        metrics_config = @settings.opentelemetry.metrics
+        endpoint = config_or_exporter_fallback(
+          signal: :metrics,
+          option_name: :endpoint,
+          computed_default: default_metrics_endpoint
+        )
+        timeout = config_or_exporter_fallback(signal: :metrics, option_name: :timeout_millis)
+        headers = config_or_exporter_fallback(signal: :metrics, option_name: :headers)
+        # OpenTelemetry SDK only supports http/protobuf protocol.
+        # TODO: Add support for http/json and grpc.
+        # protocol = config_or_exporter_fallback(signal: :metrics, option_name: :protocol)
+        exporter = Datadog::OpenTelemetry::SDK::MetricsExporter.new(
+          endpoint: endpoint,
+          timeout: timeout / 1000.0,
+          headers: headers
+        )
+
+        reader = ::OpenTelemetry::SDK::Metrics::Export::PeriodicMetricReader.new(
+          exporter: exporter,
+          export_interval_millis: metrics_config.export_interval_millis,
+          export_timeout_millis: metrics_config.export_timeout_millis
+        )
+        provider.add_metric_reader(reader)
+      rescue LoadError => e
+        @logger.warn("Could not load OTLP metrics exporter:  #{e.class}: #{e.message}")
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/sdk/configurator.rb

@@ -30,7 +30,71 @@ module Datadog
           [SpanProcessor.new]
         end
 
-        ::OpenTelemetry::SDK::Configurator.prepend(self)
+        # SDK 1.6.0+ calls logs_configuration_hook from configure.
+        # https://github.com/open-telemetry/opentelemetry-ruby/blob/opentelemetry-sdk/v1.6.0/sdk/lib/opentelemetry/sdk/configurator.rb#L152
+        # Older supported SDK versions do not, so we call it explicitly as a fallback.
+        # The flag prevents double-calling on newer SDK versions.
+        def configure
+          @datadog_logs_hook_called = false
+          super
+          logs_configuration_hook unless @datadog_logs_hook_called
+        end
+
+        def metrics_configuration_hook
+          components = Datadog.send(:components)
+          return super unless components.settings.opentelemetry.metrics.enabled
+
+          begin
+            require 'opentelemetry-metrics-sdk'
+          rescue LoadError => exc
+            components.logger.warn("Failed to load OpenTelemetry metrics gems: #{exc.class}: #{exc.message}")
+            return super
+          end
+
+          success = Datadog::OpenTelemetry::Metrics.initialize!(components)
+          super unless success
+        end
+
+        def logs_configuration_hook
+          @datadog_logs_hook_called = true
+          components = Datadog.send(:components)
+          unless components.settings.opentelemetry.logs.enabled
+            super if defined?(super)
+            return
+          end
+
+          begin
+            require 'opentelemetry-logs-sdk'
+          rescue LoadError => exc
+            components.logger.warn("Failed to load OpenTelemetry logs gems: #{exc.class}: #{exc.message}")
+            return
+          end
+
+          success = Datadog::OpenTelemetry::Logs.initialize!(components)
+          unless success
+            components.logger.warn('Falling back to OpenTelemetry default logs configuration')
+            super if defined?(super)
+          end
+        end
+
+        # Prepend to ConfiguratorPatch (not Configurator) so our hook runs first.
+        begin
+          require 'opentelemetry-metrics-sdk' if defined?(OpenTelemetry::SDK) && !defined?(OpenTelemetry::SDK::Metrics::ConfiguratorPatch)
+        rescue LoadError
+        end
+
+        begin
+          require 'opentelemetry-logs-sdk' if defined?(OpenTelemetry::SDK) && !defined?(OpenTelemetry::SDK::Logs::ConfiguratorPatch)
+        rescue LoadError
+        end
+
+        if defined?(::OpenTelemetry::SDK::Metrics::ConfiguratorPatch)
+          ::OpenTelemetry::SDK::Metrics::ConfiguratorPatch.prepend(self) unless ::OpenTelemetry::SDK::Metrics::ConfiguratorPatch.ancestors.include?(self)
+        end
+        if defined?(::OpenTelemetry::SDK::Logs::ConfiguratorPatch)
+          ::OpenTelemetry::SDK::Logs::ConfiguratorPatch.prepend(self) unless ::OpenTelemetry::SDK::Logs::ConfiguratorPatch.ancestors.include?(self)
+        end
+        ::OpenTelemetry::SDK::Configurator.prepend(self) unless ::OpenTelemetry::SDK::Configurator.ancestors.include?(self)
       end
     end
   end

data/lib/datadog/opentelemetry/sdk/id_generator.rb

@@ -1,23 +1,29 @@
 # frozen_string_literal: true
 
+require_relative '../../tracing/utils'
+
 module Datadog
   module OpenTelemetry
     module SDK
-      # Generates Datadog-compatible IDs for OpenTelemetry traces.
-      # OpenTelemetry traces already produce Datadog-compatible IDs.
+      # Generates Datadog-compatible trace IDs for OpenTelemetry spans.
+      #
+      # Reuses the same 128-bit ID format as non-OTel Datadog tracing:
+      #   [32-bit seconds since Epoch | 32 zero bits | 64 random bits]
+      #
+      # When DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED is false the high 64
+      # bits are zero, preserving the OTel 16-byte wire format while keeping
+      # backward compatibility with 64-bit Datadog trace IDs.
       class IdGenerator
         class << self
           include ::OpenTelemetry::Trace
 
-          # Generates a valid trace identifier, a 16-byte string with at least one
-          # non-zero byte.
-          #
-          # @return [String] a valid trace ID.
+          # @return [String] a valid 16-byte trace ID.
           def generate_trace_id
-            loop do
-              id = Random.bytes(8) # DEV: Change to 16 (16*8-byte) when 128-bit trace_id is supported.
-              return id unless id == ::OpenTelemetry::Trace::INVALID_SPAN_ID
-            end
+            trace_id = Tracing::Utils::TraceId.next_id
+            [
+              Tracing::Utils::TraceId.to_high_order(trace_id),
+              Tracing::Utils::TraceId.to_low_order(trace_id),
+            ].pack('Q>Q>')
           end
         end
       end

data/lib/datadog/opentelemetry/sdk/logs_exporter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'opentelemetry/exporter/otlp_logs'
+require_relative '../sdk'
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      class LogsExporter < ::OpenTelemetry::Exporter::OTLP::Logs::LogsExporter
+        METRIC_EXPORT_ATTEMPTS = 'otel.logs_export_attempts'
+        METRIC_EXPORT_SUCCESSES = 'otel.logs_export_successes'
+        METRIC_EXPORT_FAILURES = 'otel.logs_export_failures'
+        METRIC_LOG_RECORDS = 'otel.log_records'
+
+        def export(log_records, timeout: nil)
+          SDK.telemetry_inc(METRIC_EXPORT_ATTEMPTS, 1)
+          SDK.telemetry_inc(METRIC_LOG_RECORDS, log_records.size)
+          result = super
+          metric_name = (result == 0) ? METRIC_EXPORT_SUCCESSES : METRIC_EXPORT_FAILURES
+          SDK.telemetry_inc(metric_name, 1)
+          result
+        rescue => e
+          Datadog.logger.warn("Failed to export OpenTelemetry Logs: #{e.class}: #{e.message}")
+          SDK.telemetry_inc(METRIC_EXPORT_FAILURES, 1)
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/sdk/metrics_exporter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'opentelemetry/exporter/otlp_metrics'
+require_relative '../sdk'
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      class MetricsExporter < ::OpenTelemetry::Exporter::OTLP::Metrics::MetricsExporter
+        METRIC_EXPORT_ATTEMPTS = 'otel.metrics_export_attempts'
+        METRIC_EXPORT_SUCCESSES = 'otel.metrics_export_successes'
+        METRIC_EXPORT_FAILURES = 'otel.metrics_export_failures'
+
+        def export(metrics, timeout: nil)
+          SDK.telemetry_inc(METRIC_EXPORT_ATTEMPTS, 1)
+          result = super
+          metric_name = (result == 0) ? METRIC_EXPORT_SUCCESSES : METRIC_EXPORT_FAILURES
+          SDK.telemetry_inc(metric_name, 1)
+          result
+        rescue => e
+          Datadog.logger.error("Failed to export OpenTelemetry Metrics:  #{e.class}: #{e.message}")
+          SDK.telemetry_inc(METRIC_EXPORT_FAILURES, 1)
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/sdk/propagator.rb

@@ -43,6 +43,15 @@ module Datadog
           digest = @datadog_propagator.extract(carrier)
           return context unless digest
 
+          # Always call continue_trace! so span links are created in restart mode
+          # (when digest.trace_id is nil) before we attempt to build the OTel SpanContext.
+          trace = Tracing.continue_trace!(digest)
+
+          # In restart mode DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT=restart, the extracted
+          # digest carries no trace_id (fresh start). continue_trace! has already recorded
+          # the span link; return the current context so the caller's span starts a new root.
+          return context unless digest.trace_id
+
           # Converts the {Numeric} Datadog id object to OpenTelemetry's byte array format.
           # 128-bit unsigned, big-endian integer
           trace_id = [digest.trace_id >> 64, digest.trace_id & 0xFFFFFFFFFFFFFFFF].pack('Q>Q>')
@@ -70,9 +79,6 @@ module Datadog
           )
 
           span = ::OpenTelemetry::Trace.non_recording_span(span_context)
-
-          trace = Tracing.continue_trace!(digest)
-
           span.datadog_trace = trace
 
           ::OpenTelemetry::Trace.context_with_span(span, parent_context: context)

data/lib/datadog/opentelemetry/sdk/span_processor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'trace/span'
+require_relative '../../core/utils'
 require_relative '../../tracing/span_link'
 require_relative '../../tracing/span_event'
 require_relative '../../tracing/trace_digest'
@@ -101,12 +102,14 @@ module Datadog
 
           unless span.links.nil?
             datadog_span.links = span.links.map do |link|
+              tracestate = link.span_context.tracestate&.to_s
+
               Datadog::Tracing::SpanLink.new(
                 Datadog::Tracing::TraceDigest.new(
                   trace_id: link.span_context.hex_trace_id.to_i(16),
                   span_id: link.span_context.hex_span_id.to_i(16),
                   trace_sampling_priority: (link.span_context.trace_flags&.sampled? ? 1 : 0),
-                  trace_state: link.span_context.tracestate&.to_s,
+                  trace_state: tracestate && ::Datadog::Core::Utils.utf8_encode(tracestate, placeholder: nil),
                   span_remote: link.span_context.remote?,
                 ),
                 attributes: link.attributes

data/lib/datadog/opentelemetry/sdk.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../tracing/ext'
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      TELEMETRY_TAGS = {'protocol' => 'http', 'encoding' => 'protobuf'}.freeze
+
+      def self.telemetry_inc(metric_name, value)
+        telemetry&.inc(Datadog::Tracing::Ext::TELEMETRY_METRICS_NAMESPACE, metric_name, value, tags: TELEMETRY_TAGS)
+      end
+
+      def self.telemetry
+        Datadog.send(:components).telemetry
+      end
+    end
+  end
+end