newrelic_rpm 3.12.0.288 → 9.10.2

data/lib/new_relic/local_environment.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 'set'
 require 'new_relic/version'
@@ -26,7 +26,7 @@ module NewRelic
   #
   # If the environment can't be determined, it will be set to nil.
   #
-  # NewRelic::LocalEnvironment should be accessed through NewRelic::Control#env (via the NewRelic::Control singleton).
+  # NewRelic::LocalEnvironment should be accessed through NewRelic::Control#local_env (via the NewRelic::Control singleton).
   class LocalEnvironment
     def discovered_dispatcher
       discover_dispatcher unless @discovered_dispatcher
@@ -34,13 +34,14 @@ module NewRelic
     end
 
     def initialize
-      # Extend self with any any submodules of LocalEnvironment.  These can override
-      # the discover methods to discover new framworks and dispatchers.
-      NewRelic::LocalEnvironment.constants.each do | const |
-        mod = NewRelic::LocalEnvironment.const_get const
-        self.extend mod if mod.instance_of? Module
+      # Extend self with any submodules of LocalEnvironment.  These can override
+      # the discover methods to discover new frameworks and dispatchers.
+      NewRelic::LocalEnvironment.constants.each do |const|
+        mod = NewRelic::LocalEnvironment.const_get(const)
+        self.extend(mod) if mod.instance_of?(Module)
       end
 
+      @discovered_dispatcher = nil
       discover_dispatcher
     end
 
@@ -59,30 +60,32 @@ module NewRelic
 
     def discover_dispatcher
       dispatchers = %w[
+        serverless
+        puma
+        sidekiq
+        falcon
+        delayed_job
+        unicorn
         passenger
+        resque
         torquebox
         trinidad
         glassfish
-        resque
-        sidekiq
-        delayed_job
-        puma
         thin
         mongrel
         litespeed
         webrick
         fastcgi
-        rainbows
-        unicorn
       ]
       while dispatchers.any? && @discovered_dispatcher.nil?
-        send 'check_for_'+(dispatchers.shift)
+        send('check_for_' + (dispatchers.shift))
       end
     end
 
     def check_for_torquebox
       return unless defined?(::JRuby) &&
-         ( org.torquebox::TorqueBox rescue nil)
+        (org.torquebox::TorqueBox rescue nil)
+
       @discovered_dispatcher = :torquebox
     end
 
@@ -91,11 +94,13 @@ module NewRelic
         (((com.sun.grizzly.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
           defined?(com::sun::grizzly::jruby::rack::DefaultRackApplicationFactory)) ||
          (jruby_rack? && defined?(::GlassFish::Server)))
+
       @discovered_dispatcher = :glassfish
     end
 
     def check_for_trinidad
       return unless defined?(::JRuby) && jruby_rack? && defined?(::Trinidad::Server)
+
       @discovered_dispatcher = :trinidad
     end
 
@@ -105,38 +110,42 @@ module NewRelic
 
     def check_for_webrick
       return unless defined?(::WEBrick) && defined?(::WEBrick::VERSION)
+
       @discovered_dispatcher = :webrick
     end
 
     def check_for_fastcgi
       return unless defined?(::FCGI)
+
       @discovered_dispatcher = :fastcgi
     end
 
     # this case covers starting by mongrel_rails
     def check_for_mongrel
       return unless defined?(::Mongrel) && defined?(::Mongrel::HttpServer)
+
       @discovered_dispatcher = :mongrel
     end
 
     def check_for_unicorn
-      if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && NewRelic::LanguageSupport.object_space_usable?
-        v = find_class_in_object_space(::Unicorn::HttpServer)
-        @discovered_dispatcher = :unicorn if v
-      end
-    end
+      return unless (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) &&
+        NewRelic::LanguageSupport.object_space_usable?
 
-    def check_for_rainbows
-      if (defined?(::Rainbows) && defined?(::Rainbows::HttpServer)) && NewRelic::LanguageSupport.object_space_usable?
-        v = find_class_in_object_space(::Rainbows::HttpServer)
-        @discovered_dispatcher = :rainbows if v
-      end
+      v = find_class_in_object_space(::Unicorn::HttpServer)
+      @discovered_dispatcher = :unicorn if v
     end
 
     def check_for_puma
-      if defined?(::Puma) && File.basename($0) == 'puma'
-        @discovered_dispatcher = :puma
-      end
+      return unless defined?(::Puma) && File.basename($0) == 'puma'
+
+      @discovered_dispatcher = :puma
+    end
+
+    def check_for_falcon
+      return unless defined?(::Falcon::Server) &&
+        NewRelic::LanguageSupport.object_space_usable?
+
+      @discovered_dispatcher = :falcon if find_class_in_object_space(::Falcon::Server)
     end
 
     def check_for_delayed_job
@@ -146,9 +155,9 @@ module NewRelic
     end
 
     def check_for_resque
-      has_queue              = ENV['QUEUE'] || ENV['QUEUES']
-      resque_rake            = executable == 'rake' && ARGV.include?('resque:work')
-      resque_pool_rake       = executable == 'rake' && ARGV.include?('resque:pool')
+      has_queue = ENV['QUEUE'] || ENV['QUEUES']
+      resque_rake = executable == 'rake' && ARGV.include?('resque:work')
+      resque_pool_rake = executable == 'rake' && ARGV.include?('resque:pool')
       resque_pool_executable = executable == 'resque-pool' && defined?(::Resque::Pool)
 
       using_resque = defined?(::Resque) &&
@@ -179,28 +188,32 @@ module NewRelic
     end
 
     def check_for_litespeed
-      if caller.pop =~ /fcgi-bin\/RailsRunner\.rb/
-        @discovered_dispatcher = :litespeed
-      end
+      return unless caller.pop.include?('fcgi-bin/RailsRunner.rb')
+
+      @discovered_dispatcher = :litespeed
     end
 
     def check_for_passenger
-      if defined?(::PhusionPassenger)
-        @discovered_dispatcher = :passenger
-      end
+      return unless defined?(::PhusionPassenger)
+
+      @discovered_dispatcher = :passenger
+    end
+
+    def check_for_serverless
+      return unless NewRelic::Agent.config[:'serverless_mode.enabled']
+
+      @discovered_dispatcher = :serverless
     end
 
     public
+
     # outputs a human-readable description
     def to_s
-      s = "LocalEnvironment["
-      s << ";dispatcher=#{@discovered_dispatcher}" if @discovered_dispatcher
-      s << "]"
+      %Q(LocalEnvironment[#{";dispatcher=#{@discovered_dispatcher}" if @discovered_dispatcher}])
     end
 
     def executable
       File.basename($0)
     end
-
   end
 end

data/lib/new_relic/metric_data.rb

@@ -1,74 +1,72 @@
-# 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/coerce'
 
 module NewRelic
   class MetricData
-    # nil, or a NewRelic::MetricSpec object if we have no cached ID
-    attr_accessor :metric_spec
-    # nil or a cached integer ID for the metric from the collector.
-    attr_accessor :metric_id
-    # the actual statistics object
+    # a NewRelic::MetricSpec object
+    attr_reader :metric_spec
+    # a NewRelic::Agent::Stats object
     attr_accessor :stats
 
-    def initialize(metric_spec, stats, metric_id)
+    include NewRelic::Coerce
+
+    def initialize(metric_spec, stats)
+      @original_spec = nil
       @metric_spec = metric_spec
       self.stats = stats
-      self.metric_id = metric_id
     end
 
     def eql?(o)
-     (metric_spec.eql? o.metric_spec) && (stats.eql? o.stats)
+      (metric_spec.eql?(o.metric_spec)) && (stats.eql?(o.stats))
     end
 
-    def original_spec
-      @original_spec || @metric_spec
+    def hash
+      [metric_spec, stats].hash
+    end
+
+    def inspect
+      "#<MetricData metric_spec:#{metric_spec.inspect}, stats:#{stats.inspect}>"
     end
 
     # assigns a new metric spec, and retains the old metric spec as
     # @original_spec if it exists currently
-    def metric_spec= new_spec
+    def metric_spec=(new_spec)
       @original_spec = @metric_spec if @metric_spec
       @metric_spec = new_spec
     end
 
-    def hash
-      metric_spec.hash ^ stats.hash
+    def original_spec
+      @original_spec || @metric_spec
     end
 
-    # Serialize with all attributes, but if the metric id is not nil, then don't send the metric spec
-    def to_json(*a)
-       %Q[{"metric_spec":#{metric_id ? 'null' : metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}},"metric_id":#{metric_id ? metric_id : 'null'}}]
+    def to_collector_array(encoder = nil)
+      stat_key = {'name' => metric_spec.name, 'scope' => metric_spec.scope}
+      [stat_key, stats_collector_array(stat_key)]
     end
 
-    def to_s
-      if metric_spec
-        "#{metric_spec.name}(#{metric_spec.scope}): #{stats}"
-      else
-        "#{metric_id}: #{stats}"
-      end
+    def to_json(*a)
+      %Q({"metric_spec":#{metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}}})
     end
 
-    def inspect
-      "#<MetricData metric_spec:#{metric_spec.inspect}, stats:#{stats.inspect}, metric_id:#{metric_id.inspect}>"
+    def to_s
+      "#{metric_spec.name}(#{metric_spec.scope}): #{stats}"
     end
 
-    include NewRelic::Coerce
+    private
 
-    def to_collector_array(encoder=nil)
-      stat_key = metric_id || { 'name' => metric_spec.name, 'scope' => metric_spec.scope }
-      [ stat_key,
-        [
-          int(stats.call_count, stat_key),
-          float(stats.total_call_time, stat_key),
-          float(stats.total_exclusive_time, stat_key),
-          float(stats.min_call_time, stat_key),
-          float(stats.max_call_time, stat_key),
-          float(stats.sum_of_squares, stat_key)
-        ]
-      ]
+    def stats_collector_array(stat_key)
+      [[:call_count, Integer], [:total_call_time, Float],
+        [:total_exclusive_time, Float], [:min_call_time, Float],
+        [:max_call_time, Float], [:sum_of_squares, Float]].map do |attr_types|
+        if attr_types[1].eql?(Integer)
+          int(stats.send(attr_types[0]), stat_key)
+        elsif attr_types[1].eql?(Float)
+          float(stats.send(attr_types[0]), stat_key)
+        end
+      end
     end
   end
 end

data/lib/new_relic/metric_spec.rb

@@ -1,18 +1,18 @@
-# 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
 
 # this struct uniquely defines a metric, optionally inside
 # the call scope of another metric
 class NewRelic::MetricSpec
-  attr_reader   :name, :scope
+  attr_reader :name, :scope
 
   # the maximum length of a metric name or metric scope
   MAX_LENGTH = 255
   LENGTH_RANGE = (0...MAX_LENGTH)
   EMPTY_SCOPE = ''.freeze
 
-  def initialize(metric_name='', metric_scope=nil)
+  def initialize(metric_name = '', metric_scope = nil)
     if metric_name.to_s.length > MAX_LENGTH
       @name = metric_name.to_s[LENGTH_RANGE]
     else
@@ -34,33 +34,17 @@ class NewRelic::MetricSpec
     self.eql?(o)
   end
 
-  def eql? o
+  def eql?(o)
     @name == o.name && @scope == o.scope
   end
 
   def hash
-    @name.hash ^ @scope.hash
-  end
-
-  # return a new metric spec if the given regex
-  # matches the name or scope.
-  def sub(pattern, replacement, apply_to_scope = true)
-    ::NewRelic::Agent.logger.warn("The sub method on metric specs is deprecated") rescue nil
-    return nil if name !~ pattern &&
-     (!apply_to_scope || scope.nil? || scope !~ pattern)
-    new_name = name.sub(pattern, replacement)[LENGTH_RANGE]
-
-    if apply_to_scope
-      new_scope = (scope && scope.sub(pattern, replacement)[LENGTH_RANGE])
-    else
-      new_scope = scope
-    end
-
-    self.class.new new_name, new_scope
+    [@name, @scope].hash
   end
 
   def to_s
     return name if scope.empty?
+
     "#{name}:#{scope}"
   end
 
@@ -70,12 +54,13 @@ class NewRelic::MetricSpec
 
   def to_json(*a)
     {'name' => name,
-    'scope' => scope}.to_json(*a)
+     'scope' => scope}.to_json(*a)
   end
 
   def <=>(o)
     namecmp = self.name <=> o.name
     return namecmp if namecmp != 0
+
     return (self.scope || '') <=> (o.scope || '')
   end
 end

data/lib/new_relic/noticed_error.rb

@@ -1,26 +1,42 @@
-# 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/helper'
 require 'new_relic/agent/attribute_filter'
+require 'new_relic/collection_helper'
 
 # This class encapsulates an error that was noticed by New Relic in a managed app.
 class NewRelic::NoticedError
   extend NewRelic::CollectionHelper
 
   attr_accessor :path, :timestamp, :message, :exception_class_name,
-                :request_uri, :file_name, :line_number, :stack_trace,
-                :attributes_from_notice_error, :attributes
+    :request_uri, :request_port, :file_name, :line_number,
+    :stack_trace, :attributes_from_notice_error, :attributes,
+    :expected, :transaction_id
 
-  attr_reader   :exception_id, :is_internal
+  attr_reader :error_group, :exception_id, :is_internal
 
   STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE = "Message removed by New Relic 'strip_exception_messages' setting"
+  UNKNOWN_ERROR_CLASS_NAME = 'Error'
+  NIL_ERROR_MESSAGE = '<no message>'
 
-  def initialize(path, exception, timestamp = Time.now)
+  USER_ATTRIBUTES = 'userAttributes'
+  AGENT_ATTRIBUTES = 'agentAttributes'
+  INTRINSIC_ATTRIBUTES = 'intrinsics'
+
+  DESTINATION = NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR
+
+  AGENT_ATTRIBUTE_ERROR_GROUP = :'error.group.name'
+
+  ERROR_PREFIX_KEY = 'error'
+  ERROR_MESSAGE_KEY = "#{ERROR_PREFIX_KEY}.message"
+  ERROR_CLASS_KEY = "#{ERROR_PREFIX_KEY}.class"
+  ERROR_EXPECTED_KEY = "#{ERROR_PREFIX_KEY}.expected"
+
+  def initialize(path, exception, timestamp = Process.clock_gettime(Process::CLOCK_REALTIME), expected = false)
     @exception_id = exception.object_id
     @path = path
-    @exception_class_name = exception.is_a?(Exception) ? exception.class.name : 'Error'
 
     # It's critical that we not hold onto the exception class constant in this
     # class. These objects get serialized for Resque to a process that might
@@ -28,22 +44,8 @@ class NewRelic::NoticedError
     # while we have the actual exception!
     @is_internal = (exception.class < NewRelic::Agent::InternalAgentError)
 
-    if exception.nil?
-      @message = '<no message>'
-    elsif exception.respond_to?('original_exception')
-      @message = (exception.original_exception || exception).to_s
-    else # exception is not nil, but does not respond to original_exception
-      @message = exception.to_s
-    end
-
-
-    unless @message.is_a?(String)
-      # In pre-1.9.3, Exception.new({}).to_s.class != String
-      # That is, Exception#to_s may not return a String instance if one wasn't
-      # passed in upon creation of the Exception. So, try to generate a useful
-      # String representation of the exception message, falling back to failsafe
-      @message = String(@message.inspect) rescue '<unknown message type>'
-    end
+    extract_class_name_and_message_from(exception)
+    @transaction_id = NewRelic::Agent::Tracer&.current_transaction&.guid
 
     # clamp long messages to 4k so that we don't send a lot of
     # overhead across the wire
@@ -51,18 +53,14 @@ class NewRelic::NoticedError
 
     # replace error message if enabled
     if NewRelic::Agent.config[:'strip_exception_messages.enabled'] &&
-       !self.class.passes_message_whitelist(exception.class)
+        !self.class.passes_message_allowlist(exception.class)
       @message = STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE
     end
 
+    @attributes_from_notice_error = nil
+    @attributes = nil
     @timestamp = timestamp
-  end
-
-  # @exception_class has been deprecated in favor of the more descriptive
-  # @exception_class_name.
-  # @deprecated
-  def exception_class
-    exception_class_name
+    @expected = expected
   end
 
   def ==(other)
@@ -73,44 +71,44 @@ class NewRelic::NoticedError
     end
   end
 
-  def self.passes_message_whitelist(exception_class)
-    NewRelic::Agent.config.stripped_exceptions_whitelist.any? do |klass|
+  def self.passes_message_allowlist(exception_class)
+    NewRelic::Agent.config[:'strip_exception_messages.allowed_classes'].any? do |klass|
       exception_class <= klass
     end
   end
 
   include NewRelic::Coerce
 
-  def to_collector_array(encoder=nil)
-    [ NewRelic::Helper.time_to_millis(timestamp),
+  def to_collector_array(encoder = nil)
+    arr = [NewRelic::Helper.time_to_millis(timestamp),
       string(path),
       string(message),
       string(exception_class_name),
-      build_params ]
+      processed_attributes]
+    arr << @transaction_id if @transaction_id
+    arr
   end
 
-  USER_ATTRIBUTES = "userAttributes".freeze
-  AGENT_ATTRIBUTES = "agentAttributes".freeze
-  INTRINSIC_ATTRIBUTES = "intrinsics".freeze
-
-  EMPTY_HASH = {}.freeze
-
-  DESTINATION = NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR
-
-  def build_params
-    params = base_parameters
-    append_attributes(params, USER_ATTRIBUTES, merged_custom_attributes)
-    append_attributes(params, AGENT_ATTRIBUTES, build_agent_attributes)
-    append_attributes(params, INTRINSIC_ATTRIBUTES, build_intrinsic_attributes)
-    params
+  # Note that we process attributes lazily and store the result. This is because
+  # there is a possibility that a noticed error will be discarded and not sent back
+  # as a traced error or TransactionError.
+  def processed_attributes
+    @processed_attributes ||= begin
+      attributes = base_parameters
+      merged_attributes = NewRelic::Agent::Attributes.new(NewRelic::Agent.instance.attribute_filter)
+      append_attributes(attributes, USER_ATTRIBUTES, merged_custom_attributes(merged_attributes))
+      append_attributes(attributes, AGENT_ATTRIBUTES, build_agent_attributes(merged_attributes))
+      append_attributes(attributes, INTRINSIC_ATTRIBUTES, build_intrinsic_attributes)
+      attributes
+    end
   end
 
   def base_parameters
     params = {}
-    params[:request_uri] = request_uri if request_uri
-    params[:file_name]   = file_name   if file_name
+    params[:file_name] = file_name if file_name
     params[:line_number] = line_number if line_number
     params[:stack_trace] = stack_trace if stack_trace
+    params[ERROR_EXPECTED_KEY.to_sym] = expected
     params
   end
 
@@ -118,9 +116,7 @@ class NewRelic::NoticedError
   # hold in @attributes, or passed options to notice_error which show up in
   # @attributes_from_notice_error. Both need filtering, so merge them together
   # in our Attributes class for consistent handling
-  def merged_custom_attributes
-    merged_attributes = NewRelic::Agent::Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
-
+  def merged_custom_attributes(merged_attributes)
     merge_custom_attributes_from_transaction(merged_attributes)
     merge_custom_attributes_from_notice_error(merged_attributes)
 
@@ -141,19 +137,25 @@ class NewRelic::NoticedError
     end
   end
 
-  def build_agent_attributes
-    if @attributes
-      @attributes.agent_attributes_for(DESTINATION)
-    else
-      EMPTY_HASH
-    end
+  def build_error_attributes
+    @attributes_from_notice_error ||= {}
+    @attributes_from_notice_error[ERROR_MESSAGE_KEY] = string(message)
+    @attributes_from_notice_error[ERROR_CLASS_KEY] = string(exception_class_name)
+
+    @attributes_from_notice_error[ERROR_EXPECTED_KEY] = true if expected
+  end
+
+  def build_agent_attributes(merged_attributes)
+    return NewRelic::EMPTY_HASH unless @attributes
+
+    @attributes.agent_attributes_for(DESTINATION)
   end
 
   def build_intrinsic_attributes
     if @attributes
       @attributes.intrinsic_attributes_for(DESTINATION)
     else
-      EMPTY_HASH
+      NewRelic::EMPTY_HASH
     end
   end
 
@@ -161,4 +163,43 @@ class NewRelic::NoticedError
     outgoing_params[outgoing_key] = source_attributes || {}
   end
 
+  def agent_attributes
+    processed_attributes[AGENT_ATTRIBUTES]
+  end
+
+  def custom_attributes
+    processed_attributes[USER_ATTRIBUTES]
+  end
+
+  def intrinsic_attributes
+    processed_attributes[INTRINSIC_ATTRIBUTES]
+  end
+
+  def extract_class_name_and_message_from(exception)
+    if exception.nil?
+      @exception_class_name = UNKNOWN_ERROR_CLASS_NAME
+      @message = NIL_ERROR_MESSAGE
+    elsif exception.is_a?(NewRelic::Agent::NoticeableError)
+      @exception_class_name = exception.class_name
+      @message = exception.message
+    else
+      if defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR < 5 && exception.respond_to?(:original_exception)
+        exception = exception.original_exception || exception
+      end
+      @exception_class_name = exception.is_a?(Exception) ? exception.class.name : UNKNOWN_ERROR_CLASS_NAME
+      @message = exception.to_s
+    end
+  end
+
+  def error_group=(name)
+    return if name.nil? || name.empty?
+
+    if agent_attributes.frozen?
+      processed_attributes[AGENT_ATTRIBUTES] = agent_attributes.merge(AGENT_ATTRIBUTE_ERROR_GROUP => name)
+    else
+      agent_attributes[AGENT_ATTRIBUTE_ERROR_GROUP] = name
+    end
+
+    @error_group = name
+  end
 end

data/lib/new_relic/rack/agent_hooks.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/event_listener'
 require 'new_relic/rack/agent_middleware'
@@ -23,7 +23,7 @@ module NewRelic::Rack
   #
   class AgentHooks < AgentMiddleware
     def self.needed?
-      !NewRelic::Agent.config[:disable_middleware_instrumentation]
+      NewRelic::Agent.config[:disable_middleware_instrumentation]
     end
 
     def traced_call(env)