datadog 2.37.0 → 2.39.0

data/lib/datadog/data_streams/processor.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-require 'zlib'
-require_relative 'pathway_context'
-require_relative 'transport/http'
-require_relative '../version'
-require_relative '../core/worker'
-require_relative '../core/workers/polling'
-require_relative '../core/ddsketch'
-require_relative '../core/buffer/cruby'
-require_relative '../core/utils/time'
-require_relative '../core/utils/fnv'
+require "zlib"
+require_relative "pathway_context"
+require_relative "transport/http"
+require_relative "../version"
+require_relative "../core/worker"
+require_relative "../core/workers/polling"
+require_relative "../core/ddsketch"
+require_relative "../core/buffer/cruby"
+require_relative "../core/utils/time"
+require_relative "../core/utils/fnv"
 
 module Datadog
   module DataStreams
@@ -22,7 +22,7 @@ module Datadog
     class Processor < Core::Worker
       include Core::Workers::Polling
 
-      PROPAGATION_KEY = 'dd-pathway-ctx-base64'
+      PROPAGATION_KEY = "dd-pathway-ctx-base64"
 
       # Default buffer size for lock-free event queue
       # Set to handle high-throughput scenarios (e.g., 10k events/sec for 10s interval)
@@ -41,7 +41,7 @@ module Datadog
       #   (default: DEFAULT_BUFFER_SIZE). Higher values support more throughput but use more memory.
       # @raise [UnsupportedError] if DDSketch is not available on this platform
       def initialize(interval:, logger:, settings:, agent_settings:, agent_info:, buffer_size: DEFAULT_BUFFER_SIZE)
-        raise UnsupportedError, 'DDSketch is not supported' unless Datadog::Core::DDSketch.supported?
+        raise UnsupportedError, "DDSketch is not supported" unless Datadog::Core::DDSketch.supported?
 
         @settings = settings
         @agent_settings = agent_settings
@@ -112,8 +112,8 @@ module Datadog
       # @yield [key, value] Block to inject context into carrier
       # @return [String] Base64 encoded pathway context
       def set_produce_checkpoint(type:, destination:, manual_checkpoint: true, tags: {}, &block)
-        checkpoint_tags = ["type:#{type}", "topic:#{destination}", 'direction:out']
-        checkpoint_tags << 'manual_checkpoint:true' if manual_checkpoint
+        checkpoint_tags = ["type:#{type}", "topic:#{destination}", "direction:out"]
+        checkpoint_tags << "manual_checkpoint:true" if manual_checkpoint
         checkpoint_tags.concat(tags.map { |k, v| "#{k}:#{v}" }) unless tags.empty?
 
         span = Datadog::Tracing.active_span
@@ -140,8 +140,8 @@ module Datadog
           end
         end
 
-        checkpoint_tags = ["type:#{type}", "topic:#{source}", 'direction:in']
-        checkpoint_tags << 'manual_checkpoint:true' if manual_checkpoint
+        checkpoint_tags = ["type:#{type}", "topic:#{source}", "direction:in"]
+        checkpoint_tags << "manual_checkpoint:true" if manual_checkpoint
         checkpoint_tags.concat(tags.map { |k, v| "#{k}:#{v}" }) unless tags.empty?
 
         span = Datadog::Tracing.active_span
@@ -228,7 +228,7 @@ module Datadog
         bucket_time_ns = now_ns - (now_ns % @bucket_size_ns)
         bucket = @buckets[bucket_time_ns] ||= create_bucket
 
-        aggr_key = [event[:tags].join(','), event[:hash], event[:parent_hash]]
+        aggr_key = [event[:tags].join(","), event[:hash], event[:parent_hash]]
         stats = bucket[:pathway_stats][aggr_key] ||= create_pathway_stats
 
         stats[:edge_latency].add(event[:edge_latency_sec])
@@ -247,7 +247,7 @@ module Datadog
 
         direction = nil # : ::String?
         tags.each do |tag|
-          if tag.start_with?('direction:')
+          if tag.start_with?("direction:")
             direction = tag
             break
           end
@@ -272,7 +272,7 @@ module Datadog
         new_hash = compute_pathway_hash(parent_hash, tags)
 
         # Tag the APM span with the pathway hash to link DSM and APM
-        span&.set_tag('pathway.hash', new_hash.to_s)
+        span&.set_tag("pathway.hash", new_hash.to_s)
 
         edge_latency_sec = [now - current_context.current_edge_start, 0.0].max
         full_pathway_latency_sec = [now - current_context.pathway_start, 0.0].max
@@ -316,15 +316,15 @@ module Datadog
         end
 
         payload = {
-          'Env' => @settings.env || 'none',
-          'Service' => @settings.service,
-          'TracerVersion' => Datadog::VERSION::STRING,
-          'Lang' => 'ruby',
-          'Stats' => stats_buckets,
-          'Hostname' => hostname
+          "Env" => @settings.env || "none",
+          "Service" => @settings.service,
+          "TracerVersion" => Datadog::VERSION::STRING,
+          "Lang" => "ruby",
+          "Stats" => stats_buckets,
+          "Hostname" => hostname
         } # : ::Hash[::String, (::String | ::Array[::String])]
 
-        payload['ProcessTags'] = Core::Environment::Process.tags if @settings.experimental_propagate_process_tags_enabled
+        payload["ProcessTags"] = Core::Environment::Process.tags if @settings.experimental_propagate_process_tags_enabled
 
         # Send to agent outside mutex to avoid blocking customer code if agent is slow/hung.
         send_stats_to_agent(payload)
@@ -357,9 +357,9 @@ module Datadog
       end
 
       def decode_and_set_pathway_context(headers)
-        return unless headers && headers['dd-pathway-ctx-base64']
+        return unless headers && headers["dd-pathway-ctx-base64"]
 
-        pathway_ctx = decode_pathway_context(headers['dd-pathway-ctx-base64'])
+        pathway_ctx = decode_pathway_context(headers["dd-pathway-ctx-base64"])
         set_pathway_context(pathway_ctx) if pathway_ctx
       end
 
@@ -369,21 +369,21 @@ module Datadog
       # The hash only needs to be internally consistent:
       # @see Datadog::Core::Environment::AgentInfo#container_tags_checksum
       def compute_pathway_hash(current_hash, tags)
-        service = @settings.service || 'ruby-service'
-        env = @settings.env || 'none'
+        service = @settings.service || "ruby-service"
+        env = @settings.env || "none"
 
         bytes = service.bytes + env.bytes
 
         if @settings.experimental_propagate_process_tags_enabled
           propagation_checksum = @agent_info.propagation_checksum
-          bytes += [propagation_checksum].pack('Q<').bytes if propagation_checksum
+          bytes += [propagation_checksum].pack("Q<").bytes if propagation_checksum
         end
 
         tags.each { |tag| bytes += tag.bytes }
-        byte_string = bytes.pack('C*')
+        byte_string = bytes.pack("C*")
 
         node_hash = Core::Utils::FNV.fnv1_64(byte_string)
-        combined_bytes = [node_hash, current_hash].pack('QQ')
+        combined_bytes = [node_hash, current_hash].pack("QQ")
         Core::Utils::FNV.fnv1_64(combined_bytes)
       end
 
@@ -433,38 +433,38 @@ module Datadog
           bucket_stats = []
           bucket[:pathway_stats].each do |aggr_key, stats|
             edge_tags_str, hash_value, parent_hash = aggr_key
-            edge_tags_array = edge_tags_str.split(',')
+            edge_tags_array = edge_tags_str.split(",")
 
             bucket_stats << {
-              'EdgeTags' => edge_tags_array,
-              'Hash' => hash_value,
-              'ParentHash' => parent_hash,
-              'PathwayLatency' => stats[:full_pathway_latency].encode,
-              'EdgeLatency' => stats[:edge_latency].encode,
+              "EdgeTags" => edge_tags_array,
+              "Hash" => hash_value,
+              "ParentHash" => parent_hash,
+              "PathwayLatency" => stats[:full_pathway_latency].encode,
+              "EdgeLatency" => stats[:edge_latency].encode,
             }
           end
 
           backlogs = []
           bucket[:latest_produce_offsets].each do |key, offset|
-            topic, partition = key.split(':', 2)
+            topic, partition = key.split(":", 2)
             backlogs << {
-              'Tags' => ['type:kafka_produce', "topic:#{topic}", "partition:#{partition}"],
-              'Value' => offset
+              "Tags" => ["type:kafka_produce", "topic:#{topic}", "partition:#{partition}"],
+              "Value" => offset
             }
           end
           bucket[:latest_commit_offsets].each do |key, offset|
-            group, topic, partition = key.split(':', 3)
+            group, topic, partition = key.split(":", 3)
             backlogs << {
-              'Tags' => ['type:kafka_commit', "consumer_group:#{group}", "topic:#{topic}", "partition:#{partition}"],
-              'Value' => offset
+              "Tags" => ["type:kafka_commit", "consumer_group:#{group}", "topic:#{topic}", "partition:#{partition}"],
+              "Value" => offset
             }
           end
 
           serialized_buckets << {
-            'Start' => bucket_time_ns,
-            'Duration' => @bucket_size_ns,
-            'Stats' => bucket_stats,
-            'Backlogs' => backlogs + serialize_consumer_backlogs
+            "Start" => bucket_time_ns,
+            "Duration" => @bucket_size_ns,
+            "Stats" => bucket_stats,
+            "Backlogs" => backlogs + serialize_consumer_backlogs
           }
         end
 
@@ -476,12 +476,12 @@ module Datadog
       def serialize_consumer_backlogs
         @consumer_stats.map do |stat|
           {
-            'Tags' => [
-              'type:kafka_commit',
+            "Tags" => [
+              "type:kafka_commit",
               "topic:#{stat[:topic]}",
               "partition:#{stat[:partition]}"
             ],
-            'Value' => stat[:offset]
+            "Value" => stat[:offset]
           }
         end
       end

data/lib/datadog/data_streams/transport/http/stats.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../stats'
-require_relative '../../../core/transport/http/api/endpoint'
-require_relative '../../../core/transport/http/response'
+require_relative "../stats"
+require_relative "../../../core/transport/http/api/endpoint"
+require_relative "../../../core/transport/http/response"
 
 module Datadog
   module DataStreams
@@ -32,10 +32,10 @@ module Datadog
                 env.path = path
                 env.body = env.request.parcel.data
                 if (content_type = env.request.parcel.content_type)
-                  env.headers['content-type'] = content_type
+                  env.headers["content-type"] = content_type
                 end
                 if (content_encoding = env.request.parcel.content_encoding)
-                  env.headers['content-encoding'] = content_encoding
+                  env.headers["content-encoding"] = content_encoding
                 end
 
                 # Send request

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../../core/transport/http'
-require_relative 'http/stats'
-require_relative 'stats'
+require_relative "../../core/transport/http"
+require_relative "http/stats"
+require_relative "stats"
 
 module Datadog
   module DataStreams
@@ -10,7 +10,7 @@ module Datadog
       # HTTP transport for Data Streams Monitoring
       module HTTP
         V01 = Stats::API::Endpoint.new(
-          '/v0.1/pipeline_stats'
+          "/v0.1/pipeline_stats"
         )
 
         module_function
@@ -24,7 +24,7 @@ module Datadog
             agent_settings: agent_settings,
             logger: logger,
           ) do |transport|
-            transport.api 'v0.1', V01, default: true
+            transport.api "v0.1", V01, default: true
 
             # Call block to apply any customization, if provided
             yield(transport) if block_given?

data/lib/datadog/data_streams/transport/stats.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require 'msgpack'
-require 'zlib'
-require_relative '../../core/transport/parcel'
-require_relative '../../core/transport/request'
-require_relative '../../core/transport/transport'
+require "msgpack"
+require "zlib"
+require_relative "../../core/transport/parcel"
+require_relative "../../core/transport/request"
+require_relative "../../core/transport/transport"
 
 module Datadog
   module DataStreams
@@ -24,8 +24,8 @@ module Datadog
             # Create parcel and request
             parcel = Core::Transport::Parcel.new(
               compressed_data,
-              content_type: 'application/msgpack',
-              content_encoding: 'gzip',
+              content_type: "application/msgpack",
+              content_encoding: "gzip",
             )
             request = Request.new(parcel)
 

data/lib/datadog/data_streams.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative 'data_streams/processor'
-require_relative 'data_streams/pathway_context'
-require_relative 'data_streams/configuration'
-require_relative 'data_streams/extensions'
-require_relative 'core/utils/time'
+require_relative "data_streams/processor"
+require_relative "data_streams/pathway_context"
+require_relative "data_streams/configuration"
+require_relative "data_streams/extensions"
+require_relative "core/utils/time"
 
 module Datadog
   # Datadog Data Streams Monitoring public API.

data/lib/datadog/di/base.rb

@@ -8,11 +8,11 @@
 # are loaded, and also none of the rest of datadog library which also
 # has contrib code in other products.
 
-require_relative 'fatal_exceptions'
-require_relative 'code_tracker'
+require_relative "fatal_exceptions"
+require_relative "code_tracker"
 
 # Needed since this file can be loaded without core
-require_relative '../ruby_version'
+require_relative "../ruby_version"
 
 module Datadog
   # Namespace for Datadog dynamic instrumentation.
@@ -48,7 +48,7 @@ module Datadog
       # DI code.
       def activate_tracking
         # :script_compiled trace point was added in Ruby 2.6.
-        return unless RubyVersion.is?('>= 2.6')
+        return unless RubyVersion.is?(">= 2.6")
 
         begin
           # Activate code tracking by default because line trace points will not work

data/lib/datadog/di/boot.rb

@@ -1,24 +1,27 @@
 # frozen_string_literal: true
 
-require_relative 'logger'
-require_relative 'base'
-require_relative 'error'
-require_relative 'code_tracker'
-require_relative 'component'
-require_relative 'context'
-require_relative 'instrumenter'
-require_relative 'probe'
-require_relative 'probe_builder'
-require_relative 'probe_manager'
-require_relative 'probe_notification_builder'
-require_relative 'probe_notifier_worker'
-require_relative 'probe_repository'
-require_relative 'redactor'
-require_relative 'serializer'
-require_relative 'transport/http'
-require_relative 'utils'
+require_relative "logger"
+require_relative "base"
+require_relative "error"
+require_relative "code_tracker"
+require_relative "component"
+require_relative "context"
+require_relative "capture_limits"
+require_relative "capture_expression"
+require_relative "capture_expression_evaluator"
+require_relative "instrumenter"
+require_relative "probe"
+require_relative "probe_builder"
+require_relative "probe_manager"
+require_relative "probe_notification_builder"
+require_relative "probe_notifier_worker"
+require_relative "probe_repository"
+require_relative "redactor"
+require_relative "serializer"
+require_relative "transport/http"
+require_relative "utils"
 
-if %w[1 true yes].include?(Datadog::DATADOG_ENV['DD_DYNAMIC_INSTRUMENTATION_ENABLED'])
+if %w[1 true yes].include?(Datadog::DATADOG_ENV["DD_DYNAMIC_INSTRUMENTATION_ENABLED"])
 
   # For initial release of Dynamic Instrumentation, activate code tracking
   # only if DI is explicitly requested in the environment.
@@ -32,13 +35,13 @@ if %w[1 true yes].include?(Datadog::DATADOG_ENV['DD_DYNAMIC_INSTRUMENTATION_ENAB
   Datadog::DI.activate_tracking
 end
 
-require_relative 'contrib'
+require_relative "contrib"
 
 Datadog::DI::Contrib.load_now_or_later
 
-if %w[1 true yes].include?(Datadog::DATADOG_ENV['DD_DYNAMIC_INSTRUMENTATION_ENABLED'])
-  if Datadog::DATADOG_ENV['DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE']
-    require_relative 'probe_file_loader'
+if %w[1 true yes].include?(Datadog::DATADOG_ENV["DD_DYNAMIC_INSTRUMENTATION_ENABLED"])
+  if Datadog::DATADOG_ENV["DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE"]
+    require_relative "probe_file_loader"
     Datadog::DI::ProbeFileLoader.load_now_or_later
   end
 end

data/lib/datadog/di/capture_expression.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "capture_limits"
+
+module Datadog
+  module DI
+    class CaptureExpression
+      def initialize(name:, expr:, limits: nil)
+        @name = name
+        @expr = expr
+        @limits = limits
+      end
+
+      attr_reader :name
+
+      attr_reader :expr
+
+      attr_reader :limits
+    end
+  end
+end

data/lib/datadog/di/capture_expression_evaluator.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "capture_expression"
+require_relative "capture_limits"
+require_relative "fatal_exceptions"
+
+module Datadog
+  module DI
+    class CaptureExpressionEvaluator
+      TELEMETRY_NAMESPACE = "dynamic_instrumentation"
+
+      def initialize(settings:, serializer:, logger:, telemetry: nil)
+        @settings = settings
+        @serializer = serializer
+        @logger = logger
+        @telemetry = telemetry
+      end
+
+      attr_reader :settings
+
+      attr_reader :serializer
+
+      attr_reader :logger
+
+      attr_reader :telemetry
+
+      def evaluate(probe, context)
+        budget_ns = settings.dynamic_instrumentation.max_time_to_serialize_ms * 1_000_000
+        deadline_ns = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :nanosecond) + budget_ns
+
+        output = {}
+        evaluation_errors = []
+
+        probe.capture_expressions.each do |capture_expression|
+          name = capture_expression.name
+
+          if ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :nanosecond) >= deadline_ns
+            output[name] = {notCapturedReason: "timeout"}
+            telemetry&.inc(TELEMETRY_NAMESPACE, "capture_expressions_skipped_by_timeout", 1)
+            next
+          end
+
+          begin
+            value = capture_expression.expr.evaluate(context)
+            limits = CaptureLimits.resolve(
+              expr_limits: capture_expression.limits,
+              probe: probe,
+              settings: settings,
+            )
+            output[name] = serializer.serialize_value(
+              value, name: name,
+              depth: limits[:depth],
+              attribute_count: limits[:attribute_count],
+              length: limits[:length],
+              collection_size: limits[:collection_size],
+            )
+          rescue Exception => exc # standard:disable Lint/RescueException
+            Datadog::DI.reraise_if_fatal(exc)
+            evaluation_errors << {expr: name, message: "#{exc.class}: #{exc.message}"}
+            logger.debug do
+              "di: probe #{probe.id}: capture expression #{name}: evaluation failed: #{exc.class}: #{exc.message}"
+            end
+            telemetry&.report(exc, description: "DI capture-expression evaluation failed")
+          end
+        end
+
+        [output, evaluation_errors]
+      end
+    end
+  end
+end

data/lib/datadog/di/capture_limits.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Datadog
+  module DI
+    class CaptureLimits
+      def initialize(max_reference_depth: nil, max_collection_size: nil,
+        max_length: nil, max_field_count: nil)
+        @max_reference_depth = max_reference_depth
+        @max_collection_size = max_collection_size
+        @max_length = max_length
+        @max_field_count = max_field_count
+      end
+
+      attr_reader :max_reference_depth
+
+      attr_reader :max_collection_size
+
+      attr_reader :max_length
+
+      attr_reader :max_field_count
+
+      def self.resolve(expr_limits:, probe:, settings:)
+        di = settings.dynamic_instrumentation
+        {
+          depth: expr_limits&.max_reference_depth ||
+            probe.max_capture_depth ||
+            di.max_capture_depth,
+          collection_size: expr_limits&.max_collection_size ||
+            probe.max_capture_collection_size ||
+            di.max_capture_collection_size,
+          length: expr_limits&.max_length ||
+            probe.max_capture_string_length ||
+            di.max_capture_string_length,
+          attribute_count: expr_limits&.max_field_count ||
+            probe.max_capture_attribute_count ||
+            di.max_capture_attribute_count,
+        }
+      end
+    end
+  end
+end

data/lib/datadog/di/code_tracker.rb

@@ -2,8 +2,8 @@
 
 # rubocop:disable Lint/AssignmentInCondition
 
-require_relative 'error'
-require_relative 'fatal_exceptions'
+require_relative "error"
+require_relative "fatal_exceptions"
 
 module Datadog
   module DI
@@ -275,8 +275,8 @@ module Datadog
               if inexact.any?
                 return inexact.first
               end
-              break unless working_suffix.include?('/')
-              working_suffix.sub!(%r{.*/+}, '')
+              break unless working_suffix.include?("/")
+              working_suffix.sub!(%r{.*/+}, "")
             end
           end
           nil
@@ -393,8 +393,8 @@ module Datadog
             matches = paths.select { |p| Utils.path_matches_suffix?(p, working_suffix, case_insensitive: case_insensitive) }
             raise Error::MultiplePathsMatch, "Multiple paths matched requested suffix" if matches.length > 1
             return matches.first if matches.any?
-            break unless working_suffix.include?('/')
-            working_suffix.sub!(%r{.*/+}, '')
+            break unless working_suffix.include?("/")
+            working_suffix.sub!(%r{.*/+}, "")
           end
         end
         nil

data/lib/datadog/di/component.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'fatal_exceptions'
+require_relative "fatal_exceptions"
 
 module Datadog
   module DI
@@ -76,7 +76,7 @@ module Datadog
         @serializer = Serializer.new(settings, redactor, telemetry: telemetry)
         @instrumenter = Instrumenter.new(settings, serializer, logger, code_tracker: code_tracker, telemetry: telemetry)
         @probe_repository = ProbeRepository.new
-        @probe_notification_builder = ProbeNotificationBuilder.new(settings, serializer)
+        @probe_notification_builder = ProbeNotificationBuilder.new(settings, serializer, logger, telemetry: telemetry)
         @probe_notifier_worker = ProbeNotifierWorker.new(
           settings, logger,
           agent_settings: agent_settings,
@@ -123,6 +123,14 @@ module Datadog
         @lifecycle_mutex.synchronize do
           return if @started
 
+          # DI.activate_tracking creates the global code tracker lazily. When DI
+          # is enabled after boot via remote configuration (in-product
+          # enablement), this component and its instrumenter were built with a
+          # nil tracker; adopt the now-current global tracker so line probes
+          # can be targeted.
+          @code_tracker = DI.code_tracker
+          instrumenter.code_tracker = @code_tracker
+
           probe_notifier_worker.start
           probe_manager.reopen
           @started = true
@@ -185,19 +193,19 @@ module Datadog
       end
 
       def parse_probe_spec_and_notify(probe_spec)
-        probe = ProbeBuilder.build_from_remote_config(probe_spec)
+        probe = ProbeBuilder.build_from_remote_config(probe_spec, logger: logger)
       rescue Exception => exc # standard:disable Lint/RescueException
         Datadog::DI.reraise_if_fatal(exc)
         begin
           probe = Struct.new(:id).new(
-            probe_spec['id'],
+            probe_spec["id"],
           )
           payload = probe_notification_builder.build_errored(probe, exc)
           probe_notifier_worker.add_status(payload)
         rescue Exception => nested_exc # standard:disable Lint/RescueException
           Datadog::DI.reraise_if_fatal(nested_exc)
           logger.debug { "di: failed to build error notification: #{nested_exc.class}: #{nested_exc.message}" }
-          telemetry&.report(nested_exc, description: 'Error building probe error notification')
+          telemetry&.report(nested_exc, description: "Error building probe error notification")
           raise
         end
 

data/lib/datadog/di/configuration.rb

@@ -134,6 +134,12 @@ module Datadog
                 o.default 20
               end
 
+              option :max_time_to_serialize_ms do |o|
+                o.type :int
+                o.default 200
+                o.env "DD_DYNAMIC_INSTRUMENTATION_MAX_TIME_TO_SERIALIZE"
+              end
+
               # Settings in the 'internal' group are for internal Datadog
               # use only, and are needed to test dynamic instrumentation or
               # experiment with features not released to customers.
@@ -223,7 +229,7 @@ module Datadog
                   # dedicated environment variable in the future but
                   # will likely need a way to turn on remote config
                   # debugging (since DI uses RC for configuration).
-                  o.env 'DD_TRACE_DEBUG'
+                  o.env "DD_TRACE_DEBUG"
                 end
 
                 # If the CPU time consumed by the thread performing instrumentation