newrelic_rpm 6.8.0.360 → 8.13.1

data/lib/new_relic/agent/datastores/mongo.rb

@@ -1,28 +1,23 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     module Datastores
       module Mongo
         def self.is_supported_version?
-          # No version constant in < 2.0 versions of Mongo :(
-          defined?(::Mongo) && (defined?(::Mongo::MongoClient) || is_monitoring_enabled?)
-        end
-
-        def self.is_monitoring_enabled?
-          defined?(::Mongo::Monitoring)
+          defined?(::Mongo) && is_monitoring_enabled?
         end
 
         def self.is_unsupported_2x?
-          defined?(::Mongo::VERSION) && Gem::Version.new(::Mongo::VERSION).segments[0] == 2 &&
+          defined?(::Mongo::VERSION) &&
+            Gem::Version.new(::Mongo::VERSION).segments[0] == 2 &&
             !self.is_monitoring_enabled?
         end
 
-        def self.is_version_1_10_or_later?
-          # Again, no VERSION constant in 1.x, so we have to rely on constant checks
-          defined?(::Mongo::CollectionOperationWriter)
+        def self.is_monitoring_enabled?
+          defined?(::Mongo::Monitoring) # @since 2.1.0
         end
       end
     end

data/lib/new_relic/agent/datastores/nosql_obfuscator.rb

@@ -0,0 +1,41 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module Datastores
+      module NosqlObfuscator
+        ALLOWLIST = [:operation].freeze
+
+        def self.obfuscate_statement(source, allowlist = ALLOWLIST)
+          if source.is_a?(Hash)
+            obfuscated = {}
+            source.each do |key, value|
+              if allowlist.include?(key)
+                obfuscated[key] = value
+              else
+                obfuscated[key] = obfuscate_value(value, allowlist)
+              end
+            end
+            obfuscated
+          else
+            obfuscate_value(source, allowlist)
+          end
+        end
+
+        QUESTION_MARK = '?'.freeze
+
+        def self.obfuscate_value(value, allowlist = ALLOWLIST)
+          if value.is_a?(Hash)
+            obfuscate_statement(value, allowlist)
+          elsif value.is_a?(Array)
+            value.map { |v| obfuscate_value(v, allowlist) }
+          else
+            QUESTION_MARK
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/datastores/redis.rb

@@ -1,20 +1,16 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     module Datastores
       module Redis
-        MULTI_OPERATION = 'multi'
-        PIPELINE_OPERATION = 'pipeline'
         BINARY_DATA_PLACEHOLDER = "<binary data>"
-        PRODUCT_NAME = 'Redis'
-        CONNECT = 'connect'
 
         MAXIMUM_COMMAND_LENGTH = 1000
         MAXIMUM_ARGUMENT_LENGTH = 64
-        CHUNK_SIZE   = (MAXIMUM_ARGUMENT_LENGTH - 5) / 2
+        CHUNK_SIZE = (MAXIMUM_ARGUMENT_LENGTH - 5) / 2
         PREFIX_RANGE = (0...CHUNK_SIZE)
         SUFFIX_RANGE = (-CHUNK_SIZE..-1)
 
@@ -29,20 +25,18 @@ module NewRelic
 
         def self.format_command(command_with_args)
           if Agent.config[:'transaction_tracer.record_redis_arguments']
-            result = ""
+            result = String.new('')
 
             append_command_with_args(result, command_with_args)
 
             trim_result(result) if result.length >= MAXIMUM_COMMAND_LENGTH
             result.strip!
             result
-          else
-            nil
           end
         end
 
         def self.format_pipeline_commands(commands_with_args)
-          result = ""
+          result = String.new('')
 
           commands_with_args.each do |command|
             if result.length >= MAXIMUM_COMMAND_LENGTH
@@ -121,7 +115,7 @@ module NewRelic
         end
 
         def self.trim_result(result)
-          result.slice!((MAXIMUM_COMMAND_LENGTH-ELLIPSES.length)..-1)
+          result.slice!((MAXIMUM_COMMAND_LENGTH - ELLIPSES.length)..-1)
           result.strip!
           result << ELLIPSES
         end

data/lib/new_relic/agent/datastores.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/datastores/metric_helper'
 
@@ -13,7 +13,6 @@ module NewRelic
     #
     # @api public
     module Datastores
-
       # @!group Tracing query methods
 
       # Add Datastore tracing to a method. This properly generates the metrics
@@ -21,7 +20,7 @@ module NewRelic
       # query content into Transaction Traces. Use wrap if you want to provide
       # that functionality.
       #
-      # @param [Class] clazz the class to instrument
+      # @param [Class] klass the class to instrument
       #
       # @param [String, Symbol] method_name the name of instance method to
       #   instrument
@@ -33,18 +32,18 @@ module NewRelic
       #
       # @api public
       #
-      def self.trace(clazz, method_name, product, operation = method_name)
+      def self.trace(klass, method_name, product, operation = method_name)
         NewRelic::Agent.record_api_supportability_metric(:trace)
 
-        clazz.class_eval do
+        klass.class_eval do
           method_name_without_newrelic = "#{method_name}_without_newrelic"
 
-          if NewRelic::Helper.instance_methods_include?(clazz, method_name) &&
-             !NewRelic::Helper.instance_methods_include?(clazz, method_name_without_newrelic)
+          if NewRelic::Helper.instance_methods_include?(klass, method_name) &&
+              !NewRelic::Helper.instance_methods_include?(klass, method_name_without_newrelic)
 
-            visibility = NewRelic::Helper.instance_method_visibility(clazz, method_name)
+            visibility = NewRelic::Helper.instance_method_visibility(klass, method_name)
 
-            alias_method method_name_without_newrelic, method_name
+            alias_method(method_name_without_newrelic, method_name)
 
             define_method(method_name) do |*args, &blk|
               segment = NewRelic::Agent::Tracer.start_datastore_segment(
@@ -58,8 +57,8 @@ module NewRelic
               end
             end
 
-            send visibility, method_name
-            send visibility, method_name_without_newrelic
+            send(visibility, method_name)
+            send(visibility, method_name_without_newrelic)
           end
         end
       end
@@ -123,7 +122,7 @@ module NewRelic
         ensure
           begin
             if callback
-              elapsed_time = (Time.now - segment.start_time).to_f
+              elapsed_time = Process.clock_gettime(Process::CLOCK_REALTIME) - segment.start_time
               callback.call(result, segment.name, elapsed_time)
             end
           ensure
@@ -202,7 +201,6 @@ module NewRelic
         end
         nil
       end
-
     end
   end
 end

data/lib/new_relic/agent/deprecator.rb

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent

data/lib/new_relic/agent/{cross_app_payload.rb → distributed_tracing/cross_app_payload.rb}

@@ -1,6 +1,6 @@
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
@@ -8,28 +8,29 @@ module NewRelic
       attr_reader :id, :transaction, :referring_guid, :referring_trip_id, :referring_path_hash
 
       def initialize(id, transaction, transaction_info)
-        @id                  = id
-        @transaction         = transaction
+        @id = id
+        @transaction = transaction
 
         transaction_info ||= []
-        @referring_guid      = transaction_info[0]
+        @referring_guid = transaction_info[0]
         # unused_flag        = transaction_info[1]
-        @referring_trip_id   = string_or_false_for(transaction_info[2])
+        @referring_trip_id = string_or_false_for(transaction_info[2])
         @referring_path_hash = string_or_false_for(transaction_info[3])
       end
 
       def as_json_array(content_length)
-        queue_time_in_seconds = [transaction.queue_time.to_f, 0.0].max
-        start_time_in_seconds = [transaction.start_time.to_f, 0.0].max
-        app_time_in_seconds   = Time.now.to_f - start_time_in_seconds
+        queue_time_in_seconds = [transaction.queue_time, 0.0].max
+        start_time_in_seconds = [transaction.start_time, 0.0].max
+        app_time_in_seconds = Process.clock_gettime(Process::CLOCK_REALTIME) - start_time_in_seconds
 
         [
           NewRelic::Agent.config[:cross_process_id],
           transaction.best_name,
-          queue_time_in_seconds.to_f,
-          app_time_in_seconds.to_f,
+          queue_time_in_seconds,
+          app_time_in_seconds,
           content_length,
-          transaction.guid
+          transaction.guid,
+          false
         ]
       end
 

data/lib/new_relic/agent/{cross_app_tracing.rb → distributed_tracing/cross_app_tracing.rb}

@@ -1,7 +1,7 @@
 # -*- ruby -*-
-# encoding: utf-8
 # This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'json'
 
@@ -9,23 +9,22 @@ module NewRelic
   module Agent
     module CrossAppTracing
       # The cross app response header for "outgoing" calls
-      NR_APPDATA_HEADER = 'X-NewRelic-App-Data'.freeze
+      NR_APPDATA_HEADER = 'X-NewRelic-App-Data'
 
       # The cross app id header for "outgoing" calls
-      NR_ID_HEADER = 'X-NewRelic-ID'.freeze
+      NR_ID_HEADER = 'X-NewRelic-ID'
 
       # The cross app transaction header for "outgoing" calls
-      NR_TXN_HEADER = 'X-NewRelic-Transaction'.freeze
+      NR_TXN_HEADER = 'X-NewRelic-Transaction'
 
-      NR_MESSAGE_BROKER_ID_HEADER  = 'NewRelicID'.freeze
-      NR_MESSAGE_BROKER_TXN_HEADER = 'NewRelicTransaction'.freeze
-      NR_MESSAGE_BROKER_SYNTHETICS_HEADER = 'NewRelicSynthetics'.freeze
+      NR_MESSAGE_BROKER_ID_HEADER = 'NewRelicID'
+      NR_MESSAGE_BROKER_TXN_HEADER = 'NewRelicTransaction'
+      NR_MESSAGE_BROKER_SYNTHETICS_HEADER = 'NewRelicSynthetics'
 
       attr_accessor :is_cross_app_caller, :cross_app_payload, :cat_path_hashes
 
       def is_cross_app_caller?
-        @is_cross_app_caller = false unless defined? @is_cross_app_caller
-        @is_cross_app_caller
+        @is_cross_app_caller ||= false
       end
 
       def is_cross_app_callee?
@@ -37,28 +36,66 @@ module NewRelic
       end
 
       def cat_trip_id
-        cross_app_payload && cross_app_payload.referring_trip_id || guid
+        cross_app_payload && cross_app_payload.referring_trip_id || transaction.guid
+      end
+
+      def cross_app_monitor
+        NewRelic::Agent.instance.monitors.cross_app_monitor
       end
 
       def cat_path_hash
         referring_path_hash = cat_referring_path_hash || '0'
         seed = referring_path_hash.to_i(16)
-        result = NewRelic::Agent.instance.cross_app_monitor.path_hash(best_name, seed)
+        result = cross_app_monitor.path_hash(transaction.best_name, seed)
         record_cat_path_hash(result)
         result
       end
 
-      def add_message_cat_headers headers
-        self.is_cross_app_caller = true
-        CrossAppTracing.insert_message_headers headers,
-                                               guid,
-                                               cat_trip_id,
-                                               cat_path_hash,
-                                               raw_synthetics_header
+      def insert_cross_app_header(headers)
+        return unless CrossAppTracing.cross_app_enabled?
+
+        @is_cross_app_caller = true
+        txn_guid = transaction.guid
+        trip_id = cat_trip_id
+        path_hash = cat_path_hash
+
+        insert_request_headers(headers, txn_guid, trip_id, path_hash)
+      end
+
+      def add_message_cat_headers(headers)
+        return unless CrossAppTracing.cross_app_enabled?
+
+        @is_cross_app_caller = true
+        insert_message_headers(headers,
+          transaction.guid,
+          cat_trip_id,
+          cat_path_hash,
+          transaction.raw_synthetics_header)
+      end
+
+      def record_cross_app_metrics
+        if (id = cross_app_payload && cross_app_payload.id)
+          app_time_in_seconds = [
+            Process.clock_gettime(Process::CLOCK_REALTIME) - transaction.start_time,
+            0.0
+          ].max
+          NewRelic::Agent.record_metric("ClientApplication/#{id}/all", app_time_in_seconds)
+        end
+      end
+
+      def assign_cross_app_intrinsics
+        transaction.attributes.add_intrinsic_attribute(:trip_id, cat_trip_id)
+        transaction.attributes.add_intrinsic_attribute(:path_hash, cat_path_hash)
       end
 
       private
 
+      def insert_message_headers(headers, txn_guid, trip_id, path_hash, synthetics_header)
+        headers[NR_MESSAGE_BROKER_ID_HEADER] = obfuscator.obfuscate(Agent.config[:cross_process_id])
+        headers[NR_MESSAGE_BROKER_TXN_HEADER] = obfuscator.obfuscate(::JSON.dump([txn_guid, false, trip_id, path_hash]))
+        headers[NR_MESSAGE_BROKER_SYNTHETICS_HEADER] = synthetics_header if synthetics_header
+      end
+
       def record_cat_path_hash(hash)
         @cat_path_hashes ||= []
         if @cat_path_hashes.size < 10 && !@cat_path_hashes.include?(hash)
@@ -75,15 +112,17 @@ module NewRelic
           payload[:referring_transaction_guid] = referring_guid
         end
 
-        return unless include_guid?
-        payload[:guid] = guid
+        return unless transaction.include_guid?
+
+        payload[:guid] = transaction.guid
 
         return unless is_cross_app?
-        trip_id             = cat_trip_id
-        path_hash           = cat_path_hash
+
+        trip_id = cat_trip_id
+        path_hash = cat_path_hash
         referring_path_hash = cat_referring_path_hash
 
-        payload[:cat_trip_id]             = trip_id             if trip_id
+        payload[:cat_trip_id] = trip_id if trip_id
         payload[:cat_referring_path_hash] = referring_path_hash if referring_path_hash
 
         if path_hash
@@ -96,20 +135,9 @@ module NewRelic
         end
       end
 
-      def assign_cross_app_intrinsics
-        attributes.add_intrinsic_attribute(:trip_id, cat_trip_id)
-        attributes.add_intrinsic_attribute(:path_hash, cat_path_hash)
-      end
-
-      def record_cross_app_metrics
-        if (id = cross_app_payload && cross_app_payload.id)
-          app_time_in_seconds = [Time.now.to_f - @start_time.to_f, 0.0].max
-          NewRelic::Agent.record_metric "ClientApplication/#{id}/all", app_time_in_seconds
-        end
-      end
-
       ###############
       module_function
+
       ###############
 
       def cross_app_enabled?
@@ -119,19 +147,19 @@ module NewRelic
       end
 
       def valid_cross_process_id?
-        if NewRelic::Agent.config[:cross_process_id] && NewRelic::Agent.config[:cross_process_id].length > 0
+        if Agent.config[:cross_process_id] && Agent.config[:cross_process_id].length > 0
           true
         else
-          NewRelic::Agent.logger.debug "No cross_process_id configured"
+          NewRelic::Agent.logger.debug("No cross_process_id configured")
           false
         end
       end
 
       def valid_encoding_key?
-        if NewRelic::Agent.config[:encoding_key] && NewRelic::Agent.config[:encoding_key].length > 0
+        if Agent.config[:encoding_key] && Agent.config[:encoding_key].length > 0
           true
         else
-          NewRelic::Agent.logger.debug "No encoding_key set"
+          NewRelic::Agent.logger.debug("No encoding_key set")
           false
         end
       end
@@ -143,14 +171,14 @@ module NewRelic
       end
 
       def obfuscator
-        @obfuscator ||= NewRelic::Agent::Obfuscator.new(NewRelic::Agent.config[:encoding_key])
+        @obfuscator ||= NewRelic::Agent::Obfuscator.new(Agent.config[:encoding_key])
       end
 
-      def insert_request_headers request, txn_guid, trip_id, path_hash
+      def insert_request_headers(request, txn_guid, trip_id, path_hash)
         cross_app_id = NewRelic::Agent.config[:cross_process_id]
-        txn_data  = ::JSON.dump([txn_guid, false, trip_id, path_hash])
+        txn_data = ::JSON.dump([txn_guid, false, trip_id, path_hash])
 
-        request[NR_ID_HEADER]  = obfuscator.obfuscate(cross_app_id)
+        request[NR_ID_HEADER] = obfuscator.obfuscate(cross_app_id)
         request[NR_TXN_HEADER] = obfuscator.obfuscate(txn_data)
       end
 
@@ -158,7 +186,7 @@ module NewRelic
         if !!response[NR_APPDATA_HEADER]
           true
         else
-          NewRelic::Agent.logger.debug "No #{NR_APPDATA_HEADER} header"
+          NewRelic::Agent.logger.debug("No #{NR_APPDATA_HEADER} header")
           false
         end
       end
@@ -188,44 +216,38 @@ module NewRelic
         !!(xp_id =~ /\A\d+#\d+\z/)
       end
 
-      def insert_message_headers headers, txn_guid, trip_id, path_hash, synthetics_header
-        headers[NR_MESSAGE_BROKER_ID_HEADER]  = obfuscator.obfuscate(NewRelic::Agent.config[:cross_process_id])
-        headers[NR_MESSAGE_BROKER_TXN_HEADER] = obfuscator.obfuscate(::JSON.dump([txn_guid, false, trip_id, path_hash]))
-        headers[NR_MESSAGE_BROKER_SYNTHETICS_HEADER] = synthetics_header if synthetics_header
-      end
-
-      def message_has_crossapp_request_header? headers
+      def message_has_crossapp_request_header?(headers)
         !!headers[NR_MESSAGE_BROKER_ID_HEADER]
       end
 
-      def reject_messaging_cat_headers headers
-        headers.reject {|k,_| k == NR_MESSAGE_BROKER_ID_HEADER || k == NR_MESSAGE_BROKER_TXN_HEADER}
+      def reject_messaging_cat_headers(headers)
+        headers.reject { |k, _| k == NR_MESSAGE_BROKER_ID_HEADER || k == NR_MESSAGE_BROKER_TXN_HEADER }
       end
 
-      def trusts? id
+      def trusts?(id)
         split_id = id.match(/(\d+)#\d+/)
         return false if split_id.nil?
 
-        NewRelic::Agent.config[:trusted_account_ids].include? split_id.captures.first.to_i
+        NewRelic::Agent.config[:trusted_account_ids].include?(split_id.captures.first.to_i)
       end
 
-      def trusted_valid_cross_app_id? id
+      def trusted_valid_cross_app_id?(id)
         valid_cross_app_id?(id) && trusts?(id)
       end
 
       # From inbound request headers
-      def assign_intrinsic_transaction_attributes state
+      def assign_intrinsic_transaction_attributes(state)
         # We expect to get the before call to set the id (if we have it) before
         # this, and then write our custom parameter when the transaction starts
-        return unless (transaction       = state.current_transaction)
-        return unless (cross_app_payload = transaction.cross_app_payload)
+        return unless (txn = state.current_transaction)
+        return unless (payload = txn.distributed_tracer.cross_app_payload)
 
-        if (cross_app_id = cross_app_payload.id)
-          transaction.attributes.add_intrinsic_attribute(:client_cross_process_id, cross_app_id)
+        if (cross_app_id = payload.id)
+          txn.attributes.add_intrinsic_attribute(:client_cross_process_id, cross_app_id)
         end
 
-        if (referring_guid = cross_app_payload.referring_guid)
-          transaction.attributes.add_intrinsic_attribute(:referring_transaction_guid, referring_guid)
+        if (referring_guid = payload.referring_guid)
+          txn.attributes.add_intrinsic_attribute(:referring_transaction_guid, referring_guid)
         end
       end
     end

data/lib/new_relic/agent/distributed_tracing/distributed_trace_attributes.rb

@@ -0,0 +1,84 @@
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
+
+module NewRelic
+  module Agent
+    module DistributedTraceAttributes
+      extend self
+
+      # Intrinsic Keys
+      INTRINSIC_KEYS = [
+        PARENT_TYPE_KEY = "parent.type",
+        PARENT_APP_KEY = "parent.app",
+        PARENT_ACCOUNT_ID_KEY = "parent.account",
+        PARENT_TRANSPORT_TYPE_KEY = "parent.transportType",
+        PARENT_TRANSPORT_DURATION_KEY = "parent.transportDuration",
+        GUID_KEY = "guid",
+        TRACE_ID_KEY = "traceId",
+        PARENT_TRANSACTION_ID_KEY = "parentId",
+        PARENT_SPAN_ID_KEY = "parentSpanId",
+        SAMPLED_KEY = "sampled"
+      ].freeze
+
+      # This method extracts intrinsics from the transaction_payload and
+      # inserts them into the specified destination.
+      def copy_to_hash(transaction_payload, destination)
+        return unless enabled?
+
+        INTRINSIC_KEYS.each do |key|
+          value = transaction_payload[key]
+          destination[key] = value unless value.nil?
+        end
+      end
+
+      # This method extracts intrinsics from the transaction_payload and
+      # inserts them as intrinsics in the specified transaction_attributes
+      def copy_to_attributes(transaction_payload, destination)
+        return unless enabled?
+
+        INTRINSIC_KEYS.each do |key|
+          next unless transaction_payload.key?(key)
+
+          destination.add_intrinsic_attribute(key, transaction_payload[key])
+        end
+      end
+
+      # This method takes all distributed tracing intrinsics from the transaction
+      # and the trace_payload, and populates them into the destination
+      def copy_from_transaction(transaction, trace_payload, destination)
+        destination[GUID_KEY] = transaction.guid
+        destination[SAMPLED_KEY] = transaction.sampled?
+        destination[TRACE_ID_KEY] = transaction.trace_id
+
+        if transaction.parent_span_id
+          destination[PARENT_SPAN_ID_KEY] = transaction.parent_span_id
+        end
+
+        copy_parent_attributes(transaction, trace_payload, destination)
+      end
+
+      def copy_parent_attributes(transaction, trace_payload, destination)
+        transport_type = transaction.distributed_tracer.caller_transport_type
+        destination[PARENT_TRANSPORT_TYPE_KEY] = DistributedTraceTransportType.from(transport_type)
+
+        if trace_payload
+          destination[PARENT_TYPE_KEY] = trace_payload.parent_type
+          destination[PARENT_APP_KEY] = trace_payload.parent_app_id
+          destination[PARENT_ACCOUNT_ID_KEY] = trace_payload.parent_account_id
+          destination[PARENT_TRANSPORT_DURATION_KEY] = transaction.calculate_transport_duration(trace_payload)
+
+          if parent_transaction_id = transaction.distributed_tracer.parent_transaction_id
+            destination[PARENT_TRANSACTION_ID_KEY] = parent_transaction_id
+          end
+        end
+      end
+
+      private
+
+      def enabled?
+        return Agent.config[:'distributed_tracing.enabled']
+      end
+    end
+  end
+end