datadog 2.18.0 → 2.20.0

data/lib/datadog/kit/appsec/events/v2.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require_relative '../../identity'
+require_relative '../../../appsec/trace_keeper'
+
+module Datadog
+  module Kit
+    module AppSec
+      module Events
+        # The second version of Business Logic Events SDK
+        module V2
+          LOGIN_SUCCESS_EVENT = 'users.login.success'
+          LOGIN_FAILURE_EVENT = 'users.login.failure'
+          TELEMETRY_METRICS_NAMESPACE = 'appsec'
+          TELEMETRY_METRICS_SDK_EVENT = 'sdk.event'
+          TELEMETRY_METRICS_SDK_VERSION = 'v2'
+          TELEMETRY_METRICS_EVENTS_INTO_TYPES = {
+            LOGIN_SUCCESS_EVENT => 'login_success',
+            LOGIN_FAILURE_EVENT => 'login_failure'
+          }.freeze
+
+          class << self
+            # Attach user login success information to the service entry span
+            # and trigger AppSec event processing.
+            #
+            # @param login [String] The user login (e.g., username or email).
+            # @param user_or_id [String, Hash<Symbol, String>] (optional) If a
+            #   String, considered as a user ID, if a Hash, considered as a user
+            #   attributes. The Hash must include `:id` as a key.
+            # @param metadata [Hash<Symbol, String>] Additional flat free-form
+            #   metadata to attach to the event.
+            #
+            # @example Login only
+            #   Datadog::Kit::AppSec::Events::V2.track_user_login_success('alice@example.com')
+            #
+            # @example Login and user attributes
+            #   Datadog::Kit::AppSec::Events::V2.track_user_login_success(
+            #     'alice@example.com',
+            #     { id: 'user-123', email: 'alice@example.com', name: 'Alice' },
+            #     ip: '192.168.1.1', device: 'mobile', 'usr.country': 'US'
+            #   )
+            #
+            # @return [void]
+            def track_user_login_success(login, user_or_id = nil, metadata = {})
+              trace = service_entry_trace
+              span = service_entry_span
+
+              if trace.nil? || span.nil?
+                return Datadog.logger.warn(
+                  'Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events'
+                )
+              end
+
+              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
+              raise TypeError, '`metadata` argument must be a Hash' unless metadata.is_a?(Hash)
+
+              user_attributes = build_user_attributes(user_or_id, login)
+
+              set_span_tags(span, metadata, namespace: LOGIN_SUCCESS_EVENT)
+              set_span_tags(span, user_attributes, namespace: "#{LOGIN_SUCCESS_EVENT}.usr")
+              span.set_tag('appsec.events.users.login.success.track', 'true')
+              span.set_tag('_dd.appsec.events.users.login.success.sdk', 'true')
+
+              ::Datadog::AppSec::TraceKeeper.keep!(trace)
+
+              record_event_telemetry_metric(LOGIN_SUCCESS_EVENT)
+              ::Datadog::AppSec::Instrumentation.gateway.push('appsec.events.user_lifecycle', LOGIN_SUCCESS_EVENT)
+
+              # NOTE: Guard-clause will not work with Steep typechecking
+              return Kit::Identity.set_user(trace, span, **user_attributes) if user_attributes.key?(:id) # steep:ignore
+
+              # NOTE: This is a fallback for the case when we don't have an ID,
+              #       but need to trigger WAF.
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(nil, login)
+              ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+            end
+
+            # Attach user login failure information to the service entry span
+            # and trigger AppSec event processing.
+            #
+            # @param login [String] The user login (e.g., username or email).
+            # @param user_exists [Boolean] Whether the user exists in the system.
+            # @param metadata [Hash<Symbol, String>] Additional flat free-form
+            #   metadata to attach to the event.
+            #
+            # @example Login only
+            #   Datadog::Kit::AppSec::Events::V2.track_user_login_failure('alice@example.com')
+            #
+            # @example With user existence and metadata
+            #   Datadog::Kit::AppSec::Events::V2.track_user_login_failure(
+            #     'alice@example.com',
+            #     true,
+            #     ip: '192.168.1.1', device: 'mobile', 'usr.country': 'US'
+            #   )
+            #
+            # @return [void]
+            def track_user_login_failure(login, user_exists = false, metadata = {})
+              trace = service_entry_trace
+              span = service_entry_span
+
+              if trace.nil? || span.nil?
+                return Datadog.logger.warn(
+                  'Kit::AppSec: Tracing is not enabled. Please enable tracing if you want to track events'
+                )
+              end
+
+              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
+              raise TypeError, '`metadata` argument must be a Hash' unless metadata.is_a?(Hash)
+
+              unless user_exists.is_a?(TrueClass) || user_exists.is_a?(FalseClass)
+                raise TypeError, '`user_exists` argument must be a boolean'
+              end
+
+              set_span_tags(span, metadata, namespace: LOGIN_FAILURE_EVENT)
+              span.set_tag('appsec.events.users.login.failure.track', 'true')
+              span.set_tag('_dd.appsec.events.users.login.failure.sdk', 'true')
+              span.set_tag('appsec.events.users.login.failure.usr.login', login)
+              span.set_tag('appsec.events.users.login.failure.usr.exists', user_exists.to_s)
+
+              ::Datadog::AppSec::TraceKeeper.keep!(trace)
+
+              record_event_telemetry_metric(LOGIN_FAILURE_EVENT)
+              ::Datadog::AppSec::Instrumentation.gateway.push('appsec.events.user_lifecycle', LOGIN_FAILURE_EVENT)
+
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(nil, login)
+              ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+            end
+
+            private
+
+            # NOTE: Current tracer implementation does not provide a way to
+            #       get the service entry span. This is a shortcut we take now.
+            def service_entry_trace
+              return Datadog::Tracing.active_trace unless Datadog::AppSec.active_context
+
+              Datadog::AppSec.active_context&.trace
+            end
+
+            # NOTE: Current tracer implementation does not provide a way to
+            #       get the service entry span. This is a shortcut we take now.
+            def service_entry_span
+              return Datadog::Tracing.active_span unless Datadog::AppSec.active_context
+
+              Datadog::AppSec.active_context&.span
+            end
+
+            def build_user_attributes(user_or_id, login)
+              raise TypeError, '`login` argument must be a String' unless login.is_a?(String)
+
+              case user_or_id
+              when nil
+                {login: login}
+              when String
+                {login: login, id: user_or_id}
+              when Hash
+                raise ArgumentError, 'missing required user key `:id`' unless user_or_id.key?(:id)
+                raise TypeError, 'user key `:id` must be a String' unless user_or_id[:id].is_a?(String)
+
+                user_or_id.merge(login: login)
+              else
+                raise TypeError, '`user_or_id` argument must be either String or Hash'
+              end
+            end
+
+            def set_span_tags(span, tags, namespace:)
+              tags.each do |name, value|
+                next if value.nil?
+
+                span.set_tag("appsec.events.#{namespace}.#{name}", value)
+              end
+            end
+
+            # TODO: In case if we need to introduce telemetry metrics to the SDK v1
+            #       or highly increase the number of metrics, this method should be
+            #       extracted into a proper module.
+            def record_event_telemetry_metric(event)
+              telemetry = ::Datadog.send(:components, allow_initialization: false)&.telemetry
+
+              if telemetry.nil?
+                return Datadog.logger.debug(
+                  'Kit::AppSec: Telemetry component is unavailable. Skip recording SDK metrics'
+                )
+              end
+
+              tags = {
+                event_type: TELEMETRY_METRICS_EVENTS_INTO_TYPES[event],
+                sdk_version: TELEMETRY_METRICS_SDK_VERSION
+              }
+              telemetry.inc(TELEMETRY_METRICS_NAMESPACE, TELEMETRY_METRICS_SDK_EVENT, 1, tags: tags)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/kit/appsec/events.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../identity'
+require_relative '../../appsec/trace_keeper'
 
 module Datadog
   module Kit
@@ -10,7 +11,7 @@ module Datadog
         LOGIN_SUCCESS_EVENT = 'users.login.success'
         LOGIN_FAILURE_EVENT = 'users.login.failure'
         SIGNUP_EVENT = 'users.signup'
-        USER_LOGIN_KEYS = ['usr.login', :'usr.login'].freeze
+        USER_LOGIN_KEYS = ['usr.login', :"usr.login"].freeze
 
         class << self
           # Attach login success event information to the trace
@@ -31,12 +32,12 @@ module Datadog
             set_trace_and_span_context('track_login_success', trace, span) do |active_trace, active_span|
               user_options = user.dup
               user_id = user_options.delete(:id)
-              user_login = user_options[:login] || others[:'usr.login'] || others['usr.login'] || user_id
+              user_login = user_options[:login] || others[:"usr.login"] || others['usr.login'] || user_id
 
               raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
 
               others = others.reject { |key, _| USER_LOGIN_KEYS.include?(key) }
-              others[:'usr.login'] = user_login
+              others[:"usr.login"] = user_login
               track(LOGIN_SUCCESS_EVENT, active_trace, active_span, **others)
 
               user_options[:login] = user_login
@@ -60,7 +61,7 @@ module Datadog
           #   event information to attach to the trace.
           def track_login_failure(trace = nil, span = nil, user_exists:, user_id: nil, **others)
             set_trace_and_span_context('track_login_failure', trace, span) do |active_trace, active_span|
-              others[:'usr.login'] = user_id if user_id && !others.key?(:'usr.login') && !others.key?('usr.login')
+              others[:"usr.login"] = user_id if user_id && !others.key?(:"usr.login") && !others.key?('usr.login')
               track(LOGIN_FAILURE_EVENT, active_trace, active_span, **others)
 
               active_span.set_tag('appsec.events.users.login.failure.usr.id', user_id) if user_id
@@ -86,12 +87,12 @@ module Datadog
             set_trace_and_span_context('track_signup', trace, span) do |active_trace, active_span|
               user_options = user.dup
               user_id = user_options.delete(:id)
-              user_login = user_options[:login] || others[:'usr.login'] || others['usr.login'] || user_id
+              user_login = user_options[:login] || others[:"usr.login"] || others['usr.login'] || user_id
 
               raise ArgumentError, 'missing required key: :user => { :id }' if user_id.nil?
 
               others = others.reject { |key, _| USER_LOGIN_KEYS.include?(key) }
-              others[:'usr.login'] = user_login
+              others[:"usr.login"] = user_login
               track(SIGNUP_EVENT, active_trace, active_span, **others)
 
               user_options[:login] = user_login
@@ -126,7 +127,7 @@ module Datadog
                 span.set_tag("appsec.events.#{event}.#{k}", v) unless v.nil?
               end
 
-              trace.keep!
+              ::Datadog::AppSec::TraceKeeper.keep!(trace)
             else
               set_trace_and_span_context('track', trace, span) do |active_trace, active_span|
                 active_span.set_tag("appsec.events.#{event}.track", 'true')
@@ -138,7 +139,7 @@ module Datadog
                   active_span.set_tag("appsec.events.#{event}.#{k}", v) unless v.nil?
                 end
 
-                active_trace.keep!
+                ::Datadog::AppSec::TraceKeeper.keep!(active_trace)
               end
             end
 
@@ -154,11 +155,11 @@ module Datadog
             end
 
             trace ||= Datadog::Tracing.active_trace
-            span ||=  trace && trace.active_span || Datadog::Tracing.active_span
+            span ||= trace&.active_span || Datadog::Tracing.active_span
 
             unless trace && span
               Datadog.logger.debug(
-                "Tracing not enabled. Method ##{method} is a no-op. Please enable tracing if you want ##{method}"\
+                "Tracing not enabled. Method ##{method} is a no-op. Please enable tracing if you want ##{method}" \
                 ' to track this events'
               )
               return

data/lib/datadog/kit/identity.rb

@@ -43,12 +43,12 @@ module Datadog
 
           # enforce types
 
-          raise TypeError, ':id must be a String'         unless id.is_a?(String)
-          raise TypeError, ':email must be a String'      unless email.nil? || email.is_a?(String)
-          raise TypeError, ':name must be a String'       unless name.nil? || name.is_a?(String)
+          raise TypeError, ':id must be a String' unless id.is_a?(String)
+          raise TypeError, ':email must be a String' unless email.nil? || email.is_a?(String)
+          raise TypeError, ':name must be a String' unless name.nil? || name.is_a?(String)
           raise TypeError, ':session_id must be a String' unless session_id.nil? || session_id.is_a?(String)
-          raise TypeError, ':role must be a String'       unless role.nil? || role.is_a?(String)
-          raise TypeError, ':scope must be a String'      unless scope.nil? || scope.is_a?(String)
+          raise TypeError, ':role must be a String' unless role.nil? || role.is_a?(String)
+          raise TypeError, ':scope must be a String' unless scope.nil? || scope.is_a?(String)
 
           others.each do |k, v|
             raise TypeError, "#{k.inspect} must be a String" unless v.nil? || v.is_a?(String)
@@ -57,11 +57,11 @@ module Datadog
           set_trace_and_span_context('set_user', trace, span) do |_active_trace, active_span|
             # set tags once data is known consistent
             active_span.set_tag('usr.id', id)
-            active_span.set_tag('usr.email', email)           unless email.nil?
-            active_span.set_tag('usr.name', name)             unless name.nil?
+            active_span.set_tag('usr.email', email) unless email.nil?
+            active_span.set_tag('usr.name', name) unless name.nil?
             active_span.set_tag('usr.session_id', session_id) unless session_id.nil?
-            active_span.set_tag('usr.role', role)             unless role.nil?
-            active_span.set_tag('usr.scope', scope)           unless scope.nil?
+            active_span.set_tag('usr.role', role) unless role.nil?
+            active_span.set_tag('usr.scope', scope) unless scope.nil?
 
             others.each do |k, v|
               active_span.set_tag("usr.#{k}", v) unless v.nil?
@@ -81,6 +81,9 @@ module Datadog
 
         private
 
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
         def set_trace_and_span_context(method, trace = nil, span = nil)
           if (appsec_context = Datadog::AppSec.active_context)
             trace = appsec_context.trace
@@ -88,11 +91,11 @@ module Datadog
           end
 
           trace ||= Datadog::Tracing.active_trace
-          span ||= trace && trace.active_span || Datadog::Tracing.active_span
+          span ||= trace&.active_span || Datadog::Tracing.active_span
 
           unless trace && span
             Datadog.logger.debug(
-              "Tracing not enabled. Method ##{method} is a no-op. Please enable tracing if you want ##{method}"\
+              "Tracing not enabled. Method ##{method} is a no-op. Please enable tracing if you want ##{method}" \
               ' to track this events'
             )
             return
@@ -102,6 +105,9 @@ module Datadog
 
           yield(trace, span)
         end
+        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity
       end
     end
   end

data/lib/datadog/opentelemetry/api/baggage.rb

@@ -69,7 +69,7 @@ module Datadog
         def set_value(key, value, metadata: nil, context: ::OpenTelemetry::Context.current)
           # Delegate to the context to set the value because an active trace is not guaranteed
           # set_values handles this logic
-          context.set_values({ ::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY) => { key => value } })
+          context.set_values({::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY) => {key => value}})
         end
 
         # Returns a new context with value at key removed
@@ -81,7 +81,7 @@ module Datadog
         def remove_value(key, context: ::OpenTelemetry::Context.current)
           # Delegate to the context to remove the value because an active trace is not guaranteed
           # set_values handles this logic
-          context.set_values({ Context::BAGGAGE_REMOVE_KEY => key })
+          context.set_values({Context::BAGGAGE_REMOVE_KEY => key})
         end
         ::OpenTelemetry::Baggage.singleton_class.prepend(self)
       end

data/lib/datadog/opentelemetry/api/context.rb

@@ -50,7 +50,8 @@ module Datadog
           @trace.otel_value(key)
         end
 
-        alias [] value
+        # `alias` performed to match {::OpenTelemetry::Context} aliasing upstream
+        alias [] value # rubocop:disable Style/Alias
 
         # Returns a new Context where entries contains the newly added key and value
         #
@@ -80,8 +81,8 @@ module Datadog
             )
           end
 
-          existing_values = @trace && @trace.otel_values || {}
-          existing_baggage = @trace && @trace.baggage || {}
+          existing_values = @trace&.otel_values || {}
+          existing_baggage = @trace&.baggage || {}
 
           # Retrieve the baggage removal sentinel and remove it from the values hash
           existing_baggage.delete(values[BAGGAGE_REMOVE_KEY]) if values.key?(BAGGAGE_REMOVE_KEY)
@@ -89,10 +90,10 @@ module Datadog
           # If the values hash contains a BAGGAGE_KEY, merge its contents with existing baggage
           # Otherwise, keep the existing baggage unchanged
           new_baggage = if values.key?(::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY))
-                          existing_baggage.merge(values[::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY)])
-                        else
-                          existing_baggage
-                        end
+            existing_baggage.merge(values[::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY)])
+          else
+            existing_baggage
+          end
 
           ::OpenTelemetry::Context.new(existing_values.merge(values), trace: trace, baggage: new_baggage)
         end
@@ -125,7 +126,7 @@ module Datadog
             previous_trace = Tracing.active_trace
             continue_trace!(context)
 
-            stack.push(previous_trace && previous_trace.otel_context || ::OpenTelemetry::Context::ROOT)
+            stack.push(previous_trace&.otel_context || ::OpenTelemetry::Context::ROOT)
             stack.size
           end
 
@@ -168,7 +169,7 @@ module Datadog
 
           def continue_trace!(context, &block)
             call_context = Tracing.send(:tracer).send(:call_context)
-            if context && context.trace
+            if context&.trace
               call_context.activate!(context.ensure_trace, &block)
             else
               call_context.activate!(nil)

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

@@ -54,10 +54,10 @@ module Datadog
             tracestate = Tracing::Distributed::TraceContext.new(fetcher: nil).send(:build_tracestate, digest)
           else
             trace_flags = if Tracing::Sampling::PrioritySampler.sampled?(digest.trace_sampling_priority)
-                            ::OpenTelemetry::Trace::TraceFlags::SAMPLED
-                          else
-                            ::OpenTelemetry::Trace::TraceFlags::DEFAULT
-                          end
+              ::OpenTelemetry::Trace::TraceFlags::SAMPLED
+            else
+              ::OpenTelemetry::Trace::TraceFlags::DEFAULT
+            end
             tracestate = ::OpenTelemetry::Trace::Tracestate::DEFAULT
           end
 

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

@@ -120,7 +120,7 @@ module Datadog
         # Some special attributes can override Datadog Span fields
         def span_arguments(span, attributes)
           if attributes.key?('analytics.event') && (analytics_event = attributes['analytics.event']).respond_to?(:casecmp)
-            attributes[Tracing::Metadata::Ext::Analytics::TAG_SAMPLE_RATE] = analytics_event.casecmp('true') == 0 ? 1 : 0
+            attributes[Tracing::Metadata::Ext::Analytics::TAG_SAMPLE_RATE] = (analytics_event.casecmp('true') == 0) ? 1 : 0
           end
 
           if attributes.key?('http.response.status_code')
@@ -129,15 +129,15 @@ module Datadog
 
           attributes[Tracing::Metadata::Ext::TAG_KIND] = span.kind || 'internal'
 
-          kwargs = { start_time: ns_to_time(span.start_timestamp) }
+          kwargs = {start_time: ns_to_time(span.start_timestamp)}
 
           name = if attributes.key?('operation.name')
-                   attributes['operation.name']
-                 elsif (rich_name = Datadog::OpenTelemetry::Trace::Span.enrich_name(span.kind, attributes))
-                   rich_name.downcase
-                 else
-                   span.kind
-                 end
+            attributes['operation.name']
+          elsif (rich_name = Datadog::OpenTelemetry::Trace::Span.enrich_name(span.kind, attributes))
+            rich_name.downcase
+          else
+            span.kind
+          end
 
           kwargs[:resource] = attributes.key?('resource.name') ? attributes['resource.name'] : span.name
           kwargs[:service] = attributes['service.name'] if attributes.key?('service.name')

data/lib/datadog/opentelemetry/sdk/trace/span.rb

@@ -38,8 +38,8 @@ module Datadog
           res
         end
 
-        # `alias` performed to match {OpenTelemetry::SDK::Trace::Span} aliasing upstream
-        alias []= set_attribute
+        # `alias` performed to match {::OpenTelemetry::SDK::Trace::Span} aliasing upstream
+        alias []= set_attribute # rubocop:disable Style/Alias
 
         # Attributes are equivalent to span tags and metrics.
         def add_attributes(attributes)
@@ -72,24 +72,24 @@ module Datadog
             return 'http.client.request' if kind == :client
           end
 
-          return "#{attrs['db.system']}.query" if attrs.key?('db.system') && kind == :client
+          return "#{attrs["db.system"]}.query" if attrs.key?('db.system') && kind == :client
 
           if (attrs.key?('messaging.system') || attrs.key?('messaging.operation')) &&
               [:consumer, :producer, :server, :client].include?(kind)
 
-            return "#{attrs['messaging.system']}.#{attrs['messaging.operation']}"
+            return "#{attrs["messaging.system"]}.#{attrs["messaging.operation"]}"
           end
 
           if attrs.key?('rpc.system')
             if attrs['rpc.system'] == 'aws-api' && kind == :client
               service = attrs['rpc.service']
-              return "aws.#{service || 'client'}.request"
+              return "aws.#{service || "client"}.request"
             end
 
             if kind == :client
-              return "#{attrs['rpc.system']}.client.request"
+              return "#{attrs["rpc.system"]}.client.request"
             elsif kind == :server
-              return "#{attrs['rpc.system']}.server.request"
+              return "#{attrs["rpc.system"]}.server.request"
             end
           end
 
@@ -99,7 +99,7 @@ module Datadog
             return "#{provider}.#{name}.invoke"
           end
 
-          return "#{attrs['faas.trigger']}.invoke" if attrs.key?('faas.trigger') && kind == :server
+          return "#{attrs["faas.trigger"]}.invoke" if attrs.key?('faas.trigger') && kind == :server
 
           return 'graphql.server.request' if attrs.key?('graphql.operation.type')
 
@@ -119,6 +119,7 @@ module Datadog
 
         private
 
+        # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         def datadog_set_attribute(key)
           # Return if attributes are currently disabled by OpenTelemetry.
           return unless defined?(@attributes) && @attributes
@@ -149,9 +150,11 @@ module Datadog
             end
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
         # Some special attributes can override Datadog Span fields beyond tags and metrics.
         # @return [Boolean] true if the key is a Datadog Span override attribute, false otherwise
+        # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         def override_datadog_values(span, key, value)
           span.name = value if key == 'operation.name'
           span.resource = value if key == 'resource.name'
@@ -161,15 +164,16 @@ module Datadog
           if key == 'analytics.event' && value.respond_to?(:casecmp)
             Datadog::Tracing::Analytics.set_sample_rate(
               span,
-              value.casecmp('true') == 0 ? 1 : 0
+              (value.casecmp('true') == 0) ? 1 : 0
             )
           end
 
           span.set_tag('http.status_code', value) if key == 'http.response.status_code'
         end
+        # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
         DATADOG_SPAN_ATTRIBUTE_OVERRIDES = ['analytics.event', 'operation.name', 'resource.name', 'service.name',
-                                            'span.type', 'http.response.status_code'].freeze
+          'span.type', 'http.response.status_code'].freeze
 
         ::OpenTelemetry::SDK::Trace::Span.prepend(self)
       end

data/lib/datadog/opentelemetry/trace.rb

@@ -15,10 +15,10 @@ module Datadog
         # @return [TraceOperation]
         def start_trace_copy(trace, parent_span: nil)
           digest = if parent_span
-                     digest_with_parent_span(trace, parent_span)
-                   else
-                     trace.to_digest
-                   end
+            digest_with_parent_span(trace, parent_span)
+          else
+            trace.to_digest
+          end
 
           # Create a new TraceOperation, attached to the current Datadog Tracer.
           Datadog::Tracing.continue_trace!(digest)

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

@@ -23,6 +23,7 @@ module Datadog
           allocation_profiling_enabled:,
           allocation_counting_enabled:,
           gvl_profiling_enabled:,
+          sighandler_sampling_enabled:,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
@@ -49,6 +50,7 @@ module Datadog
             allocation_profiling_enabled: allocation_profiling_enabled,
             allocation_counting_enabled: allocation_counting_enabled,
             gvl_profiling_enabled: gvl_profiling_enabled,
+            sighandler_sampling_enabled: sighandler_sampling_enabled,
             skip_idle_samples_for_testing: skip_idle_samples_for_testing,
           )
           @worker_thread = nil

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

@@ -28,6 +28,37 @@ module Datadog
 
         private
 
+        # Ruby GC tuning environment variables
+        RUBY_GC_TUNING_ENV_VARS = [
+          "RUBY_GC_HEAP_FREE_SLOTS",
+          "RUBY_GC_HEAP_GROWTH_FACTOR",
+          "RUBY_GC_HEAP_GROWTH_MAX_SLOTS",
+          "RUBY_GC_HEAP_FREE_SLOTS_MIN_RATIO",
+          "RUBY_GC_HEAP_FREE_SLOTS_MAX_RATIO",
+          "RUBY_GC_HEAP_FREE_SLOTS_GOAL_RATIO",
+          "RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR",
+          "RUBY_GC_HEAP_REMEMBERED_WB_UNPROTECTED_OBJECTS_LIMIT_RATIO",
+          "RUBY_GC_MALLOC_LIMIT",
+          "RUBY_GC_MALLOC_LIMIT_MAX",
+          "RUBY_GC_MALLOC_LIMIT_GROWTH_FACTOR",
+          "RUBY_GC_OLDMALLOC_LIMIT",
+          "RUBY_GC_OLDMALLOC_LIMIT_MAX",
+          "RUBY_GC_OLDMALLOC_LIMIT_GROWTH_FACTOR",
+          # INIT_SLOTS changed for Ruby 3.3+:
+          # * https://bugs.ruby-lang.org/issues/19785
+          # * https://www.ruby-lang.org/en/news/2023/12/25/ruby-3-3-0-released/#:~:text=Removed%20environment%20variables
+          "RUBY_GC_HEAP_0_INIT_SLOTS",
+          "RUBY_GC_HEAP_1_INIT_SLOTS",
+          "RUBY_GC_HEAP_2_INIT_SLOTS",
+          "RUBY_GC_HEAP_3_INIT_SLOTS",
+          "RUBY_GC_HEAP_4_INIT_SLOTS",
+          # There was only one setting for older Rubies:
+          "RUBY_GC_HEAP_INIT_SLOTS",
+          # Ruby 2.x only, alias for others:
+          "RUBY_FREE_MIN",
+          "RUBY_HEAP_MIN_SLOTS",
+        ].freeze
+
         # Instead of trying to figure out real process start time by checking
         # /proc or some other complex/non-portable way, approximate start time
         # by time of requirement of this file.
@@ -51,6 +82,7 @@ module Datadog
             engine: Datadog::Core::Environment::Identity.lang_engine,
             version: Datadog::Core::Environment::Identity.lang_version,
             platform: Datadog::Core::Environment::Identity.lang_platform,
+            gc_tuning: collect_gc_tuning_info,
           }.freeze
         end
 
@@ -109,6 +141,15 @@ module Datadog
             v.inspect
           end
         end
+
+        def collect_gc_tuning_info
+          return @gc_tuning_info if defined?(@gc_tuning_info)
+
+          @gc_tuning_info = RUBY_GC_TUNING_ENV_VARS.each_with_object({}) do |var, hash|
+            current_value = ENV[var]
+            hash[var.to_sym] = current_value if current_value
+          end.freeze
+        end
       end
     end
   end

data/lib/datadog/profiling/component.rb

@@ -67,6 +67,7 @@ module Datadog
           allocation_profiling_enabled: allocation_profiling_enabled,
           allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
           gvl_profiling_enabled: enable_gvl_profiling?(settings, logger),
+          sighandler_sampling_enabled: settings.profiling.advanced.sighandler_sampling_enabled,
         )
 
         internal_metadata = {