datadog 2.4.0 → 2.6.0

data/lib/datadog/di.rb

@@ -1,7 +1,15 @@
 # frozen_string_literal: true
 
+require_relative 'di/error'
 require_relative 'di/configuration'
+require_relative 'di/code_tracker'
 require_relative 'di/extensions'
+require_relative 'di/instrumenter'
+require_relative 'di/probe'
+require_relative 'di/redactor'
+require_relative 'di/serializer'
+require_relative 'di/transport'
+require_relative 'di/utils'
 
 module Datadog
   # Namespace for Datadog dynamic instrumentation.
@@ -10,5 +18,40 @@ module Datadog
   module DI
     # Expose DI to global shared objects
     Extensions.activate!
+
+    class << self
+      attr_reader :code_tracker
+
+      # Activates code tracking. Normally this method should be called
+      # when the application starts. If instrumenting third-party code,
+      # code tracking needs to be enabled before the third-party libraries
+      # are loaded. If you definitely will not be instrumenting
+      # third-party libraries, activating tracking after third-party libraries
+      # have been loaded may improve lookup performance.
+      #
+      # TODO test that activating tracker multiple times preserves
+      # existing mappings in the registry
+      def activate_tracking!
+        (@code_tracker ||= CodeTracker.new).start
+      end
+
+      # Deactivates code tracking. In normal usage of DI this method should
+      # never be called, however it is used by DI's test suite to reset
+      # state for individual tests.
+      #
+      # Note that deactivating tracking clears out the registry, losing
+      # the ability to look up files that have been loaded into the process
+      # already.
+      def deactivate_tracking!
+        code_tracker&.stop
+      end
+
+      # Returns whether code tracking is available.
+      # This method should be used instead of querying #code_tracker
+      # because the latter one may be nil.
+      def code_tracking_active?
+        code_tracker&.active? || false
+      end
+    end
   end
 end

data/lib/datadog/profiling/collectors/thread_context.rb

@@ -21,20 +21,18 @@ module Datadog
           endpoint_collection_enabled:,
           timeline_enabled:,
           waiting_for_gvl_threshold_ns:,
-          otel_context_enabled:,
-          allocation_type_enabled: true
+          otel_context_enabled:
         )
           tracer_context_key = safely_extract_context_key_from(tracer)
           self.class._native_initialize(
-            self,
-            recorder,
-            max_frames,
-            tracer_context_key,
-            endpoint_collection_enabled,
-            timeline_enabled,
-            waiting_for_gvl_threshold_ns,
-            otel_context_enabled,
-            allocation_type_enabled,
+            self_instance: self,
+            recorder: recorder,
+            max_frames: max_frames,
+            tracer_context_key: tracer_context_key,
+            endpoint_collection_enabled: endpoint_collection_enabled,
+            timeline_enabled: timeline_enabled,
+            waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
+            otel_context_enabled: otel_context_enabled,
           )
         end
 

data/lib/datadog/profiling/component.rb

@@ -53,6 +53,7 @@ module Datadog
           heap_size_enabled: heap_size_profiling_enabled,
           heap_sample_every: heap_sample_every,
           timeline_enabled: timeline_enabled,
+          heap_clean_after_gc_enabled: settings.profiling.advanced.heap_clean_after_gc_enabled,
         )
         thread_context_collector = build_thread_context_collector(settings, recorder, optional_tracer, timeline_enabled)
         worker = Datadog::Profiling::Collectors::CpuAndWallTimeWorker.new(

data/lib/datadog/profiling/stack_recorder.rb

@@ -9,8 +9,13 @@ module Datadog
     # Methods prefixed with _native_ are implemented in `stack_recorder.c`
     class StackRecorder
       def initialize(
-        cpu_time_enabled:, alloc_samples_enabled:, heap_samples_enabled:, heap_size_enabled:,
-        heap_sample_every:, timeline_enabled:
+        cpu_time_enabled:,
+        alloc_samples_enabled:,
+        heap_samples_enabled:,
+        heap_size_enabled:,
+        heap_sample_every:,
+        timeline_enabled:,
+        heap_clean_after_gc_enabled:
       )
         # This mutex works in addition to the fancy C-level mutexes we have in the native side (see the docs there).
         # It prevents multiple Ruby threads calling serialize at the same time -- something like
@@ -21,13 +26,36 @@ module Datadog
         @no_concurrent_synchronize_mutex = Mutex.new
 
         self.class._native_initialize(
-          self,
-          cpu_time_enabled,
-          alloc_samples_enabled,
-          heap_samples_enabled,
-          heap_size_enabled,
-          heap_sample_every,
-          timeline_enabled,
+          self_instance: self,
+          cpu_time_enabled: cpu_time_enabled,
+          alloc_samples_enabled: alloc_samples_enabled,
+          heap_samples_enabled: heap_samples_enabled,
+          heap_size_enabled: heap_size_enabled,
+          heap_sample_every: heap_sample_every,
+          timeline_enabled: timeline_enabled,
+          heap_clean_after_gc_enabled: heap_clean_after_gc_enabled,
+        )
+      end
+
+      def self.for_testing(
+        cpu_time_enabled: true,
+        alloc_samples_enabled: false,
+        heap_samples_enabled: false,
+        heap_size_enabled: false,
+        heap_sample_every: 1,
+        timeline_enabled: false,
+        heap_clean_after_gc_enabled: true,
+        **options
+      )
+        new(
+          cpu_time_enabled: cpu_time_enabled,
+          alloc_samples_enabled: alloc_samples_enabled,
+          heap_samples_enabled: heap_samples_enabled,
+          heap_size_enabled: heap_size_enabled,
+          heap_sample_every: heap_sample_every,
+          timeline_enabled: timeline_enabled,
+          heap_clean_after_gc_enabled: heap_clean_after_gc_enabled,
+          **options,
         )
       end
 

data/lib/datadog/tracing/component.rb

@@ -73,6 +73,19 @@ module Datadog
           return sampler
         end
 
+        # AppSec events are sent to the backend using traces.
+        # Standalone ASM billing means that we don't want to charge clients for APM traces,
+        # so we want to send the minimum amount of traces possible (idealy only traces that contains security events),
+        # but for features such as API Security, we need to send at least one trace per minute,
+        # to keep the service alive on the backend side.
+        if settings.appsec.standalone.enabled
+          post_sampler = Tracing::Sampling::RuleSampler.new(
+            [Tracing::Sampling::SimpleRule.new(sample_rate: 1.0)],
+            rate_limiter: Datadog::Core::TokenBucket.new(1.0 / 60, 1.0),
+            default_sample_rate: 1.0 / 60
+          )
+        end
+
         # Sampling rules are provided
         if (rules = settings.tracing.sampling.rules)
           post_sampler = Tracing::Sampling::RuleSampler.parse(

data/lib/datadog/tracing/contrib/ethon/easy_patch.rb

@@ -110,6 +110,10 @@ module Datadog
 
               datadog_tag_request
 
+              if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(datadog_trace)
+                datadog_trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+              end
+
               if datadog_configuration[:distributed_tracing]
                 @datadog_original_headers ||= {}
                 Contrib::HTTP.inject(datadog_trace, @datadog_original_headers)

data/lib/datadog/tracing/contrib/excon/middleware.rb

@@ -30,6 +30,9 @@ module Datadog
                 trace = Tracing.active_trace
                 datum[:datadog_span] = span
                 annotate!(span, datum)
+                if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
+                  trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+                end
                 propagate!(trace, span, datum) if distributed_tracing?
 
                 span

data/lib/datadog/tracing/contrib/faraday/middleware.rb

@@ -29,6 +29,9 @@ module Datadog
 
             Tracing.trace(Ext::SPAN_REQUEST, on_error: request_options[:on_error]) do |span, trace|
               annotate!(span, env, request_options)
+              if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
+                trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+              end
               propagate!(trace, span, env) if request_options[:distributed_tracing] && Tracing.enabled?
               app.call(env).on_complete { |resp| handle_response(span, resp, request_options) }
             end

data/lib/datadog/tracing/contrib/grape/endpoint.rb

@@ -267,8 +267,11 @@ module Datadog
               route_path = endpoint.options[:path]
               namespace = endpoint.routes.first && endpoint.routes.first.namespace || ''
 
-              parts = (namespace.split('/') + route_path).reject { |p| p.blank? || p.eql?('/') }
-              parts.join('/').prepend('/')
+              path = (namespace.split('/') + route_path)
+                .reject { |p| p.blank? || p.eql?('/') }
+                .join('/')
+              path.prepend('/') if path[0] != '/'
+              path
             end
 
             def service_name

data/lib/datadog/tracing/contrib/http/circuit_breaker.rb

@@ -29,6 +29,15 @@ module Datadog
           end
 
           def should_skip_distributed_tracing?(client_config)
+            if Datadog.configuration.appsec.standalone.enabled
+              # Skip distributed tracing so that we don't bill distributed traces in case of absence of
+              # upstream ASM event (_dd.p.appsec:1) and no local security event (which sets _dd.p.appsec:1 locally).
+              # If there is an ASM event, we still have to check if distributed tracing is enabled or not
+              return true unless Tracing.active_trace
+
+              return true if Tracing.active_trace.get_tag(Datadog::AppSec::Ext::TAG_DISTRIBUTED_APPSEC_EVENT) != '1'
+            end
+
             return !client_config[:distributed_tracing] if client_config && client_config.key?(:distributed_tracing)
 
             !Datadog.configuration.tracing[:http][:distributed_tracing]

data/lib/datadog/tracing/contrib/http/instrumentation.rb

@@ -35,6 +35,10 @@ module Datadog
                 span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
                 span.resource = req.method
 
+                if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
+                  trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+                end
+
                 if Tracing.enabled? && !Contrib::HTTP.should_skip_distributed_tracing?(client_config)
                   Contrib::HTTP.inject(trace, req)
                 end

data/lib/datadog/tracing/contrib/httpclient/instrumentation.rb

@@ -30,6 +30,10 @@ module Datadog
                   span.service = service_name(host, request_options, client_config)
                   span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
 
+                  if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
+                    trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+                  end
+
                   if Tracing.enabled? && !should_skip_distributed_tracing?(client_config)
                     Contrib::HTTP.inject(trace, req.header)
                   end

data/lib/datadog/tracing/contrib/httprb/instrumentation.rb

@@ -30,6 +30,10 @@ module Datadog
                   span.service = service_name(host, request_options, client_config)
                   span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
 
+                  if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
+                    trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+                  end
+
                   Contrib::HTTP.inject(trace, req) if Tracing.enabled? && !should_skip_distributed_tracing?(client_config)
 
                   # Add additional request specific tags to the span.

data/lib/datadog/tracing/contrib/rails/runner.rb

@@ -58,7 +58,7 @@ module Datadog
           # Capture the executed source code when provided from STDIN.
           def eval(*args)
             span = Datadog::Tracing.active_span
-            if span.name == Ext::SPAN_RUNNER_STDIN
+            if span&.name == Ext::SPAN_RUNNER_STDIN
               source = args[0]
               span.set_tag(
                 Ext::TAG_RUNNER_SOURCE,

data/lib/datadog/tracing/contrib/rest_client/request_patch.rb

@@ -25,6 +25,9 @@ module Datadog
               return super(&block) unless Tracing.enabled?
 
               datadog_trace_request(uri) do |_span, trace|
+                if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
+                  trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+                end
                 Contrib::HTTP.inject(trace, processed_headers) if datadog_configuration[:distributed_tracing]
 
                 super(&block)

data/lib/datadog/tracing/sampling/rule_sampler.rb

@@ -29,7 +29,12 @@ module Datadog
           default_sample_rate: Datadog.configuration.tracing.sampling.default_rate,
           default_sampler: nil
         )
-          @rules = rules
+          @rules = if default_sample_rate && !default_sampler
+                     # Add to the end of the rule list a rule always matches any trace
+                     rules << SimpleRule.new(sample_rate: default_sample_rate)
+                   else
+                     rules
+                   end
           @rate_limiter = if rate_limiter
                             rate_limiter
                           elsif rate_limit
@@ -37,12 +42,9 @@ module Datadog
                           else
                             Core::UnlimitedLimiter.new
                           end
-
           @default_sampler = if default_sampler
                                default_sampler
                              elsif default_sample_rate
-                               # Add to the end of the rule list a rule always matches any trace
-                               @rules << SimpleRule.new(sample_rate: default_sample_rate)
                                nil
                              else
                                # TODO: Simplify .tags access, as `Tracer#tags` can't be arbitrarily changed anymore

data/lib/datadog/tracing/tracer.rb

@@ -406,7 +406,7 @@ module Datadog
             on_error: on_error,
             resource: resource,
             service: service,
-            tags: resolve_tags(tags),
+            tags: resolve_tags(tags, service),
             type: type,
             id: id,
             &block
@@ -420,7 +420,7 @@ module Datadog
             resource: resource,
             service: service,
             start_time: start_time,
-            tags: resolve_tags(tags),
+            tags: resolve_tags(tags, service),
             type: type,
             id: id
           )
@@ -432,15 +432,20 @@ module Datadog
       end
       # rubocop:enable Lint/UnderscorePrefixedVariableName
 
-      def resolve_tags(tags)
-        if @tags.any? && tags
-          # Combine default tags with provided tags,
-          # preferring provided tags.
-          @tags.merge(tags)
-        else
-          # Use provided tags or default tags if none.
-          tags || @tags.dup
+      def resolve_tags(tags, service)
+        merged_tags = if @tags.any? && tags
+                        # Combine default tags with provided tags,
+                        # preferring provided tags.
+                        @tags.merge(tags)
+                      else
+                        # Use provided tags or default tags if none.
+                        tags || @tags.dup
+                      end
+        # Remove version tag if service is not the default service
+        if merged_tags.key?(Core::Environment::Ext::TAG_VERSION) && service != @default_service
+          merged_tags.delete(Core::Environment::Ext::TAG_VERSION)
         end
+        merged_tags
       end
 
       # Manually activate and deactivate the trace, when the span completes.

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

@@ -74,6 +74,10 @@ module Datadog
             # Add container ID, if present.
             container_id = Datadog::Core::Environment::Container.container_id
             headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
+            # Pretend that stats computation are already done by the client
+            if Datadog.configuration.appsec.standalone.enabled
+              headers[Datadog::Core::Transport::Ext::HTTP::HEADER_CLIENT_COMPUTED_STATS] = 'yes'
+            end
           end
         end
 

data/lib/datadog/tracing/workers.rb

@@ -70,7 +70,7 @@ module Datadog
             @run = true
             Datadog.logger.debug { "Starting thread for: #{self}" }
             @worker = Thread.new { perform }
-            @worker.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+            @worker.name = self.class.name
             @worker.thread_variable_set(:fork_safe, true)
 
             nil

data/lib/datadog/tracing/writer.rb

@@ -68,21 +68,6 @@ module Datadog
         end
       end
 
-      # spawns a worker for spans; they share the same transport which is thread-safe
-      # @!visibility private
-      def start_worker
-        @trace_handler = ->(items, transport) { send_spans(items, transport) }
-        @worker = Workers::AsyncTransport.new(
-          transport: @transport,
-          buffer_size: @buff_size,
-          on_trace: @trace_handler,
-          interval: @flush_interval,
-          shutdown_timeout: @shutdown_timeout
-        )
-
-        @worker.start
-      end
-
       # Gracefully shuts down this writer.
       #
       # Once stopped methods calls won't fail, but
@@ -93,19 +78,6 @@ module Datadog
         @mutex_after_fork.synchronize { stop_worker }
       end
 
-      def stop_worker
-        @stopped = true
-
-        return if @worker.nil?
-
-        @worker.stop
-        @worker = nil
-
-        true
-      end
-
-      private :start_worker, :stop_worker
-
       # flush spans to the trace-agent, handles spans only
       # @!visibility private
       def send_spans(traces, transport)
@@ -179,6 +151,32 @@ module Datadog
 
       private
 
+      # spawns a worker for spans; they share the same transport which is thread-safe
+      # @!visibility private
+      def start_worker
+        @trace_handler = ->(items, transport) { send_spans(items, transport) }
+        @worker = Workers::AsyncTransport.new(
+          transport: @transport,
+          buffer_size: @buff_size,
+          on_trace: @trace_handler,
+          interval: @flush_interval,
+          shutdown_timeout: @shutdown_timeout
+        )
+
+        @worker.start
+      end
+
+      def stop_worker
+        @stopped = true
+
+        return if @worker.nil?
+
+        @worker.stop
+        @worker = nil
+
+        true
+      end
+
       def reset_stats!
         @traces_flushed = 0
         @transport.stats.reset!

data/lib/datadog/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datadog
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.6.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-11 00:00:00.000000000 Z
+date: 2024-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -25,47 +25,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: debase-ruby_core_source
+  name: datadog-ruby_core_source
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.3.1
+        version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.3.1
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: libddwaf
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.14.0.0.0
+        version: 1.15.0.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.14.0.0.0
+        version: 1.15.0.0.0
 - !ruby/object:Gem::Dependency
   name: libdatadog
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 12.0.0.1.0
+        version: 14.0.0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 12.0.0.1.0
+        version: 14.0.0.1.0
 description: |
   datadog is Datadog's client library for Ruby. It includes a suite of tools
   which provide visibility into the performance and security of Ruby applications,
@@ -209,6 +209,7 @@ files:
 - lib/datadog/appsec/monitor/reactive/set_user.rb
 - lib/datadog/appsec/processor.rb
 - lib/datadog/appsec/processor/actions.rb
+- lib/datadog/appsec/processor/context.rb
 - lib/datadog/appsec/processor/rule_loader.rb
 - lib/datadog/appsec/processor/rule_merger.rb
 - lib/datadog/appsec/rate_limiter.rb
@@ -224,6 +225,7 @@ files:
 - lib/datadog/appsec/utils/http.rb
 - lib/datadog/appsec/utils/http/media_range.rb
 - lib/datadog/appsec/utils/http/media_type.rb
+- lib/datadog/appsec/utils/trace_operation.rb
 - lib/datadog/auto_instrument.rb
 - lib/datadog/auto_instrument_base.rb
 - lib/datadog/core.rb
@@ -303,6 +305,7 @@ files:
 - lib/datadog/core/remote/worker.rb
 - lib/datadog/core/runtime/ext.rb
 - lib/datadog/core/runtime/metrics.rb
+- lib/datadog/core/semaphore.rb
 - lib/datadog/core/telemetry/component.rb
 - lib/datadog/core/telemetry/emitter.rb
 - lib/datadog/core/telemetry/event.rb
@@ -365,10 +368,15 @@ files:
 - lib/datadog/di/configuration/settings.rb
 - lib/datadog/di/error.rb
 - lib/datadog/di/extensions.rb
+- lib/datadog/di/instrumenter.rb
 - lib/datadog/di/probe.rb
 - lib/datadog/di/probe_builder.rb
+- lib/datadog/di/probe_notification_builder.rb
+- lib/datadog/di/probe_notifier_worker.rb
 - lib/datadog/di/redactor.rb
 - lib/datadog/di/serializer.rb
+- lib/datadog/di/transport.rb
+- lib/datadog/di/utils.rb
 - lib/datadog/kit.rb
 - lib/datadog/kit/appsec/events.rb
 - lib/datadog/kit/enable_core_dumps.rb
@@ -887,8 +895,8 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.4.0/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.4.0
+  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.6.0/CHANGELOG.md
+  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.6.0
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -907,7 +915,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubygems_version: 3.5.17
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications