datadog 2.31.0 → 2.33.0

data/lib/datadog/di/probe_manager.rb

@@ -30,7 +30,7 @@ module Datadog
           install_pending_method_probes(tp.self)
         rescue => exc
           raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions
-          logger.debug { "di: unhandled exception in definition trace point: #{exc.class}: #{exc}" }
+          logger.debug { "di: unhandled exception in definition trace point: #{exc.class}: #{exc.message}" }
           telemetry&.report(exc, description: "Unhandled exception in definition trace point")
           # TODO test this path
         end
@@ -133,13 +133,13 @@ module Datadog
         # In "propagate all exceptions" mode we will try to instrument again.
         raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions
 
-        logger.debug { "di: error processing probe configuration: #{exc.class}: #{exc}" }
+        logger.debug { "di: error processing probe configuration: #{exc.class}: #{exc.message}" }
         telemetry&.report(exc, description: "Error processing probe configuration")
 
         payload = probe_notification_builder.build_errored(probe, exc)
         probe_notifier_worker.add_status(payload, probe: probe)
 
-        probe_repository.add_failed(probe.id, "#{exc.class}: #{exc}")
+        probe_repository.add_failed(probe.id, "#{exc.class}: #{exc.message}")
 
         raise
       end
@@ -164,7 +164,7 @@ module Datadog
             raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions
             # Silence all exceptions?
             # TODO should we propagate here and rescue upstream?
-            logger.debug { "di: error removing #{probe.type} probe at #{probe.location} (#{probe.id}): #{exc.class}: #{exc}" }
+            logger.debug { "di: error removing #{probe.type} probe at #{probe.location} (#{probe.id}): #{exc.class}: #{exc.message}" }
             telemetry&.report(exc, description: "Error removing probe")
           end
         end
@@ -193,13 +193,13 @@ module Datadog
                 rescue => exc
                   raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions
 
-                  logger.debug { "di: error installing #{probe.type} probe at #{probe.location} (#{probe.id}) after class is defined: #{exc.class}: #{exc}" }
+                  logger.debug { "di: error installing #{probe.type} probe at #{probe.location} (#{probe.id}) after class is defined: #{exc.class}: #{exc.message}" }
                   telemetry&.report(exc, description: "Error installing probe after class is defined")
 
                   payload = probe_notification_builder.build_errored(probe, exc)
                   probe_notifier_worker.add_status(payload, probe: probe)
 
-                  probe_repository.add_failed(probe.id, "#{exc.class}: #{exc}")
+                  probe_repository.add_failed(probe.id, "#{exc.class}: #{exc.message}")
                 end
               end
             end

data/lib/datadog/di/probe_notification_builder.rb

@@ -368,7 +368,7 @@ module Datadog
           end
         rescue => exc
           evaluation_errors << {
-            message: "#{exc.class}: #{exc}",
+            message: "#{exc.class}: #{exc.message}",
             expr: segment.dsl_expr,
           }
           '[evaluation error]'

data/lib/datadog/di/probe_notifier_worker.rb

@@ -95,7 +95,7 @@ module Datadog
             rescue => exc
               raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions
 
-              logger.debug { "di: error in probe notifier worker: #{exc.class}: #{exc} (at #{exc.backtrace.first})" }
+              logger.debug { "di: error in probe notifier worker: #{exc.class}: #{exc.message} (at #{exc.backtrace.first})" }
               telemetry&.report(exc, description: "Error in probe notifier worker")
             end
             @lock.synchronize do
@@ -320,7 +320,7 @@ module Datadog
               end
             rescue => exc
               raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions
-              logger.debug { "di: failed to send #{event_name}: #{exc.class}: #{exc} (at #{exc.backtrace.first})" }
+              logger.debug { "di: failed to send #{event_name}: #{exc.class}: #{exc.message} (at #{exc.backtrace.first})" }
               telemetry&.report(exc, description: "Error sending #{event_type}")
             end
           end

data/lib/datadog/di/remote.rb

@@ -88,11 +88,11 @@ module Datadog
             # content as errored but with a somewhat different exception
             # message.
             # TODO assert content state (errored for this example)
-            content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
+            content.errored("Error applying dynamic instrumentation configuration: #{exc.class}: #{exc.message}")
           rescue => exc
             raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
 
-            component.logger.debug { "di: unhandled exception adding #{probe.type} probe at #{probe.location} (#{probe.id}) in DI remote receiver: #{exc.class}: #{exc}" }
+            component.logger.debug { "di: unhandled exception adding #{probe.type} probe at #{probe.location} (#{probe.id}) in DI remote receiver: #{exc.class}: #{exc.message}" }
             component.telemetry&.report(exc, description: "Unhandled exception adding probe in DI remote receiver")
 
             # TODO test this path
@@ -106,7 +106,7 @@ module Datadog
             # content as errored but with a somewhat different exception
             # message.
             # TODO assert content state (errored for this example)
-            content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
+            content.errored("Error applying dynamic instrumentation configuration: #{exc.class}: #{exc.message}")
           end
 
           # Important: even if processing fails for this probe config,
@@ -117,11 +117,11 @@ module Datadog
         rescue => exc
           raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
 
-          component.logger.debug { "di: unhandled exception handling a probe in DI remote receiver: #{exc.class}: #{exc}" }
+          component.logger.debug { "di: unhandled exception handling a probe in DI remote receiver: #{exc.class}: #{exc.message}" }
           component.telemetry&.report(exc, description: "Unhandled exception handling probe in DI remote receiver")
 
           # TODO assert content state (errored for this example)
-          content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
+          content.errored("Error applying dynamic instrumentation configuration: #{exc.class}: #{exc.message}")
         end
 
         # This method does not mark +previous_content+ as succeeded or errored,
@@ -136,7 +136,7 @@ module Datadog
         rescue => exc
           raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
 
-          component.logger.debug { "di: unhandled exception removing probes in DI remote receiver: #{exc.class}: #{exc}" }
+          component.logger.debug { "di: unhandled exception removing probes in DI remote receiver: #{exc.class}: #{exc.message}" }
           component.telemetry&.report(exc, description: "Unhandled exception removing probes in DI remote receiver")
         end
 

data/lib/datadog/di/serializer.rb

@@ -186,7 +186,7 @@ module Datadog
                 # surface errors so they can fix their serializers) or they may be defined
                 # internally by dd-trace-rb (in which case we need to fix them). We use
                 # WARN level to surface these errors in either case.
-                Datadog.logger.warn("DI: Custom serializer condition failed: #{e.class}: #{e}")
+                Datadog.logger.warn("DI: Custom serializer condition failed: #{e.class}: #{e.message}")
                 telemetry&.report(e, description: "Custom serializer condition failed")
                 next
               end

data/lib/datadog/di/transport/input.rb

@@ -81,14 +81,14 @@ module Datadog
               # Serialization failed for this snapshot - report via callback
               # This catches JSON::GeneratorError, Encoding errors, TypeError, etc.
               probe_id = snapshot.dig(:debugger, :snapshot, :probe, :id)
-              logger.debug { "di: JSON encoding failed for snapshot (probe #{probe_id}): #{exc.class}: #{exc}" }
+              logger.debug { "di: JSON encoding failed for snapshot (probe #{probe_id}): #{exc.class}: #{exc.message}" }
               telemetry&.report(exc, description: "JSON encoding failed for snapshot")
 
               if probe_id
                 begin
                   on_serialization_error.call(probe_id, exc)
                 rescue => callback_exc
-                  logger.debug { "di: error in serialization error callback for probe #{probe_id}: #{callback_exc.class}: #{callback_exc}" }
+                  logger.debug { "di: error in serialization error callback for probe #{probe_id}: #{callback_exc.class}: #{callback_exc.message}" }
                   telemetry&.report(callback_exc, description: "Error in serialization error callback")
                 end
               end
@@ -110,7 +110,7 @@ module Datadog
               begin
                 send_input_chunk(chunked_payload, serialized_tags)
               rescue => exc
-                logger.debug { "di: failed to send snapshot chunk: #{exc.class}: #{exc} (at #{exc.backtrace.first})" }
+                logger.debug { "di: failed to send snapshot chunk: #{exc.class}: #{exc.message} (at #{exc.backtrace.first})" }
                 telemetry&.report(exc, description: "Error sending snapshot chunk")
               end
             end

data/lib/datadog/error_tracking/configuration.rb

@@ -1,11 +1,64 @@
 # frozen_string_literal: true
 
+require_relative 'ext'
+
 module Datadog
   module ErrorTracking
     # Configuration for ErrorTracking
     module Configuration
+      # Settings
+      module Settings
+        def self.extended(base)
+          base = base.singleton_class unless base.is_a?(Class)
+          add_settings!(base)
+        end
+
+        def self.add_settings!(base)
+          base.class_eval do
+            # Error Tracking specific configurations.
+            # @public_api
+            settings :error_tracking do
+              # Enable automatic reporting of handled errors and defines the scope
+              # for which to report errors: user code, gems, or both. Possible
+              # values are: all | user | third_party.
+              #
+              # @default 'DD_ERROR_TRACKING_HANDLED_ERRORS' environment variable, otherwise `nil`
+              # @return [String, nil]
+              option :handled_errors do |o|
+                o.type :string, nilable: true
+                o.default Ext::DEFAULT_HANDLED_ERRORS
+                o.env Ext::ENV_HANDLED_ERRORS
+                o.setter do |value|
+                  next value if Ext::VALID_HANDLED_ERRORS.include?(value)
+
+                  unless value.nil?
+                    Datadog.logger.warn(
+                      "Invalid handled errors scope: #{value}. " \
+                      "Supported values are: #{Ext::VALID_HANDLED_ERRORS.join(" | ")}. " \
+                      'Deactivating the feature.'
+                    )
+                  end
+
+                  Ext::DEFAULT_HANDLED_ERRORS
+                end
+              end
+
+              # Enable automatic reporting of handled errors and specify what files should be
+              # instrumented. The value is a list of comma separated paths, filenames or gem names.
+              # The paths can be absolute, starting with '/' or relative to directory in which the program
+              # is launched, starting with './'.
+              #
+              # @default 'DD_ERROR_TRACKING_HANDLED_ERRORS_MODULES' environment variable, otherwise `nil`
+              # @return [String, nil]
+              option :handled_errors_include do |o|
+                o.type :array
+                o.default []
+                o.env Ext::ENV_HANDLED_ERRORS_INCLUDE
+              end
+            end
+          end
+        end
+      end
     end
   end
 end
-
-require_relative 'configuration/settings'

data/lib/datadog/kit/enable_core_dumps.rb

@@ -30,7 +30,7 @@ module Datadog
           Process.setrlimit(:CORE, maximum_size)
         rescue => e
           Kernel.warn(
-            "[datadog] Failed to enable core dumps. Cause: #{e.class}: #{e} " \
+            "[datadog] Failed to enable core dumps. Cause: #{e.class}: #{e.message} " \
             "Location: #{Array(e.backtrace).first}"
           )
           return

data/lib/datadog/open_feature/component.rb

@@ -6,12 +6,13 @@ require_relative 'exposures/buffer'
 require_relative 'exposures/worker'
 require_relative 'exposures/deduplicator'
 require_relative 'exposures/reporter'
+require_relative 'metrics/flag_eval_metrics'
 
 module Datadog
   module OpenFeature
     # This class is the entry point for the OpenFeature component
     class Component
-      attr_reader :engine
+      attr_reader :engine, :flag_eval_hook
 
       def self.build(settings, agent_settings, logger:, telemetry:)
         return unless settings.respond_to?(:open_feature) && settings.open_feature.enabled
@@ -50,11 +51,27 @@ module Datadog
 
         reporter = Exposures::Reporter.new(@worker, telemetry: telemetry, logger: logger)
         @engine = EvaluationEngine.new(reporter, telemetry: telemetry, logger: logger)
+
+        @telemetry = telemetry
+        @logger = logger
+        @flag_eval_hook = create_flag_eval_hook
       end
 
       def shutdown!
         @worker.graceful_shutdown
       end
+
+      private
+
+      def create_flag_eval_hook
+        require_relative 'hooks/flag_eval_hook'
+        return unless Hooks::FlagEvalHook.available?
+
+        metrics = Metrics::FlagEvalMetrics.new(telemetry: @telemetry, logger: @logger)
+        Hooks::FlagEvalHook.new(metrics)
+      rescue LoadError
+        nil
+      end
     end
   end
 end

data/lib/datadog/open_feature/evaluation_engine.rb

@@ -42,7 +42,7 @@ module Datadog
         @telemetry.report(e, description: 'OpenFeature: Failed to fetch flag value')
 
         ResolutionDetails.build_error(
-          value: default_value, error_code: Ext::GENERAL, error_message: e.message
+          value: default_value, error_code: Ext::GENERAL, error_message: "#{e.class}: #{e.message}"
         )
       end
 
@@ -60,10 +60,10 @@ module Datadog
       rescue => e
         message = 'OpenFeature: Failed to reconfigure, reverting to the previous configuration'
 
-        @logger.error("#{message}, #{e.class}: #{e}")
+        @logger.error("#{message}, #{e.class}: #{e.message}")
         @telemetry.report(e, description: "#{message} (#{e.class})")
 
-        raise ReconfigurationError, e.message
+        raise ReconfigurationError, "#{e.class}: #{e.message}"
       end
     end
   end

data/lib/datadog/open_feature/exposures/reporter.rb

@@ -29,7 +29,7 @@ module Datadog
           event = Event.build(result, flag_key: flag_key, context: context)
           @worker.enqueue(event)
         rescue => e
-          @logger.debug { "OpenFeature: Failed to report resolution details: #{e.class}: #{e}" }
+          @logger.debug { "OpenFeature: Failed to report resolution details: #{e.class}: #{e.message}" }
           @telemetry.report(e, description: 'OpenFeature: Failed to report resolution details')
 
           false

data/lib/datadog/open_feature/exposures/worker.rb

@@ -105,7 +105,7 @@ module Datadog
 
           response
         rescue => e
-          @logger.debug { "OpenFeature: Failed to flush resolution details events: #{e.class}: #{e}" }
+          @logger.debug { "OpenFeature: Failed to flush resolution details events: #{e.class}: #{e.message}" }
           @telemetry.report(e, description: 'OpenFeature: Failed to flush resolution details events')
 
           nil

data/lib/datadog/open_feature/hooks/flag_eval_hook.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module Hooks
+      # Records flag evaluation metrics via OpenTelemetry hook
+      #
+      # Compatible with OpenFeature SDK >= 0.5.0 which provides the Hooks::Hook module,
+      # but also works with older versions since the SDK uses respond_to?(:finally)
+      # to detect hook capabilities.
+      class FlagEvalHook
+        # Include the Hook module if available (SDK >= 0.5.0) for interface documentation
+        # and default implementations of other hook methods (before, after, error)
+        include ::OpenFeature::SDK::Hooks::Hook if defined?(::OpenFeature::SDK::Hooks::Hook)
+
+        # Returns true if the OpenFeature SDK supports hooks (>= 0.5.0)
+        def self.available?
+          !!defined?(::OpenFeature::SDK::Hooks::Hook)
+        end
+
+        def initialize(metrics)
+          @metrics = metrics
+        end
+
+        def finally(hook_context:, evaluation_details:, **_opts)
+          metrics = @metrics
+          return unless metrics
+
+          metrics.record(
+            hook_context.flag_key,
+            variant: evaluation_details.variant,
+            reason: evaluation_details.reason,
+            error_code: evaluation_details.error_code,
+            allocation_key: extract_allocation_key(evaluation_details),
+          )
+        end
+
+        private
+
+        def extract_allocation_key(evaluation_details)
+          metadata = evaluation_details.flag_metadata
+          return unless metadata.is_a?(Hash)
+
+          metadata['__dd_allocation_key']
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/metrics/flag_eval_metrics.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module Metrics
+      # Records flag evaluation metrics via OpenTelemetry
+      class FlagEvalMetrics
+        METER_NAME = 'ddtrace.openfeature'
+        METRIC_NAME = 'feature_flag.evaluations'
+        METRIC_UNIT = '{evaluation}'
+        METRIC_DESCRIPTION = 'Number of feature flag evaluations'
+
+        ATTR_FLAG_KEY = 'feature_flag.key'
+        ATTR_VARIANT = 'feature_flag.result.variant'
+        ATTR_REASON = 'feature_flag.result.reason'
+        ATTR_ALLOCATION_KEY = 'feature_flag.result.allocation_key'
+        ATTR_ERROR_TYPE = 'error.type'
+
+        DEFAULT_ERROR_TYPE = 'general'
+
+        ERROR_TYPE_MAP = {
+          'FLAG_NOT_FOUND' => 'flag_not_found',
+          'TYPE_MISMATCH' => 'type_mismatch',
+          'PARSE_ERROR' => 'parse_error',
+          'PROVIDER_NOT_READY' => 'provider_not_ready',
+          'TARGETING_KEY_MISSING' => 'targeting_key_missing',
+          'INVALID_CONTEXT' => 'invalid_context',
+          'PROVIDER_FATAL' => 'provider_fatal',
+          'GENERAL' => DEFAULT_ERROR_TYPE,
+        }.freeze
+
+        # Reasons that should not include allocation_key in metrics
+        EXCLUDE_ALLOCATION_KEY_REASONS = %w[error default disabled].freeze
+
+        def initialize(telemetry:, logger:)
+          @telemetry = telemetry
+          @logger = logger
+          @enabled = Datadog.configuration.opentelemetry.metrics.enabled
+          @counter = nil
+          @mutex = Mutex.new
+
+          unless @enabled
+            @logger.debug { 'OpenFeature: OTel metrics not enabled (DD_METRICS_OTEL_ENABLED=false), flag evaluation metrics disabled' }
+          end
+        end
+
+        def record(flag_key, variant:, reason:, error_code: nil, allocation_key: nil)
+          return unless @enabled
+
+          counter = get_or_create_counter
+          return unless counter
+
+          attributes = build_attributes(
+            flag_key,
+            variant: variant,
+            reason: reason,
+            error_code: error_code,
+            allocation_key: allocation_key,
+          )
+          counter.add(1, attributes: attributes)
+        rescue => e
+          @logger.debug { "OpenFeature: Failed to record evaluation metric: #{e.class}: #{e.message}" }
+          @telemetry.report(e, description: 'OpenFeature: Failed to record evaluation metric')
+        end
+
+        private
+
+        # Counter is created lazily because OTel SDK may not be initialized
+        # when the OpenFeature component is created.
+        def get_or_create_counter
+          @mutex.synchronize do
+            return @counter if @counter
+
+            meter_provider = get_or_initialize_meter_provider
+            return unless meter_provider
+
+            meter = meter_provider.meter(METER_NAME)
+            @counter = meter.create_counter(
+              METRIC_NAME,
+              unit: METRIC_UNIT,
+              description: METRIC_DESCRIPTION
+            )
+          end
+        rescue => e
+          @logger.debug { "OpenFeature: Failed to create metrics counter: #{e.class}: #{e.message}" }
+          nil
+        end
+
+        # Fetch an available OTel meter provider, initializing if needed.
+        # Returns the meter provider if available, nil otherwise.
+        def get_or_initialize_meter_provider
+          meter_provider = defined?(::OpenTelemetry) ? ::OpenTelemetry.meter_provider : nil
+          return meter_provider if sdk_meter_provider?(meter_provider)
+
+          @logger.debug { 'OpenFeature: Initializing OTel meter provider directly' }
+          require 'opentelemetry-metrics-sdk'
+          require 'datadog/opentelemetry/metrics'
+          Datadog::OpenTelemetry::Metrics.initialize!(Datadog.send(:components))
+
+          meter_provider = ::OpenTelemetry.meter_provider
+          sdk_meter_provider?(meter_provider) ? meter_provider : nil
+        rescue LoadError => e
+          @logger.debug { "OpenFeature: Failed to initialize OTel metrics: #{e.class}: #{e.message}" }
+          nil
+        end
+
+        def sdk_meter_provider?(meter_provider)
+          return false if meter_provider.nil?
+          return false unless defined?(::OpenTelemetry::SDK::Metrics::MeterProvider)
+
+          meter_provider.is_a?(::OpenTelemetry::SDK::Metrics::MeterProvider)
+        end
+
+        def build_attributes(flag_key, variant:, reason:, error_code:, allocation_key:)
+          reason_downcase = normalize_reason(reason)
+
+          attrs = {
+            ATTR_FLAG_KEY => flag_key,
+            ATTR_VARIANT => variant.to_s,
+            ATTR_REASON => reason_downcase,
+          }
+
+          if allocation_key && !allocation_key.empty? && !exclude_allocation_key?(reason_downcase)
+            attrs[ATTR_ALLOCATION_KEY] = allocation_key
+          end
+
+          if error_code
+            attrs[ATTR_ERROR_TYPE] = normalize_error_type(error_code)
+          end
+
+          attrs
+        end
+
+        def normalize_reason(reason)
+          reason = reason.to_s
+          reason.empty? ? 'unknown' : reason.downcase
+        end
+
+        def normalize_error_type(error_code)
+          ERROR_TYPE_MAP.fetch(error_code.to_s, DEFAULT_ERROR_TYPE)
+        end
+
+        def exclude_allocation_key?(reason_downcase)
+          EXCLUDE_ALLOCATION_KEY_REASONS.include?(reason_downcase)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/open_feature/provider.rb

@@ -7,6 +7,8 @@ module Datadog
   module OpenFeature
     # OpenFeature feature flagging provider backed by Datadog Remote Configuration.
     #
+    # Requires openfeature-sdk >= 0.5.1 for flag evaluation metrics support.
+    #
     # Implementation follows the OpenFeature contract of Provider SDK.
     # For details see:
     #   - https://github.com/open-feature/ruby-sdk/blob/v0.4.1/README.md#develop-a-provider
@@ -67,6 +69,11 @@ module Datadog
         # no-op
       end
 
+      def hooks
+        hook = Datadog.send(:components).open_feature&.flag_eval_hook
+        [hook].compact
+      end
+
       def fetch_boolean_value(flag_key:, default_value:, evaluation_context: nil)
         evaluate(flag_key, default_value: default_value, expected_type: :boolean, evaluation_context: evaluation_context)
       end
@@ -117,7 +124,7 @@ module Datadog
           value: result.value,
           variant: result.variant,
           reason: result.reason,
-          flag_metadata: result.flag_metadata
+          flag_metadata: build_flag_metadata(result),
         )
       rescue => e
         ::OpenFeature::SDK::Provider::ResolutionDetails.new(
@@ -128,6 +135,17 @@ module Datadog
         )
       end
 
+      def build_flag_metadata(result)
+        metadata = result.flag_metadata || {}
+        allocation_key = result.allocation_key
+        if allocation_key && !allocation_key.empty?
+          metadata = metadata.dup
+          metadata['__dd_allocation_key'] = allocation_key
+        end
+
+        metadata
+      end
+
       def component_not_configured_default(value)
         ::OpenFeature::SDK::Provider::ResolutionDetails.new(
           value: value,

data/lib/datadog/open_feature/remote.rb

@@ -41,7 +41,7 @@ module Datadog
                   engine.reconfigure!(read_content(content))
                   content.applied
                 rescue EvaluationEngine::ReconfigurationError => e
-                  content.errored("Error applying OpenFeature configuration: #{e.class}: #{e}")
+                  content.errored("Error applying OpenFeature configuration: #{e.class}: #{e.message}")
                 end
               when :delete
                 # NOTE: For now, we treat deletion as clearing the configuration

data/lib/datadog/open_feature/transport.rb

@@ -55,7 +55,7 @@ module Datadog
             @api.call(env)
           end
         rescue => e
-          message = "Internal error during request. Cause: #{e.class}: #{e} " \
+          message = "Internal error during request. Cause: #{e.class}: #{e.message} " \
                     "Location: #{Array(e.backtrace).first}"
           @logger.debug(message)
 

data/lib/datadog/opentelemetry/metrics.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../core/configuration/ext'
+require_relative '../core/environment/socket'
 
 module Datadog
   module OpenTelemetry
@@ -11,7 +12,7 @@ module Datadog
         new(components).configure_metrics_sdk
         true
       rescue => exc
-        components.logger.error("Failed to initialize OpenTelemetry metrics: #{exc.class}: #{exc}: #{exc.backtrace.join("\n")}")
+        components.logger.error("Failed to initialize OpenTelemetry metrics: #{exc.class}: #{exc.message}: #{exc.backtrace.join("\n")}")
         false
       end
 
@@ -42,7 +43,6 @@ module Datadog
 
       def create_resource
         resource_attributes = {}
-        resource_attributes['host.name'] = Datadog::Core::Environment::Socket.hostname if @settings.tracing.report_hostname
 
         @settings.tags&.each do |key, value|
           otel_key = case key
@@ -58,6 +58,15 @@ module Datadog
         resource_attributes['deployment.environment'] = @settings.env if @settings.env
         resource_attributes['service.version'] = @settings.version if @settings.version
 
+        hostname = Datadog::Core::Environment::Socket.resolved_hostname(@settings)
+        if hostname
+          if hostname == @settings.hostname
+            resource_attributes['host.name'] = hostname
+          elsif !resource_attributes.key?('host.name')
+            resource_attributes['host.name'] = hostname
+          end
+        end
+
         ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
       end
 
@@ -67,7 +76,7 @@ module Datadog
 
         configure_otlp_exporter(provider)
       rescue => e
-        @logger.warn("Failed to configure OTLP metrics exporter:  #{e.class}: #{e}")
+        @logger.warn("Failed to configure OTLP metrics exporter:  #{e.class}: #{e.message}")
       end
 
       def default_metrics_endpoint
@@ -101,7 +110,7 @@ module Datadog
         )
         provider.add_metric_reader(reader)
       rescue LoadError => e
-        @logger.warn("Could not load OTLP metrics exporter:  #{e.class}: #{e}")
+        @logger.warn("Could not load OTLP metrics exporter:  #{e.class}: #{e.message}")
       end
 
       # Returns metrics config value if explicitly set, otherwise falls back to exporter config or computed default value.

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

@@ -37,7 +37,7 @@ module Datadog
           begin
             require 'opentelemetry-metrics-sdk'
           rescue LoadError => exc
-            components.logger.warn("Failed to load OpenTelemetry metrics gems: #{exc.class}: #{exc}")
+            components.logger.warn("Failed to load OpenTelemetry metrics gems: #{exc.class}: #{exc.message}")
             return super
           end