datadog 2.21.0 → 2.23.0

data/lib/datadog/opentelemetry.rb

@@ -22,6 +22,8 @@ require_relative 'opentelemetry/api/baggage'
 require_relative 'opentelemetry/sdk/configurator' if defined?(OpenTelemetry::SDK)
 require_relative 'opentelemetry/sdk/trace/span' if defined?(OpenTelemetry::SDK)
 
+require_relative 'opentelemetry/metrics' if defined?(OpenTelemetry::SDK::Metrics)
+
 module Datadog
   # Datadog OpenTelemetry integration.
   module OpenTelemetry
@@ -47,6 +49,7 @@ end
 # Currently, this closely translates to Datadog's partial flushing.
 #
 # @see OpenTelemetry::SDK::Trace::SpanProcessor#on_finish
+
 Datadog.configure do |c|
   c.tracing.partial_flush.enabled = true
 end

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

@@ -22,6 +22,7 @@ module Datadog
           @libraries_by_path = {}
           @seen_files = Set.new
           @seen_libraries = Set.new
+          @executable_paths = [Gem.bindir, (Bundler.bin_path.to_s if defined?(Bundler))].uniq.compact.freeze
 
           record_library(
             Library.new(
@@ -29,7 +30,7 @@ module Datadog
               name: "stdlib",
               version: RUBY_VERSION,
               path: standard_library_path,
-              extra_path: ruby_native_filename,
+              extra_paths: [ruby_native_filename],
             )
           )
         end
@@ -51,7 +52,8 @@ module Datadog
           :libraries_by_name,
           :libraries_by_path,
           :seen_files,
-          :seen_libraries
+          :seen_libraries,
+          :executable_paths
 
         def record_library(library)
           libraries_by_name[library.name] = library
@@ -79,13 +81,20 @@ module Datadog
           loaded_specs.each do |spec|
             next if libraries_by_name.key?(spec.name)
 
+            extra_paths = [(spec.extension_dir if spec.extensions.any?)]
+            spec.executables&.each do |executable|
+              executable_paths.each do |path|
+                extra_paths << File.join(path, executable)
+              end
+            end
+
             record_library(
               Library.new(
                 kind: "library",
                 name: spec.name,
                 version: spec.version,
                 path: spec.gem_dir,
-                extra_path: (spec.extension_dir if spec.extensions.any?),
+                extra_paths: extra_paths,
               )
             )
             recorded_library = true
@@ -118,12 +127,12 @@ module Datadog
         class Library
           attr_reader :kind, :name, :version
 
-          def initialize(kind:, name:, version:, path:, extra_path: nil)
-            extra_path = nil if extra_path&.empty?
+          def initialize(kind:, name:, version:, path:, extra_paths:)
+            extra_paths = Array(extra_paths).compact.reject(&:empty?).map { |p| p.dup.freeze }
             @kind = kind.freeze
             @name = name.dup.freeze
             @version = version.to_s.dup.freeze
-            @paths = [path.dup.freeze, extra_path.dup.freeze].compact.freeze
+            @paths = [path.dup.freeze, *extra_paths].freeze
             freeze
           end
 

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

@@ -82,7 +82,7 @@ module Datadog
                 "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
               )
               on_failure_proc&.call
-              Datadog::Core::Telemetry::Logger.report(e, description: "CpuAndWallTimeWorker thread error", pii_safe: true)
+              Datadog::Core::Telemetry::Logger.report(e, description: "CpuAndWallTimeWorker thread error")
             end
             @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap
             @worker_thread.thread_variable_set(:fork_safe, true)

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

@@ -41,7 +41,7 @@ module Datadog
                 "IdleSamplingHelper thread error. " \
                 "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
               )
-              Datadog::Core::Telemetry::Logger.report(e, description: "IdleSamplingHelper thread error", pii_safe: true)
+              Datadog::Core::Telemetry::Logger.report(e, description: "IdleSamplingHelper thread error")
             end
             @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap
             @worker_thread.thread_variable_set(:fork_safe, true)

data/lib/datadog/profiling/profiler.rb

@@ -17,6 +17,10 @@ module Datadog
         @scheduler = scheduler
       end
 
+      def enabled?
+        scheduler.running?
+      end
+
       def start
         after_fork! do
           worker.reset_after_fork

data/lib/datadog/profiling/tag_builder.rb

@@ -1,17 +1,48 @@
 # frozen_string_literal: true
 
-require_relative "../core/tag_builder"
-require_relative "../core/utils"
+require_relative '../core/tag_builder'
+require_relative '../core/utils'
+
+require 'set'
 
 module Datadog
   module Profiling
     # Builds a hash of default plus user tags to be included in a profile
+    #
+    # @api private
     module TagBuilder
       include Datadog::Profiling::Ext::Transport::HTTP # Tag name constants
 
+      # When changing or adding profiling-related tags, make sure they are
+      # kept in sync with
+      # https://docs.google.com/spreadsheets/d/1LOGMf4c4Avbtn36uZ2SWvhIGKRPLM1BoWkUP4JYj7hA/
+      # (Datadog internal link).
+      #
+      # For consistency between the different profilers, every tag should be
+      # vetted before it gets reported with a profile, as otherwise it's too
+      # easy to end up with different tags in different languages.
+      ALLOWED_TAGS = Set.new(
+        [
+          'env',
+          'service',
+          'version',
+          'git.commit.sha',
+          'git.repository_url',
+          'host',
+          'language',
+          'runtime',
+          'runtime_engine',
+          'runtime_platform',
+          'runtime_version',
+          'runtime-id',
+          'process_id',
+          'profiler_version',
+          'profile_seq',
+        ]
+      ).freeze
+
       def self.call(
         settings:,
-        # Other metadata
         profile_seq:,
         profiler_version: Core::Environment::Identity.gem_datadog_version
       )
@@ -19,6 +50,8 @@ module Datadog
           FORM_FIELD_TAG_PROFILER_VERSION => profiler_version,
           'profile_seq' => profile_seq.to_s,
         )
+        user_tag_keys = settings.tags.keys
+        hash.keep_if { |tag| user_tag_keys.include?(tag) || ALLOWED_TAGS.include?(tag) }
         Core::Utils.encode_tags(hash)
       end
     end

data/lib/datadog/profiling.rb

@@ -62,8 +62,7 @@ module Datadog
 
     def self.enabled?
       profiler = Datadog.send(:components).profiler
-      # Use .send(...) to avoid exposing the attr_reader as an API to the outside
-      !!profiler&.send(:scheduler)&.running?
+      !!profiler&.enabled?
     end
 
     def self.wait_until_running(timeout_seconds: 5)

data/lib/datadog/single_step_instrument.rb

@@ -15,7 +15,7 @@ end
 
 begin
   require_relative 'auto_instrument'
-  Datadog::SingleStepInstrument::LOADED = true
+  Datadog::SingleStepInstrument.const_set(:LOADED, true)
 rescue StandardError, LoadError => e
   warn "Single step instrumentation failed: #{e.class}:#{e.message}\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
 end

data/lib/datadog/tracing/component.rb

@@ -12,16 +12,7 @@ module Datadog
   module Tracing
     # Tracing component
     module Component
-      # Methods that interact with component instance fields.
-      module InstanceMethods
-        # Hot-swaps with a new sampler.
-        # This operation acquires the Components lock to ensure
-        # there is no concurrent modification of the sampler.
-        def reconfigure_live_sampler
-          sampler = self.class.build_sampler(Datadog.configuration)
-          Datadog.send(:safely_synchronize) { tracer.sampler.sampler = sampler }
-        end
-      end
+      module_function
 
       def build_tracer(settings, agent_settings, logger:)
         # If a custom tracer has been provided, use it instead.
@@ -156,11 +147,6 @@ module Datadog
         Tracing::Sampling::Span::Sampler.new(rules || [])
       end
 
-      # Configure non-privileged components.
-      def configure_tracing(settings)
-        Datadog::Tracing::Contrib::Component.configure(settings)
-      end
-
       # Sampler wrapper component, to allow for hot-swapping
       # the sampler instance used by the tracer.
       # Swapping samplers happens during Dynamic Configuration.
@@ -182,8 +168,7 @@ module Datadog
         end
       end
 
-      private
-
+      # @api private
       def build_tracer_tags(settings)
         settings.tags.dup.tap do |tags|
           tags[Core::Environment::Ext::TAG_ENV] = settings.env unless settings.env.nil?
@@ -193,6 +178,7 @@ module Datadog
 
       # Build a post-sampler that limits the rate of traces to one per `seconds`.
       # E.g.: `build_rate_limit_post_sampler(seconds: 60)` will limit the rate to one trace per minute.
+      # @api private
       def build_rate_limit_post_sampler(seconds:)
         Tracing::Sampling::RuleSampler.new(
           rate_limiter: Datadog::Core::TokenBucket.new(1.0 / seconds, 1.0),
@@ -200,11 +186,13 @@ module Datadog
         )
       end
 
+      # @api private
       def build_test_mode_trace_flush(settings)
         # If context flush behavior is provided, use it instead.
         settings.tracing.test_mode.trace_flush || build_trace_flush(settings)
       end
 
+      # @api private
       def build_test_mode_sampler
         # Do not sample any spans for tests; all must be preserved.
         # Set priority sampler to ensure the agent doesn't drop any traces.
@@ -214,6 +202,7 @@ module Datadog
         )
       end
 
+      # @api private
       def build_test_mode_writer(settings, agent_settings)
         writer_options = settings.tracing.test_mode.writer_options || {}
 

data/lib/datadog/tracing/configuration/dynamic.rb

@@ -41,7 +41,7 @@ module Datadog
           # Ensures sampler is rebuilt and new configuration is applied
           def call(tracing_sampling_rate)
             super
-            Datadog.send(:components).reconfigure_live_sampler
+            Datadog.send(:components).reconfigure_sampler
           end
 
           protected
@@ -79,7 +79,7 @@ module Datadog
             end
 
             super
-            Datadog.send(:components).reconfigure_live_sampler
+            Datadog.send(:components).reconfigure_sampler
           end
 
           protected

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

@@ -13,6 +13,9 @@ module Datadog
         ENV_BAGGAGE_TAG_KEYS = 'DD_TRACE_BAGGAGE_TAG_KEYS'
         ENV_TRACE_ID_128_BIT_GENERATION_ENABLED = 'DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED'
         ENV_NATIVE_SPAN_EVENTS = 'DD_TRACE_NATIVE_SPAN_EVENTS'
+        ENV_RESOURCE_RENAMING_ENABLED = 'DD_TRACE_RESOURCE_RENAMING_ENABLED'
+        ENV_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT = 'DD_TRACE_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT'
+        ENV_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED = 'DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED'
 
         # @public_api
         module SpanAttributeSchema
@@ -104,6 +107,12 @@ module Datadog
           ENV_ENABLED = 'DD_TRACE_CLIENT_IP_ENABLED'
           ENV_HEADER_NAME = 'DD_TRACE_CLIENT_IP_HEADER'
         end
+
+        # @public_api
+        module HTTPErrorStatuses
+          ENV_SERVER_ERROR_STATUSES = 'DD_TRACE_HTTP_SERVER_ERROR_STATUSES'
+          ENV_CLIENT_ERROR_STATUSES = 'DD_TRACE_HTTP_CLIENT_ERROR_STATUSES'
+        end
       end
     end
   end

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

@@ -2,6 +2,8 @@
 
 require_relative '../../tracing/configuration/ext'
 require_relative '../../core/environment/variable_helpers'
+require_relative '../contrib/status_range_matcher'
+require_relative '../contrib/status_range_env_parser'
 require_relative 'http'
 
 module Datadog
@@ -96,7 +98,7 @@ module Datadog
                 # Note: Alias (DD_TRACE_PROPAGATION_STYLE) defined in supported-configurations.json
                 o.env Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE
                 o.default []
-                o.after_set do |styles|
+                o.after_set do |styles, _, precedence|
                   next if styles.empty?
 
                   # Make values case-insensitive
@@ -110,8 +112,8 @@ module Datadog
                       false
                     end
                   end
-                  set_option(:propagation_style_extract, styles)
-                  set_option(:propagation_style_inject, styles)
+                  set_option(:propagation_style_extract, styles, precedence: precedence)
+                  set_option(:propagation_style_inject, styles, precedence: precedence)
                 end
               end
 
@@ -272,6 +274,38 @@ module Datadog
                 o.type :bool
               end
 
+              settings :resource_renaming do
+                # Whether resource renaming is enabled. When enabled, http.endpoint tag
+                # containing a route will be reported in traces. If AppSec is enabled,
+                # this feature will be enabled by default.
+                #
+                # For web applications built with instrumented frameworks, http.endpoint tag
+                # will contain the route as it is defined in the application.
+                # For basic Rack applications, or applications that are mounted and are not instrumented,
+                # the route will be inferred from the request path.
+                #
+                # @default `DD_TRACE_RESOURCE_RENAMING_ENABLED` environment variable, otherwise `false`.
+                # @return [Boolean]
+                option :enabled do |o|
+                  o.type :bool, nilable: false
+                  o.env Configuration::Ext::ENV_RESOURCE_RENAMING_ENABLED
+                  o.default false
+                end
+
+                # When set to true, http.endoint is always inferred from path,
+                # instead of using http.route value when it is set.
+                #
+                # This is useful for testing purposes.
+                #
+                # @default false
+                # @return [Boolean]
+                option :always_simplified_endpoint do |o|
+                  o.type :bool, nilable: false
+                  o.env Configuration::Ext::ENV_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT
+                  o.default false
+                end
+              end
+
               # Forces the tracer to always send span events with the native span events format
               # regardless of the agent support. This is useful in agent-less setups.
               #
@@ -490,6 +524,46 @@ module Datadog
                 o.env Tracing::Configuration::Ext::Distributed::ENV_X_DATADOG_TAGS_MAX_LENGTH
                 o.default 512
               end
+
+              # HTTP error statuses configuration
+              # @public_api
+              settings :http_error_statuses do
+                # Defines the range of status codes to be considered errors on http.server span kinds.
+                # Once set, only the values within the specified range are considered errors.
+                #
+                # Format of env var: comma-separated list of values like 500,501,502 or ranges like 500-599 (e.g. `500,502,504-510`)
+                #
+                # @default `DD_TRACE_HTTP_SERVER_ERROR_STATUSES` environment variable, otherwise `500..599`.
+                # @return [Tracing::Contrib::StatusRangeMatcher]
+                option :server do |o|
+                  o.env Tracing::Configuration::Ext::HTTPErrorStatuses::ENV_SERVER_ERROR_STATUSES
+                  o.default 500..599
+                  o.setter do |v|
+                    Tracing::Contrib::StatusRangeMatcher.new(v) if v
+                  end
+                  o.env_parser do |values|
+                    Tracing::Contrib::StatusRangeEnvParser.call(values)
+                  end
+                end
+
+                # Defines the range of status codes to be considered errors on http.client span kinds.
+                # Once set, only the values within the specified range are considered errors.
+                #
+                # Format of env var: comma-separated list of values like 400,401,402 or ranges like 400-499 (e.g. `400,402,404-410`)
+                #
+                # @default `DD_TRACE_HTTP_CLIENT_ERROR_STATUSES` environment variable, otherwise `400..499`.
+                # @return [Tracing::Contrib::StatusRangeMatcher]
+                option :client do |o|
+                  o.env Tracing::Configuration::Ext::HTTPErrorStatuses::ENV_CLIENT_ERROR_STATUSES
+                  o.default 400..499
+                  o.setter do |v|
+                    Tracing::Contrib::StatusRangeMatcher.new(v) if v
+                  end
+                  o.env_parser do |values|
+                    Tracing::Contrib::StatusRangeEnvParser.call(values)
+                  end
+                end
+              end
             end
           end
         end

data/lib/datadog/tracing/contrib/action_pack/action_controller/instrumentation.rb

@@ -77,10 +77,10 @@ module Datadog
 
                 exception = payload[:exception_object]
                 if exception.nil?
-                  # [christian] in some cases :status is not defined,
-                  # rather than firing an error, simply acknowledge we don't know it.
-                  status = payload.fetch(:status, '?').to_s
-                  span.status = 1 if status.start_with?('5')
+                  status = payload[:status]
+                  if status && Datadog.configuration.tracing.http_error_statuses.server.include?(status)
+                    span.status = Tracing::Metadata::Ext::Errors::STATUS
+                  end
                 elsif Utils.exception_is_error?(exception)
                   span.set_error(exception)
                 end

data/lib/datadog/tracing/contrib/action_pack/utils.rb

@@ -13,8 +13,7 @@ module Datadog
               # Gets the equivalent status code for the exception (not all are 5XX)
               # You can add custom errors via `config.action_dispatch.rescue_responses`
               status = ::ActionDispatch::ExceptionWrapper.status_code_for_exception(exception.class.name)
-              # Only 5XX exceptions are actually errors (e.g. don't flag 404s)
-              status.to_s.start_with?('5')
+              Datadog.configuration.tracing.http_error_statuses.server.include?(status)
             else
               true
             end

data/lib/datadog/tracing/contrib/active_job/log_injection.rb

@@ -6,17 +6,31 @@ module Datadog
       module ActiveJob
         # Active Job log injection wrapped around job execution
         module LogInjection
-          def self.included(base)
-            base.class_eval do
-              around_perform do |_, block|
-                if Datadog.configuration.tracing.log_injection && logger.respond_to?(:tagged)
-                  logger.tagged(Tracing.log_correlation, &block)
-                else
-                  block.call
+          # Active Job 4 / 5 don't execute `perform_now` at the right point, so we do best effort log correlation tagging
+          module AroundPerformPatch
+            def self.included(base)
+              base.class_eval do
+                around_perform do |_, block|
+                  if Datadog.configuration.tracing.log_injection && logger.respond_to?(:tagged)
+                    logger.tagged(Tracing.log_correlation, &block)
+                  else
+                    block.call
+                  end
                 end
               end
             end
           end
+
+          # Active Job 6+ executes `perform_now` at the right point, so we can provide better log correlation tagging
+          module PerformNowPatch
+            def perform_now
+              if Datadog.configuration.tracing.log_injection && logger.respond_to?(:tagged)
+                logger.tagged(Tracing.log_correlation) { super }
+              else
+                super
+              end
+            end
+          end
         end
       end
     end

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

@@ -26,7 +26,11 @@ module Datadog
 
           def inject_log_correlation
             ::ActiveSupport.on_load(:active_job) do
-              include LogInjection
+              if ::ActiveJob.gem_version < Gem::Version.new('6.0.0')
+                include LogInjection::AroundPerformPatch
+              else
+                include LogInjection::PerformNowPatch
+              end
             end
           end
         end

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

@@ -36,8 +36,10 @@ module Datadog
             span.name = Ext::SPAN_COMMAND
             span.resource = context.safely(:resource)
 
-            # Set error on the span if the Response Status Code is in error range
-            if Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(context.safely(:status_code))
+            # DEV-3.0: This was previously checking against a 500..599 range.
+            # To not introduce breaking change, this was changed to use `http_error_statuses.server`,
+            # but `aws` is a client library, this check should use `http_error_statuses.client` instead.
+            if Datadog.configuration.tracing.http_error_statuses.server.include?(context.safely(:status_code))
               # At this point we do not have any additional diagnostics
               # besides the HTTP status code which is recorded in the span tags
               # later in this method.

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

@@ -9,13 +9,13 @@ module Datadog
           # Register a callback to be invoked when components are reconfigured.
           # @param name [String] the name of the integration
           # @param callback [Proc] the callback to invoke
-          # @yieldparam config [Datadog::Configuration] the configuration to pass to callbacks
+          # @yieldparam config [Datadog::Core::Configuration::Settings] the configuration to pass to callbacks
           def register(name, &callback)
             @registry[name] = callback
           end
 
           # Invoke all registered callbacks with the given configuration.
-          # @param config [Datadog::Configuration] the configuration to pass to callbacks
+          # @param config [Datadog::Core::Configuration::Settings] the configuration to pass to callbacks
           def configure(config)
             @registry.each do |name, callback|
               callback.call(config)

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

@@ -57,7 +57,10 @@ module Datadog
                   set_span_error_message("Request has failed: #{message}")
                 else
                   @datadog_span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response_code)
-                  if Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(response_code)
+                  # DEV-3.0: This was previously checking against a 500..599 range.
+                  # To not introduce breaking change, this was changed to use `http_error_statuses.server`,
+                  # but `ethon` is a client library, this check should use `http_error_statuses.client` instead.
+                  if Datadog.configuration.tracing.http_error_statuses.server.include?(response_code)
                     set_span_error_message("Request has failed with HTTP error: #{response_code}")
                   end
                 end

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

@@ -41,9 +41,17 @@ module Datadog
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 400...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to client (400..499) + server (500..599)
+                  # DEV-3.0: `excon` is a client library, this should fall back to `http_error_statuses.client` only.
+                  # We cannot change it without causing a breaking change.
+                  client_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.client
+                  server_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.server
+                  client_global_error_statuses + server_global_error_statuses
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v

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

@@ -13,10 +13,6 @@ module Datadog
           # Custom settings for the Faraday integration
           # @public_api
           class Settings < Contrib::Configuration::Settings
-            DEFAULT_ERROR_HANDLER = lambda do |env|
-              Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(env[:status])
-            end
-
             option :enabled do |o|
               o.type :bool
               o.env Ext::ENV_ENABLED
@@ -44,9 +40,17 @@ module Datadog
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 400...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to client (400..499) + server (500..599)
+                  # DEV-3.0: `faraday` is a client library, this should fall back to `http_error_statuses.client` only.
+                  # We cannot change it without causing a breaking change.
+                  client_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.client
+                  server_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.server
+                  client_global_error_statuses + server_global_error_statuses
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v

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

@@ -39,9 +39,13 @@ module Datadog
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 500...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to server (500..599)
+                  Datadog.configuration.tracing.http_error_statuses.server
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v

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

@@ -58,6 +58,13 @@ module Datadog
               o.default []
               o.env_parser { |v| ErrorExtensionEnvParser.call(v) }
             end
+
+            # Surface GraphQL errors in Error Tracking.
+            option :error_tracking do |o|
+              o.env Ext::ENV_ERROR_TRACKING
+              o.type :bool
+              o.default false
+            end
           end
         end
       end

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

@@ -13,6 +13,7 @@ module Datadog
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_GRAPHQL_ANALYTICS_SAMPLE_RATE'
           ENV_WITH_UNIFIED_TRACER = 'DD_TRACE_GRAPHQL_WITH_UNIFIED_TRACER'
           ENV_ERROR_EXTENSIONS = 'DD_TRACE_GRAPHQL_ERROR_EXTENSIONS'
+          ENV_ERROR_TRACKING = 'DD_TRACE_GRAPHQL_ERROR_TRACKING'
           SERVICE_NAME = 'graphql'
           TAG_COMPONENT = 'graphql'