datadog 2.13.0 → 2.15.0

data/lib/datadog/profiling/http_transport.rb

@@ -20,34 +20,21 @@ module Datadog
             [:agent, agent_settings.url].freeze
           end
 
-        status, result = validate_exporter(exporter_configuration)
+        status, result = self.class._native_validate_exporter(exporter_configuration)
 
         raise(ArgumentError, "Failed to initialize transport: #{result}") if status == :error
       end
 
       def export(flush)
-        status, result = do_export(
-          exporter_configuration: exporter_configuration,
-          upload_timeout_milliseconds: @upload_timeout_milliseconds,
-
-          # why "timespec"?
-          # libdatadog represents time using POSIX's struct timespec, see
-          # https://www.gnu.org/software/libc/manual/html_node/Time-Types.html
-          # aka it represents the seconds part separate from the nanoseconds part
-          start_timespec_seconds: flush.start.tv_sec,
-          start_timespec_nanoseconds: flush.start.tv_nsec,
-          finish_timespec_seconds: flush.finish.tv_sec,
-          finish_timespec_nanoseconds: flush.finish.tv_nsec,
-
-          pprof_file_name: flush.pprof_file_name,
-          pprof_data: flush.pprof_data,
-          code_provenance_file_name: flush.code_provenance_file_name,
-          code_provenance_data: flush.code_provenance_data,
-
-          tags_as_array: flush.tags_as_array,
-          internal_metadata_json: flush.internal_metadata_json,
-
-          info_json: flush.info_json
+        status, result = self.class._native_do_export(
+          exporter_configuration,
+          @upload_timeout_milliseconds,
+          flush,
+          # TODO: This is going to be removed once we move to libdatadog 17
+          flush.start.tv_sec,
+          flush.start.tv_nsec,
+          flush.finish.tv_sec,
+          flush.finish.tv_nsec,
         )
 
         if status == :ok
@@ -77,42 +64,6 @@ module Datadog
         site && api_key && Core::Environment::VariableHelpers.env_to_bool(Profiling::Ext::ENV_AGENTLESS, false)
       end
 
-      def validate_exporter(exporter_configuration)
-        self.class._native_validate_exporter(exporter_configuration)
-      end
-
-      def do_export(
-        exporter_configuration:,
-        upload_timeout_milliseconds:,
-        start_timespec_seconds:,
-        start_timespec_nanoseconds:,
-        finish_timespec_seconds:,
-        finish_timespec_nanoseconds:,
-        pprof_file_name:,
-        pprof_data:,
-        code_provenance_file_name:,
-        code_provenance_data:,
-        tags_as_array:,
-        internal_metadata_json:,
-        info_json:
-      )
-        self.class._native_do_export(
-          exporter_configuration,
-          upload_timeout_milliseconds,
-          start_timespec_seconds,
-          start_timespec_nanoseconds,
-          finish_timespec_seconds,
-          finish_timespec_nanoseconds,
-          pprof_file_name,
-          pprof_data,
-          code_provenance_file_name,
-          code_provenance_data,
-          tags_as_array,
-          internal_metadata_json,
-          info_json,
-        )
-      end
-
       def config_without_api_key
         "#{exporter_configuration[0]}: #{exporter_configuration[1]}"
       end

data/lib/datadog/profiling/stack_recorder.rb

@@ -63,11 +63,11 @@ module Datadog
         status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
 
         if status == :ok
-          start, finish, encoded_pprof, profile_stats = result
+          start, finish, encoded_profile, profile_stats = result
 
           Datadog.logger.debug { "Encoded profile covering #{start.iso8601} to #{finish.iso8601}" }
 
-          [start, finish, encoded_pprof, profile_stats]
+          [start, finish, encoded_profile, profile_stats]
         else
           error_message = result
 
@@ -82,9 +82,9 @@ module Datadog
         status, result = @no_concurrent_synchronize_mutex.synchronize { self.class._native_serialize(self) }
 
         if status == :ok
-          _start, _finish, encoded_pprof = result
+          _start, _finish, encoded_profile = result
 
-          encoded_pprof
+          encoded_profile
         else
           error_message = result
 

data/lib/datadog/profiling.rb

@@ -149,6 +149,7 @@ module Datadog
       require_relative 'profiling/collectors/thread_context'
       require_relative 'profiling/stack_recorder'
       require_relative 'profiling/exporter'
+      require_relative 'profiling/encoded_profile'
       require_relative 'profiling/flush'
       require_relative 'profiling/scheduler'
       require_relative 'profiling/tasks/setup'

data/lib/datadog/tracing/contrib/active_record/integration.rb

@@ -57,7 +57,7 @@ module Datadog
           end
 
           def reset_resolver_cache
-            @resolver&.reset_cache
+            @resolver&.reset_cache if defined?(@resolver)
           end
 
           Contrib::Component.register('activerecord') do |_config|

data/lib/datadog/tracing/contrib/ext.rb

@@ -48,6 +48,7 @@ module Datadog
 
         module Messaging
           TAG_SYSTEM = 'messaging.system'
+          TAG_DESTINATION = 'messaging.destination'
           PEER_SERVICE_SOURCES = Array[Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
             Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
             Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze

data/lib/datadog/tracing/contrib/karafka/configuration/settings.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        module Configuration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            option :service_name
+
+            option :distributed_tracing, default: false, type: :bool
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/karafka/distributed/propagation.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../../../distributed/fetcher'
+require_relative '../../../distributed/propagation'
+require_relative '../../../distributed/b3_multi'
+require_relative '../../../distributed/b3_single'
+require_relative '../../../distributed/datadog'
+require_relative '../../../distributed/none'
+require_relative '../../../distributed/trace_context'
+require_relative '../../../configuration/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        module Distributed
+          # Extracts and injects propagation through Kafka message headers.
+          class Propagation < Tracing::Distributed::Propagation
+            def initialize(
+              propagation_style_inject:,
+              propagation_style_extract:,
+              propagation_extract_first:
+            )
+              super(
+                propagation_styles: {
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_MULTI_HEADER =>
+                    Tracing::Distributed::B3Multi.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER =>
+                    Tracing::Distributed::B3Single.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG =>
+                    Tracing::Distributed::Datadog.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT =>
+                    Tracing::Distributed::TraceContext.new(fetcher: Tracing::Distributed::Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new
+                },
+                propagation_style_inject: propagation_style_inject,
+                propagation_style_extract: propagation_style_extract,
+                propagation_extract_first: propagation_extract_first
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/karafka/ext.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_KARAFKA_ENABLED'
+
+          SPAN_MESSAGE_CONSUME = 'karafka.consume'
+          SPAN_WORKER_PROCESS = 'worker.process'
+
+          TAG_CONSUMER = 'kafka.consumer'
+          TAG_TOPIC = 'kafka.topic'
+          TAG_PARTITION = 'kafka.partition'
+          TAG_OFFSET = 'kafka.offset'
+          TAG_OFFSET_LAG = 'kafka.offset_lag'
+          TAG_MESSAGE_COUNT = 'kafka.message_count'
+          TAG_MESSAGE_KEY = 'kafka.message_key'
+          TAG_SYSTEM = 'kafka'
+
+          TAG_OPERATION_PROCESS_BATCH = 'consumer.process_batch'
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/karafka/integration.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        # Description of Kafka integration
+        class Integration
+          include Contrib::Integration
+
+          # Minimum version of the Karafka library that we support
+          # https://karafka.io/docs/Versions-Lifecycle-and-EOL/#versioning-strategy
+          MINIMUM_VERSION = Gem::Version.new('2.3.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :karafka, auto_patch: false
+
+          def self.version
+            Gem.loaded_specs['karafka']&.version
+          end
+
+          def self.loaded?
+            !defined?(::Karafka).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/karafka/monitor.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        # Custom monitor for Karafka.
+        # Creating a custom monitor, instead of subscribing to an event
+        # (e.g. `Karafka.monitor.subscribe 'worker.processed'`),
+        # is required because event subscriptions cannot wrap the event execution (`yield`).
+        module Monitor
+          TRACEABLE_EVENTS = %w[
+            worker.processed
+          ].freeze
+
+          def instrument(event_id, payload = EMPTY_HASH, &block)
+            return super unless TRACEABLE_EVENTS.include?(event_id)
+
+            Datadog::Tracing.trace(Ext::SPAN_WORKER_PROCESS) do |span|
+              job = payload[:job]
+              job_type = fetch_job_type(job.class)
+              consumer = job.executor.topic.consumer
+
+              action = case job_type
+                       when 'Periodic', 'PeriodicNonBlocking'
+                         'tick'
+                       when 'Shutdown'
+                         'shutdown'
+                       when 'Revoked', 'RevokedNonBlocking'
+                         'revoked'
+                       when 'Idle'
+                         'idle'
+                       when 'Eofed', 'EofedNonBlocking'
+                         'eofed'
+                       else
+                         'consume'
+                       end
+
+              span.resource = "#{consumer}##{action}"
+
+              if action == 'consume'
+                span.set_tag(Ext::TAG_MESSAGE_COUNT, job.messages.count)
+                span.set_tag(Ext::TAG_PARTITION, job.executor.partition)
+                span.set_tag(Ext::TAG_OFFSET, job.messages.first.metadata.offset)
+                span.set_tag(Ext::TAG_CONSUMER, consumer)
+                span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, job.executor.topic.name)
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_SYSTEM)
+              end
+
+              super
+            end
+          end
+
+          private
+
+          def fetch_job_type(job_class)
+            @job_types_cache ||= {}
+            @job_types_cache[job_class] ||= job_class.to_s.split('::').last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/karafka/patcher.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'ext'
+require_relative 'distributed/propagation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Karafka
+        # Patch to add tracing to Karafka::Messages::Messages
+        module MessagesPatch
+          def configuration
+            Datadog.configuration.tracing[:karafka]
+          end
+
+          def propagation
+            @propagation ||= Contrib::Karafka::Distributed::Propagation.new
+          end
+
+          # `each` is the most popular access point to Karafka messages,
+          # but not the only one
+          #  Other access patterns do not have a straightforward tracing avenue
+          # (e.g. `my_batch_operation messages.payloads`)
+          # @see https://github.com/karafka/karafka/blob/b06d1f7c17818e1605f80c2bb573454a33376b40/README.md?plain=1#L29-L35
+          def each(&block)
+            @messages_array.each do |message|
+              if configuration[:distributed_tracing]
+                headers = if message.metadata.respond_to?(:raw_headers)
+                            message.metadata.raw_headers
+                          else
+                            message.metadata.headers
+                          end
+                trace_digest = Karafka.extract(headers)
+                Datadog::Tracing.continue_trace!(trace_digest) if trace_digest
+              end
+
+              Tracing.trace(Ext::SPAN_MESSAGE_CONSUME) do |span|
+                span.set_tag(Ext::TAG_OFFSET, message.metadata.offset)
+                span.set_tag(Contrib::Ext::Messaging::TAG_DESTINATION, message.topic)
+                span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_SYSTEM)
+
+                span.resource = message.topic
+
+                yield message
+              end
+            end
+          end
+        end
+
+        # Patcher enables patching of 'karafka' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative 'monitor'
+
+            ::Karafka::Instrumentation::Monitor.prepend(Monitor)
+            ::Karafka::Messages::Messages.prepend(MessagesPatch)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/karafka.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'component'
+require_relative 'karafka/integration'
+require_relative 'karafka/distributed/propagation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # `Karafka` integration public API
+      module Karafka
+        def self.inject(digest, data)
+          raise 'Please invoke Datadog.configure at least once before calling this method' unless @propagation
+
+          @propagation.inject!(digest, data)
+        end
+
+        def self.extract(data)
+          raise 'Please invoke Datadog.configure at least once before calling this method' unless @propagation
+
+          @propagation.extract(data)
+        end
+
+        Contrib::Component.register('karafka') do |config|
+          tracing = config.tracing
+          tracing.propagation_style
+
+          @propagation = Karafka::Distributed::Propagation.new(
+            propagation_style_inject: tracing.propagation_style_inject,
+            propagation_style_extract: tracing.propagation_style_extract,
+            propagation_extract_first: tracing.propagation_extract_first
+          )
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/opensearch/configuration/settings.rb

@@ -46,6 +46,23 @@ module Datadog
               o.type :string, nilable: true
               o.env Ext::ENV_PEER_SERVICE
             end
+
+            option :resource_pattern do |o|
+              o.type :string
+              o.env Ext::ENV_RESOURCE_PATTERN
+              o.default Ext::DEFAULT_RESOURCE_PATTERN
+              o.setter do |value|
+                next value if Ext::VALID_RESOURCE_PATTERNS.include?(value)
+
+                Datadog.logger.warn(
+                  "Invalid resource pattern: #{value}. " \
+                  "Supported values are: #{Ext::VALID_RESOURCE_PATTERNS.join(' | ')}. " \
+                  "Using default value: #{Ext::DEFAULT_RESOURCE_PATTERN}."
+                )
+
+                Ext::DEFAULT_RESOURCE_PATTERN
+              end
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/opensearch/ext.rb

@@ -13,6 +13,15 @@ module Datadog
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_OPENSEARCH_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_OPENSEARCH_ANALYTICS_SAMPLE_RATE'
+          ENV_RESOURCE_PATTERN = 'DD_TRACE_OPENSEARCH_RESOURCE_PATTERN'
+          ABSOLUTE_RESOURCE_PATTERN = 'absolute'
+          RELATIVE_RESOURCE_PATTERN = 'relative'
+          VALID_RESOURCE_PATTERNS = [
+            ABSOLUTE_RESOURCE_PATTERN,
+            RELATIVE_RESOURCE_PATTERN
+          ].freeze
+          # Default should be changed to RELATIVE in 3.0 to match the Elasticsearch integration
+          DEFAULT_RESOURCE_PATTERN = ABSOLUTE_RESOURCE_PATTERN
           DEFAULT_PEER_SERVICE_NAME = 'opensearch'
           SPAN_QUERY = 'opensearch.query'
           SPAN_TYPE_QUERY = 'opensearch'

data/lib/datadog/tracing/contrib/opensearch/patcher.rb

@@ -77,7 +77,11 @@ module Datadog
                   span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, host) if host
 
                   # Define span resource
-                  quantized_url = OpenSearch::Quantize.format_url(url)
+                  quantized_url = if datadog_configuration[:resource_pattern] == Ext::RELATIVE_RESOURCE_PATTERN
+                                    OpenSearch::Quantize.format_url(url.path)
+                                  else # Default to Ext::ABSOLUTE_RESOURCE_PATTERN
+                                    OpenSearch::Quantize.format_url(url)
+                                  end
                   span.resource = "#{method} #{quantized_url}"
                   Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
                 rescue StandardError => e

data/lib/datadog/tracing/contrib/rack/request_queue.rb

@@ -17,7 +17,7 @@ module Datadog
 
           module_function
 
-          def get_request_start(env, now = Time.now.utc)
+          def get_request_start(env, now = Core::Utils::Time.now.utc)
             header = env[REQUEST_START] || env[QUEUE_START]
             return unless header
 

data/lib/datadog/tracing/contrib/sidekiq/server_tracer.rb

@@ -61,7 +61,7 @@ module Datadog
               span.set_tag(Ext::TAG_JOB_RETRY_COUNT, job['retry_count'])
               span.set_tag(Ext::TAG_JOB_QUEUE, job['queue'])
               span.set_tag(Ext::TAG_JOB_WRAPPER, job['class']) if job['wrapped']
-              span.set_tag(Ext::TAG_JOB_DELAY, 1000.0 * (Time.now.utc.to_f - job['enqueued_at'].to_f))
+              span.set_tag(Ext::TAG_JOB_DELAY, 1000.0 * (Core::Utils::Time.now.utc.to_f - job['enqueued_at'].to_f))
 
               args = job['args']
               if args && !args.empty?

data/lib/datadog/tracing/contrib.rb

@@ -55,6 +55,7 @@ require_relative 'contrib/httpclient/integration'
 require_relative 'contrib/httprb/integration'
 require_relative 'contrib/integration'
 require_relative 'contrib/kafka/integration'
+require_relative 'contrib/karafka'
 require_relative 'contrib/lograge/integration'
 require_relative 'contrib/mongodb/integration'
 require_relative 'contrib/mysql2/integration'

data/lib/datadog/tracing/span_event.rb

@@ -33,7 +33,7 @@ module Datadog
 
         # OpenTelemetry SDK stores span event timestamps in nanoseconds (not seconds).
         # We will do the same here to avoid unnecessary conversions and inconsistencies.
-        @time_unix_nano = time_unix_nano || (Time.now.to_r * 1_000_000_000).to_i
+        @time_unix_nano = time_unix_nano || (Core::Utils::Time.now.to_r * 1_000_000_000).to_i
       end
 
       # Converts the span event into a hash to be used by with the span tag serialization

data/lib/datadog/tracing/transport/http/client.rb

@@ -14,7 +14,7 @@ module Datadog
 
           attr_reader :api, :logger
 
-          def initialize(api, logger)
+          def initialize(api, logger: Datadog.logger)
             @api = api
             @logger = logger
           end

data/lib/datadog/tracing/transport/http.rb

@@ -18,7 +18,7 @@ module Datadog
         # Pass a block to override any settings.
         def default(
           agent_settings:,
-          logger:,
+          logger: Datadog.logger,
           api_version: nil,
           headers: nil
         )

data/lib/datadog/tracing/transport/traces.rb

@@ -51,7 +51,7 @@ module Datadog
           # @param encoder [Datadog::Core::Encoding::Encoder]
           # @param logger [Datadog::Core::Logger]
           # @param max_size [String] maximum acceptable payload size
-          def initialize(encoder, logger, native_events_supported:, max_size: DEFAULT_MAX_PAYLOAD_SIZE)
+          def initialize(encoder, logger:, native_events_supported:, max_size: DEFAULT_MAX_PAYLOAD_SIZE)
             @encoder = encoder
             @logger = logger
             @native_events_supported = native_events_supported
@@ -80,7 +80,12 @@ module Datadog
           private
 
           def encode_one(trace)
-            encoded = Encoder.encode_trace(encoder, trace, logger, native_events_supported: @native_events_supported)
+            encoded = Encoder.encode_trace(
+              encoder,
+              trace,
+              logger: logger,
+              native_events_supported: @native_events_supported
+            )
 
             if encoded.size > max_size
               # This single trace is too large, we can't flush it
@@ -98,7 +103,7 @@ module Datadog
         module Encoder
           module_function
 
-          def encode_trace(encoder, trace, logger, native_events_supported:)
+          def encode_trace(encoder, trace, logger:, native_events_supported:)
             # Format the trace for transport
             TraceFormatter.format!(trace)
 
@@ -121,7 +126,7 @@ module Datadog
         class Transport
           attr_reader :client, :apis, :default_api, :current_api_id, :logger
 
-          def initialize(apis, default_api, logger)
+          def initialize(apis, default_api, logger: Datadog.logger)
             @apis = apis
             @default_api = default_api
             @logger = logger
@@ -133,7 +138,7 @@ module Datadog
             encoder = current_api.encoder
             chunker = Datadog::Tracing::Transport::Traces::Chunker.new(
               encoder,
-              logger,
+              logger: logger,
               native_events_supported: native_events_supported?
             )
 
@@ -194,7 +199,7 @@ module Datadog
             raise UnknownApiVersionError, api_id unless apis.key?(api_id)
 
             @current_api_id = api_id
-            @client = HTTP::Client.new(current_api, logger)
+            @client = HTTP::Client.new(current_api, logger: logger)
           end
 
           # Queries the agent for native span events serialization support.

data/lib/datadog/version.rb

@@ -3,7 +3,7 @@
 module Datadog
   module VERSION
     MAJOR = 2
-    MINOR = 13
+    MINOR = 15
     PATCH = 0
     PRE = nil
     BUILD = nil

data/lib/datadog.rb

@@ -9,5 +9,5 @@ require_relative 'datadog/profiling'
 require_relative 'datadog/appsec'
 # Line probes will not work on Ruby < 2.6 because of lack of :script_compiled
 # trace point. Only load DI on supported Ruby versions.
-require_relative 'datadog/di' if RUBY_VERSION >= '2.6'
+require_relative 'datadog/di' if RUBY_VERSION >= '2.6' && RUBY_ENGINE != 'jruby'
 require_relative 'datadog/kit'