datadog 2.32.0 → 2.33.0

data/lib/datadog/symbol_database/scope_batcher.rb

@@ -0,0 +1,280 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Datadog
+  module SymbolDatabase
+    # Batches extracted scopes and triggers uploads at appropriate times.
+    #
+    # Implements two upload triggers:
+    # 1. Size-based: Immediate upload when 400 scopes collected (MAX_SCOPES)
+    # 2. Time-based: Upload after 1 second of inactivity (debounce timer, not periodic)
+    #
+    # Also provides:
+    # - Deduplication: Tracks uploaded module names to prevent re-uploads
+    # - File limiting: Stops after 10,000 files to prevent runaway extraction
+    # - Thread safety: Mutex-protected state for concurrent access
+    #
+    # Timer implementation: A single long-lived thread waits on a ConditionVariable
+    # with a timeout. Each add_scope signals the CV to reset the deadline. When the
+    # timeout expires without a signal, the timer fires and flushes the batch.
+    # This avoids creating/destroying a thread per add_scope call.
+    #
+    # Flow: Extractor → add_scope → (batch or timer) → Uploader
+    # Created by: Component (during initialization)
+    # Calls: Uploader.upload_scopes when batch full or timer fires
+    #
+    # @api private
+    class ScopeBatcher
+      # Maximum scopes per batch before triggering immediate upload.
+      # This matches the batch size used in Java and Python tracers to ensure
+      # consistent upload behavior across languages.
+      MAX_SCOPES = 400
+      INACTIVITY_TIMEOUT = 1.0  # seconds
+      # Maximum unique files to track before stopping extraction.
+      # This prevents runaway memory usage in applications with very large
+      # numbers of loaded classes (e.g., heavily modularized Rails apps).
+      MAX_FILES = 10_000
+      # Seconds to wait for the timer thread to exit when joining during
+      # shutdown or reset. Bounded so a misbehaving thread cannot hang the
+      # caller indefinitely.
+      TIMER_JOIN_TIMEOUT = 5
+
+      # Initialize batching context.
+      # @param uploader [Uploader] Uploader instance for triggering uploads
+      # @param logger [Logger] Logger for diagnostics
+      # @param on_upload [Proc, nil] Optional callback called after upload (for testing)
+      # @param timer_enabled [Boolean] Enable async timer (default true, false for tests)
+      def initialize(uploader, logger:, on_upload: nil, timer_enabled: true)
+        @uploader = uploader
+        @logger = logger
+        @on_upload = on_upload
+        @timer_enabled = timer_enabled
+        @scopes = []
+        @mutex = Mutex.new
+        @file_count = 0
+        @uploaded_modules = Set.new
+
+        # Timer state: single long-lived thread + ConditionVariable for debounce.
+        # @timer_signaled is set to true on each add_scope and cleared by the timer
+        # thread after waking. This flag is needed because ConditionVariable#wait
+        # does not distinguish signal vs timeout on Ruby < 3.2 (returns self in both
+        # cases). The flag gives a portable way to detect whether the wakeup was a
+        # signal (reset deadline) or a timeout (fire the timer).
+        @timer_cv = ConditionVariable.new
+        @timer_thread = nil
+        @timer_stopped = false
+        @timer_signaled = false
+      end
+
+      # Add a scope to the batch.
+      # Triggers immediate upload if batch reaches 400 scopes.
+      # Resets inactivity timer if batch not full.
+      # @param scope [Scope] The scope to add
+      # @return [void]
+      def add_scope(scope)
+        # @type var scopes_to_upload: ::Array[Scope]?
+        scopes_to_upload = nil
+
+        @mutex.synchronize do
+          # Check file limit (counts only unique accepted files; duplicates are
+          # filtered by the dedup check below and do not consume the budget).
+          if @file_count >= MAX_FILES
+            @logger.debug { "symdb: file limit (#{MAX_FILES}) reached, ignoring scope: #{scope.name}" }
+            return
+          end
+
+          # Check if already uploaded — duplicates do not count toward MAX_FILES
+          # so a re-extraction scenario does not exhaust the budget for unique scopes.
+          if @uploaded_modules.include?(scope.name)
+            @logger.trace { "symdb: skipping #{scope.name}: already uploaded" }
+            return
+          end
+
+          @uploaded_modules.add(scope.name)
+          @file_count += 1
+
+          # Add the scope
+          @scopes << scope
+
+          # Check if batch size reached (AFTER adding)
+          if @scopes.size >= MAX_SCOPES
+            # Prepare for upload (clear within mutex)
+            scopes_to_upload = @scopes.dup
+            @scopes.clear
+          end
+
+          # Signal the timer thread to reset its inactivity deadline.
+          # If batch was full, this is harmless — the timer will just
+          # re-check and find an empty batch if it fires.
+          ensure_timer_running
+          @timer_signaled = true
+          @timer_cv.signal
+        end
+
+        # Upload outside mutex (if batch was full)
+        perform_upload(scopes_to_upload) if scopes_to_upload
+      rescue => e
+        @logger.debug { "symdb: failed to add scope: #{e.class}: #{e.message}" }
+        # Don't propagate, continue operation
+      end
+
+      # Force upload of current batch immediately.
+      # @return [void]
+      def flush
+        # @type var scopes_to_upload: ::Array[Scope]?
+        scopes_to_upload = nil
+
+        @mutex.synchronize do
+          return if @scopes.empty?
+
+          scopes_to_upload = @scopes.dup
+          @scopes.clear
+        end
+
+        perform_upload(scopes_to_upload)
+      end
+
+      # Shutdown and upload remaining scopes.
+      # @return [void]
+      def shutdown
+        # @type var scopes_to_upload: ::Array[Scope]?
+        scopes_to_upload = nil
+        # @type var thread_to_join: ::Thread?
+        thread_to_join = nil
+
+        @mutex.synchronize do
+          @timer_stopped = true
+          @timer_cv.signal  # Wake the timer thread so it exits
+
+          # Capture the timer thread under the mutex so a concurrent add_scope
+          # cannot create a new thread that we'd accidentally orphan when we
+          # nil the field below.
+          thread_to_join = @timer_thread
+          @timer_thread = nil
+
+          scopes_to_upload = @scopes.dup
+          @scopes.clear
+        end
+
+        # Join the timer thread outside the mutex.
+        # The thread checks @timer_stopped and exits when signaled.
+        thread_to_join&.join(TIMER_JOIN_TIMEOUT)
+
+        # Upload outside mutex
+        perform_upload(scopes_to_upload) unless scopes_to_upload.nil? || scopes_to_upload.empty?
+      end
+
+      # Check if scopes are pending upload.
+      # @return [Boolean] true if scopes waiting in batch
+      def scopes_pending?
+        @mutex.synchronize { @scopes.any? }
+      end
+
+      # Get current batch size.
+      # @return [Integer] Number of scopes in current batch
+      def size
+        @mutex.synchronize { @scopes.size }
+      end
+
+      private
+
+      # Reset state. Private so production code cannot accidentally invoke it;
+      # tests call via +send(:reset)+.
+      # @return [void]
+      def reset
+        # @type var thread_to_join: ::Thread?
+        thread_to_join = nil
+
+        @mutex.synchronize do
+          @scopes.clear
+          @timer_stopped = true
+          @timer_cv.signal
+          @file_count = 0
+          @uploaded_modules.clear
+
+          # Capture under the mutex (see shutdown for rationale).
+          thread_to_join = @timer_thread
+          @timer_thread = nil
+        end
+
+        thread_to_join&.join(TIMER_JOIN_TIMEOUT)
+
+        # Allow timer to be restarted after reset
+        @mutex.synchronize do
+          @timer_stopped = false
+          @timer_signaled = false
+        end
+      end
+
+      # Start the timer thread if not already running.
+      # Must be called from within @mutex.synchronize.
+      # @return [void]
+      def ensure_timer_running
+        return unless @timer_enabled
+        return if @timer_thread&.alive?
+
+        @timer_stopped = false
+        @timer_signaled = false
+
+        @timer_thread = Thread.new do
+          timer_loop
+        end
+      end
+
+      # Timer thread main loop. Waits on the ConditionVariable with a timeout.
+      # Each signal resets the deadline (debounce). When the wait times out
+      # (no signal within INACTIVITY_TIMEOUT), the batch is flushed.
+      #
+      # Uses @timer_signaled flag instead of ConditionVariable#wait return value
+      # because Ruby < 3.2 returns self for both signal and timeout (no way to
+      # distinguish). The flag is set by add_scope before signaling, and cleared
+      # by the timer thread after waking.
+      # @return [void]
+      def timer_loop
+        loop do
+          should_flush = false
+
+          @mutex.synchronize do
+            return if @timer_stopped
+
+            @timer_signaled = false
+            @timer_cv.wait(@mutex, INACTIVITY_TIMEOUT)
+
+            return if @timer_stopped
+
+            if @timer_signaled
+              # Woke up because add_scope signaled — loop back to re-wait with
+              # a fresh timeout. This implements the debounce: the timeout resets
+              # on every scope addition.
+              next # steep:ignore BreakTypeMismatch
+            end
+
+            # Timed out (no signal within INACTIVITY_TIMEOUT). If there are
+            # scopes pending, flush them. Otherwise, loop back and wait again.
+            should_flush = !@scopes.empty?
+          end
+
+          if should_flush
+            flush
+          end
+        end
+      rescue => e
+        @logger.debug { "symdb: timer thread error: #{e.class}: #{e.message}" }
+      end
+
+      # Perform upload via uploader.
+      # @param scopes [Array<Scope>] Scopes to upload
+      # @return [void]
+      def perform_upload(scopes)
+        return if scopes.nil? || scopes.empty?
+
+        @uploader.upload_scopes(scopes)
+        @on_upload&.call(scopes)  # Notify tests after upload
+      rescue => e
+        @logger.debug { "symdb: upload failed: #{e.class}: #{e.message}" }
+        # Don't propagate, uploader handles retries
+      end
+    end
+  end
+end

data/lib/datadog/symbol_database/service_version.rb

@@ -20,8 +20,8 @@ module Datadog
 
       # Initialize a new ServiceVersion
       # @param service [String] Service name (required, from DD_SERVICE)
-      # @param env [String] Environment (from DD_ENV, defaults to "none")
-      # @param version [String] Version (from DD_VERSION, defaults to "none")
+      # @param env [String, nil] Environment (from DD_ENV, passed through unchanged)
+      # @param version [String, nil] Version (from DD_VERSION, passed through unchanged)
       # @param scopes [Array<Scope>] Top-level scopes (required)
       # @raise [ArgumentError] if service empty or scopes not an array
       def initialize(service:, env:, version:, scopes:)
@@ -29,8 +29,8 @@ module Datadog
         raise ArgumentError, 'scopes must be an array' unless scopes.is_a?(Array)
 
         @service = service
-        @env = env.to_s.empty? ? 'none' : env.to_s
-        @version = version.to_s.empty? ? 'none' : version.to_s
+        @env = env
+        @version = version
         @language = 'ruby'
         @scopes = scopes
       end

data/lib/datadog/symbol_database/uploader.rb

@@ -59,6 +59,9 @@ module Datadog
         json_data = build_symbol_payload(scopes)
         compressed_data = Zlib.gzip(json_data)
 
+        # Emitted unconditionally so the rare oversized case is observable.
+        @telemetry&.distribution('tracers', 'symbol_database.payload_size', compressed_data.bytesize)
+
         # Symbols for very large applications (>50MB after gzip) are dropped:
         # the upload is skipped and the customer sees no autocomplete /
         # symbol probe results for those classes. Java handles the same case

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

@@ -54,6 +54,12 @@ module Datadog
               o.type :string, nilable: true
             end
 
+            option :inferred_proxy_enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_INFERRED_PROXY_ENABLED
+              o.default false
+            end
+
             option :web_service_name, default: Ext::DEFAULT_PEER_WEBSERVER_SERVICE_NAME, type: :string
           end
         end

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

@@ -9,6 +9,7 @@ module Datadog
         module Ext
           ENV_ENABLED = 'DD_TRACE_RACK_ENABLED'
           ENV_DISTRIBUTED_TRACING = 'DD_TRACE_RACK_DISTRIBUTED_TRACING'
+          ENV_INFERRED_PROXY_ENABLED = 'DD_TRACE_INFERRED_PROXY_SERVICES_ENABLED'
           # @!visibility private
           ENV_ANALYTICS_ENABLED = 'DD_TRACE_RACK_ANALYTICS_ENABLED'
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_RACK_ANALYTICS_SAMPLE_RATE'
@@ -24,6 +25,32 @@ module Datadog
           TAG_OPERATION_HTTP_SERVER_QUEUE = 'queue'
           WEBSERVER_APP = 'webserver'
           DEFAULT_PEER_WEBSERVER_SERVICE_NAME = 'web-server'
+
+          # @!visibility private
+          HEADER_X_DD_PROXY = 'HTTP_X_DD_PROXY'
+          HEADER_X_DD_PROXY_REQUEST_TIME_MS = 'HTTP_X_DD_PROXY_REQUEST_TIME_MS'
+          HEADER_X_DD_PROXY_PATH = 'HTTP_X_DD_PROXY_PATH'
+          HEADER_X_DD_PROXY_RESOURCE_PATH = 'HTTP_X_DD_PROXY_RESOURCE_PATH'
+          HEADER_X_DD_PROXY_HTTPMETHOD = 'HTTP_X_DD_PROXY_HTTPMETHOD'
+          HEADER_X_DD_PROXY_DOMAIN_NAME = 'HTTP_X_DD_PROXY_DOMAIN_NAME'
+          HEADER_X_DD_PROXY_STAGE = 'HTTP_X_DD_PROXY_STAGE'
+          HEADER_X_DD_PROXY_ACCOUNT_ID = 'HTTP_X_DD_PROXY_ACCOUNT_ID'
+          HEADER_X_DD_PROXY_API_ID = 'HTTP_X_DD_PROXY_API_ID'
+          HEADER_X_DD_PROXY_REGION = 'HTTP_X_DD_PROXY_REGION'
+          HEADER_X_DD_PROXY_USER = 'HTTP_X_DD_PROXY_USER'
+
+          PROXY_AWS_APIGATEWAY = 'aws-apigateway'
+          PROXY_AWS_HTTPAPI = 'aws-httpapi'
+
+          SPAN_AWS_APIGATEWAY = 'aws.apigateway'
+          SPAN_AWS_HTTPAPI = 'aws.httpapi'
+
+          PROXY_SPAN_NAMES = {
+            PROXY_AWS_APIGATEWAY => SPAN_AWS_APIGATEWAY,
+            PROXY_AWS_HTTPAPI => SPAN_AWS_HTTPAPI,
+          }.freeze
+
+          TAG_INFERRED_SPAN = '_dd.inferred_span'
         end
       end
     end

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

@@ -13,7 +13,11 @@ module Datadog
         module TraceProxyMiddleware
           module_function
 
-          def call(env, configuration)
+          def call(env, configuration, &block)
+            if configuration[:inferred_proxy_enabled] &&
+                (proxy_type = env[Ext::HEADER_X_DD_PROXY]) && !proxy_type.empty?
+              return call_with_inferred_proxy(env, proxy_type, &block)
+            end
             return yield unless configuration[:request_queuing]
 
             # parse the request queue time
@@ -51,6 +55,118 @@ module Datadog
             queue_span&.finish
             request_span&.finish
           end
+
+          # Creates a virtual parent span representing the upstream proxy
+          # that wraps the actual request processing.
+          #
+          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          def call_with_inferred_proxy(env, proxy_type)
+            span_name = Ext::PROXY_SPAN_NAMES[proxy_type]
+            return yield unless span_name
+
+            request_time_ms = env[Ext::HEADER_X_DD_PROXY_REQUEST_TIME_MS].to_f
+            return yield unless request_time_ms.positive?
+
+            path = env[Ext::HEADER_X_DD_PROXY_PATH]
+            stage = env[Ext::HEADER_X_DD_PROXY_STAGE]
+            domain = env[Ext::HEADER_X_DD_PROXY_DOMAIN_NAME]
+            http_method = env[Ext::HEADER_X_DD_PROXY_HTTPMETHOD]
+            resource_path = env[Ext::HEADER_X_DD_PROXY_RESOURCE_PATH]
+
+            # NOTE: resource_path is the parameterized route (e.g. /users/{id}) vs literal path
+            resource = "#{http_method} #{resource_path || path}" if http_method
+
+            inferred_span = Tracing.trace(
+              span_name,
+              service: domain,
+              type: Tracing::Metadata::Ext::AppTypes::TYPE_WEB,
+              start_time: Time.at(request_time_ms / 1_000),
+            )
+            inferred_span.resource = resource if resource
+            inferred_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, proxy_type)
+            inferred_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
+            inferred_span.set_tag('stage', stage) if stage
+            inferred_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, http_method) if http_method
+            inferred_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, "https://#{domain}#{path}") if domain && path
+            inferred_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE, resource_path) if resource_path
+            inferred_span.set_metric(Ext::TAG_INFERRED_SPAN, 1)
+
+            set_optional_tags(inferred_span, env: env, proxy_type: proxy_type)
+
+            yield
+          # NOTE: The underlying {Rack::TraceMiddleware} rescues {Exception}
+          #       to tag the request span with error details.
+          #       We must propagate errors to the inferred proxy parent span.
+          rescue Exception => e # rubocop:disable Lint/RescueException
+            inferred_span&.set_error(e)
+            raise
+          ensure
+            if inferred_span
+              propagate_request_span_tags(inferred_span, env: env)
+
+              if (trace = Tracing.active_trace) && resource
+                trace.resource = resource
+              end
+
+              inferred_span.finish
+            end
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+          # Sets cloud provider metadata and constructs the resource ARN.
+          #
+          # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          def set_optional_tags(span, env:, proxy_type:)
+            api_id = env[Ext::HEADER_X_DD_PROXY_API_ID]
+            region = env[Ext::HEADER_X_DD_PROXY_REGION]
+
+            # API Gateway v1 sends region as a single-quoted string
+            region = region.delete("'") if region
+
+            span.set_tag('apiid', api_id) if api_id
+            span.set_tag('region', region) if region
+
+            if (account_id = env[Ext::HEADER_X_DD_PROXY_ACCOUNT_ID])
+              span.set_tag('account_id', account_id)
+            end
+
+            if (user = env[Ext::HEADER_X_DD_PROXY_USER])
+              span.set_tag('aws_user', user)
+            end
+
+            if api_id && region
+              # NOTE: Update this when adding non-AWS proxy types.
+              restapi_prefix = (proxy_type == Ext::PROXY_AWS_APIGATEWAY) ? 'restapis' : 'apis'
+              span.set_tag('dd_resource_key', "arn:aws:apigateway:#{region}::/#{restapi_prefix}/#{api_id}")
+            end
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+          # Propagates response-level and security tags from the request span to
+          # the inferred parent.
+          def propagate_request_span_tags(span, env:)
+            rack_span = env[Ext::RACK_ENV_REQUEST_SPAN]
+            return unless rack_span
+
+            if (status_code = rack_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE))
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, status_code)
+              span.status = rack_span.status
+            end
+
+            if (user_agent = rack_span.get_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT))
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_USER_AGENT, user_agent)
+            end
+
+            # NOTE: Tracing shouldn't know about AppSec tags.
+            if (appsec_enabled = rack_span.get_metric('_dd.appsec.enabled'))
+              span.set_metric('_dd.appsec.enabled', appsec_enabled)
+            end
+
+            # NOTE: Tracing shouldn't know about AppSec tags.
+            if (appsec_json = rack_span.get_tag('_dd.appsec.json'))
+              span.set_tag('_dd.appsec.json', appsec_json)
+            end
+          end
         end
       end
     end

data/lib/datadog/tracing/tracer.rb

@@ -372,9 +372,7 @@ module Datadog
       end
 
       def build_trace(digest, auto_finish)
-        # Resolve hostname if configured
-        hostname = Core::Environment::Socket.hostname if Datadog.configuration.tracing.report_hostname
-        hostname = (hostname && !hostname.empty?) ? hostname : nil
+        hostname = Core::Environment::Socket.resolved_hostname(Datadog.configuration)
 
         if digest
           sampling_priority = if propagate_sampling_priority?(upstream_tags: digest.trace_distributed_tags)

data/lib/datadog/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datadog
 version: !ruby/object:Gem::Version
-  version: 2.32.0
+  version: 2.33.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-08 00:00:00.000000000 Z
+date: 2026-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -64,14 +64,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 30.0.0.1.0
+        version: 33.0.0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 30.0.0.1.0
+        version: 33.0.0.1.0
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -124,8 +124,8 @@ files:
 - ext/LIBDATADOG_DEVELOPMENT.md
 - ext/datadog_profiling_native_extension/NativeExtensionDesign.md
 - ext/datadog_profiling_native_extension/clock_id.h
+- ext/datadog_profiling_native_extension/clock_id_from_mach.c
 - ext/datadog_profiling_native_extension/clock_id_from_pthread.c
-- ext/datadog_profiling_native_extension/clock_id_noop.c
 - ext/datadog_profiling_native_extension/collectors_cpu_and_wall_time_worker.c
 - ext/datadog_profiling_native_extension/collectors_discrete_dynamic_sampler.c
 - ext/datadog_profiling_native_extension/collectors_discrete_dynamic_sampler.h
@@ -187,10 +187,17 @@ files:
 - lib/datadog.rb
 - lib/datadog/ai_guard.rb
 - lib/datadog/ai_guard/api_client.rb
+- lib/datadog/ai_guard/autoload.rb
 - lib/datadog/ai_guard/component.rb
 - lib/datadog/ai_guard/configuration.rb
 - lib/datadog/ai_guard/configuration/ext.rb
+- lib/datadog/ai_guard/contrib/auto_instrument.rb
 - lib/datadog/ai_guard/contrib/integration.rb
+- lib/datadog/ai_guard/contrib/rack/integration.rb
+- lib/datadog/ai_guard/contrib/rack/patcher.rb
+- lib/datadog/ai_guard/contrib/rack/request_middleware.rb
+- lib/datadog/ai_guard/contrib/rails/integration.rb
+- lib/datadog/ai_guard/contrib/rails/patcher.rb
 - lib/datadog/ai_guard/contrib/ruby_llm/chat_instrumentation.rb
 - lib/datadog/ai_guard/contrib/ruby_llm/integration.rb
 - lib/datadog/ai_guard/contrib/ruby_llm/patcher.rb
@@ -231,6 +238,10 @@ files:
 - lib/datadog/appsec/contrib/active_record/integration.rb
 - lib/datadog/appsec/contrib/active_record/patcher.rb
 - lib/datadog/appsec/contrib/auto_instrument.rb
+- lib/datadog/appsec/contrib/aws_lambda/gateway/watcher.rb
+- lib/datadog/appsec/contrib/aws_lambda/integration.rb
+- lib/datadog/appsec/contrib/aws_lambda/patcher.rb
+- lib/datadog/appsec/contrib/aws_lambda/waf_addresses.rb
 - lib/datadog/appsec/contrib/devise/configuration.rb
 - lib/datadog/appsec/contrib/devise/data_extractor.rb
 - lib/datadog/appsec/contrib/devise/ext.rb
@@ -613,6 +624,7 @@ files:
 - lib/datadog/symbol_database/file_hash.rb
 - lib/datadog/symbol_database/logger.rb
 - lib/datadog/symbol_database/scope.rb
+- lib/datadog/symbol_database/scope_batcher.rb
 - lib/datadog/symbol_database/service_version.rb
 - lib/datadog/symbol_database/symbol.rb
 - lib/datadog/symbol_database/transport.rb
@@ -1118,8 +1130,8 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.32.0/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.32.0
+  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.33.0/CHANGELOG.md
+  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.33.0
 post_install_message: 'JRuby support in the datadog gem is deprecated. Details: https://dtdg.co/jruby-deprecation'
 rdoc_options: []
 require_paths:

data/ext/datadog_profiling_native_extension/clock_id_noop.c

@@ -1,21 +0,0 @@
-#include "extconf.h"
-
-// This file is the dual of clock_id_from_pthread.c for systems where that info
-// is not available.
-#ifndef HAVE_PTHREAD_GETCPUCLOCKID
-
-#include "clock_id.h"
-#include "helpers.h"
-#include "datadog_ruby_common.h"
-
-void self_test_clock_id(void) { } // Nothing to check
-
-thread_cpu_time_id thread_cpu_time_id_for(DDTRACE_UNUSED VALUE _thread) {
-  return (thread_cpu_time_id) {.valid = false};
-}
-
-thread_cpu_time thread_cpu_time_for(DDTRACE_UNUSED thread_cpu_time_id _time_id) {
-  return (thread_cpu_time) {.valid = false};
-}
-
-#endif