scout_apm 2.6.10 → 3.0.0.pre0

data/lib/scout_apm/error_service/error_record.rb

@@ -1,211 +0,0 @@
-module ScoutApm
-  module ErrorService
-    # Converts the raw error data captured into the captured data, and holds it
-    # until it's ready to be reported.
-    class ErrorRecord
-      attr_reader :exception_class
-      attr_reader :message
-      attr_reader :request_uri
-      attr_reader :request_params
-      attr_reader :request_session
-      attr_reader :environment
-      attr_reader :trace
-      attr_reader :request_components
-      attr_reader :context
-
-      def initialize(agent_context, exception, env, context=nil)
-        @agent_context = agent_context
-
-        @context = if context
-          context.to_hash
-        else
-          {}
-        end
-
-        @exception_class = LengthLimit.new(exception.class.name).to_s
-        @message = LengthLimit.new(exception.message, 100).to_s
-        @request_uri = LengthLimit.new(rack_request_url(env), 200).to_s
-        @request_params = clean_params(env["action_dispatch.request.parameters"])
-        @request_session = clean_params(session_data(env))
-        @environment = clean_params(strip_env(env))
-        @trace = clean_backtrace(exception.backtrace)
-        @request_components = components(env)
-      end
-
-      # TODO: This is rails specific
-      def components(env)
-        components = {}
-        unless env["action_dispatch.request.parameters"].nil?
-          components[:controller] = env["action_dispatch.request.parameters"][:controller] || nil
-          components[:action] = env["action_dispatch.request.parameters"][:action] || nil
-          components[:module] = env["action_dispatch.request.parameters"][:module] || nil
-        end
-
-        # For background workers like sidekiq
-        # TODO: extract data creation for background jobs
-        components[:controller] ||= env[:custom_controller]
-
-        components
-      end
-
-      # TODO: Can I use the same thing we use in traces?
-      def rack_request_url(env)
-        protocol = rack_scheme(env)
-        protocol = protocol.nil? ? "" : "#{protocol}://"
-
-        host = env["SERVER_NAME"] || ""
-        path = env["REQUEST_URI"] || ""
-        port = env["SERVER_PORT"] || "80"
-        port = ["80", "443"].include?(port.to_s) ? "" : ":#{port}"
-
-        protocol.to_s + host.to_s + port.to_s + path.to_s
-      end
-
-      def rack_scheme(env)
-        if env["HTTPS"] == "on"
-          "https"
-        elsif env["HTTP_X_FORWARDED_PROTO"]
-          env["HTTP_X_FORWARDED_PROTO"].split(",")[0]
-        else
-          env["rack.url_scheme"]
-        end
-      end
-
-      # TODO: This name is too vague
-      def clean_params(params)
-        return if params.nil?
-
-        normalized = normalize_data(params)
-        filter_params(normalized)
-      end
-
-      # TODO: When was backtrace_cleaner introduced?
-      def clean_backtrace(backtrace)
-        if defined?(Rails) && Rails.respond_to?(:backtrace_cleaner)
-          Rails.backtrace_cleaner.send(:filter, backtrace)
-        else
-          backtrace
-        end
-      end
-
-      # Deletes params from env
-      #
-      # These are not configurable, and will leak PII info up to Scout if
-      # allowed through. Things like specific parameters can be exposed with
-      # the ScoutApm::Context interface.
-      KEYS_TO_REMOVE = [
-        "rack.request.form_hash",
-        "rack.request.form_vars",
-        "async.callback",
-
-        # Security related items
-        "action_dispatch.secret_key_base",
-        "action_dispatch.http_auth_salt",
-        "action_dispatch.signed_cookie_salt",
-        "action_dispatch.encrypted_cookie_salt",
-        "action_dispatch.encrypted_signed_cookie_salt",
-        "action_dispatch.authenticated_encrypted_cookie_salt",
-
-        # Raw data from the URL & parameters. Would bypass our normal params filtering
-        "QUERY_STRING",
-        "REQUEST_URI",
-        "REQUEST_PATH",
-        "ORIGINAL_FULLPATH",
-        "action_dispatch.request.query_parameters",
-        "action_dispatch.request.parameters",
-        "rack.request.query_string",
-        "rack.request.query_hash",
-      ]
-      def strip_env(env)
-        env.reject { |k, v| KEYS_TO_REMOVE.include?(k) }
-      end
-
-      def session_data(env)
-        session = env["action_dispatch.request.session"]
-        return if session.nil?
-
-        if session.respond_to?(:to_hash)
-          session.to_hash
-        else
-          session.data
-        end
-      end
-
-      # TODO: Rename and make this clearer. I think it maps over the whole tree of a hash, and to_s each leaf node?
-      def normalize_data(hash)
-        new_hash = {}
-
-        hash.each do |key, value|
-          if value.respond_to?(:to_hash)
-            begin
-              new_hash[key] = normalize_data(value.to_hash)
-            rescue
-              new_hash[key] = LengthLimit.new(value.to_s).to_s
-            end
-          else
-            new_hash[key] = LengthLimit.new(value.to_s).to_s
-          end
-        end
-
-        new_hash
-      end
-
-      ###################
-      # Filtering Params
-      ###################
-
-      # Replaces parameter values with a string / set in config file
-      def filter_params(params)
-        return params unless filtered_params_config
-
-        params.each do |k, v|
-          if filter_key?(k)
-            params[k] = "[FILTERED]"
-          elsif v.respond_to?(:to_hash)
-            filter_params(params[k])
-          end
-        end
-
-        params
-      end
-
-      # Check, if a key should be filtered
-      def filter_key?(key)
-        params_to_filter.any? do |filter|
-          key.to_s == filter.to_s # key.to_s.include?(filter.to_s)
-        end
-      end
-
-      def params_to_filter
-        @params_to_filter ||= filtered_params_config + rails_filtered_params
-      end
-
-      # Accessor for the filtered params config value. Will be removed as we refactor and clean up this code.
-      # TODO: Flip this over to use a new class like filtered exceptions?
-      def filtered_params_config
-        @agent_context.config.value("errors_filtered_params")
-      end
-
-      def rails_filtered_params
-        return [] unless defined?(Rails)
-        Rails.configuration.filter_parameters
-      rescue 
-        []
-      end
-
-      class LengthLimit
-        attr_reader :text
-        attr_reader :char_limit
-
-        def initialize(text, char_limit=100)
-          @text = text
-          @char_limit = char_limit
-        end
-
-        def to_s
-          text[0..char_limit]
-        end
-      end
-    end
-  end
-end

data/lib/scout_apm/error_service/ignored_exceptions.rb

@@ -1,66 +0,0 @@
-# Encapsulates the management and checking of ignored exceptions. Allows using
-# string matches on the class name, or arbitrary matching with a callback
-module ScoutApm
-  module ErrorService
-    class IgnoredExceptions
-      attr_reader :ignored_exceptions
-      attr_reader :blocks
-
-      def initialize(context, from_config)
-        @context = context
-        @ignored_exceptions = Array(from_config).map{ |e| normalize_as_klass(e) }
-        @blocks = []
-      end
-
-      # Add a single ignored exception by class name
-      def add(klass_or_str)
-        @ignored_exceptions << normalize_as_klass(klass_or_str)
-      end
-
-      # Add a callback block that will be called on every error. If it returns
-      # Signature of blocks:  ->(exception object): truthy or falsy value
-      def add_callback(&block)
-        @blocks << block
-      end
-
-      def ignored?(exception_object)
-        klass = normalize_as_klass(exception_object)
-
-        # Check if we ignored this error by name (typical way to ignore)
-        if ignored_exceptions.any? { |ignored| klass.ancestors.include?(ignored) }
-          return true
-        end
-
-        # For each block, see if it says we should ignore this error
-        blocks.each do |b|
-          if b.call(exception_object)
-            return true
-          end
-        end
-
-        false
-      end
-
-      private
-
-      def normalize_as_klass(klass_or_str)
-        if Module === klass_or_str
-          return klass_or_str
-        end
-
-        if klass_or_str.is_a?(Exception)
-          return klass_or_str.class
-        end
-
-        if String === klass_or_str
-          maybe = ScoutApm::Utils::KlassHelper.lookup(klass_or_str)
-          if Module === maybe
-            return maybe
-          end
-        end
-
-        klass_or_str
-      end
-    end
-  end
-end

data/lib/scout_apm/error_service/middleware.rb

@@ -1,32 +0,0 @@
-module ScoutApm
-  module ErrorService
-    class Middleware
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        begin
-          response = @app.call(env)
-        rescue Exception => exception
-          puts "[Scout Error Service] Caught Exception: #{exception.class.name}"
-
-          context = ScoutApm::Agent.instance.context
-
-          # Bail out early, and reraise if the error is not interesting.
-          if context.ignored_exceptions.ignored?(exception)
-            raise
-          end
-
-          # Capture the error for further processing and shipping
-          context.error_buffer.capture(exception, env)
-
-          # Finally re-raise
-          raise
-        end
-
-        response
-      end
-    end
-  end
-end

data/lib/scout_apm/error_service/notifier.rb

@@ -1,33 +0,0 @@
-module ScoutApm
-  module ErrorService
-    class Notifier
-      attr_reader :context
-      attr_reader :reporter
-
-      def initialize(context)
-        @context = context
-        @reporter = ScoutApm::Reporter.new(context, :errors)
-      end
-
-      def ship
-        error_records = context.error_buffer.get_and_reset_error_records
-        if error_records.any?
-          payload = ScoutApm::ErrorService::Payload.new(context, error_records)
-          reporter.report(
-            payload.serialize,
-            default_headers.merge("X-Error-Count" => error_records.length.to_s)
-          )
-        end
-      end
-
-      private
-
-      def default_headers
-        {
-          "Content-Type" => "application/json",
-          "Accept" => "application/json"
-        }
-      end
-    end
-  end
-end

data/lib/scout_apm/error_service/payload.rb

@@ -1,47 +0,0 @@
-module ScoutApm
-  module ErrorService
-    class Payload
-      attr_reader :context
-      attr_reader :errors
-
-      def initialize(context, errors)
-        @context = context
-        @errors = errors
-      end
-
-      # TODO: Don't use to_json since it isn't supported in Ruby 1.8.7
-      def serialize
-        payload = as_json.to_json
-        context.logger.info(payload)
-        payload
-      end
-
-      def as_json
-        serialized_errors = errors.map do |error_record|
-          serialize_error_record(error_record)
-        end
-
-        {
-          :notifier => "scout_apm_ruby",
-          :environment => context.environment.env,
-          :root => context.environment.root,
-          :problems => serialized_errors,
-        }
-      end
-
-      def serialize_error_record(error_record)
-        {
-          :exception_class => error_record.exception_class,
-          :message => error_record.message,
-          :request_uri => error_record.request_uri,
-          :request_params => error_record.request_params,
-          :request_session => error_record.request_session,
-          :environment => error_record.environment,
-          :trace => error_record.trace,
-          :request_components => error_record.request_components,
-          :context => error_record.context,
-        }
-      end
-    end
-  end
-end

data/lib/scout_apm/error_service/periodic_work.rb

@@ -1,17 +0,0 @@
-module ScoutApm
-  module ErrorService
-    class PeriodicWork
-      attr_reader :context
-
-      def initialize(context)
-        @context = context
-        @notifier = ScoutApm::ErrorService::Notifier.new(context)
-      end
-
-      # Expected to be called many times over the life of the agent
-      def run
-        @notifier.ship
-      end
-    end
-  end
-end

data/lib/scout_apm/error_service/railtie.rb

@@ -1,11 +0,0 @@
-module ScoutApm
-  module ErrorService
-    class Railtie < Rails::Railtie
-      initializer "scoutapm_error_service.middleware" do |app|
-        next if ScoutApm::Agent.instance.config.value("error_service")
-
-        app.config.middleware.insert_after ActionDispatch::DebugExceptions, ScoutApm::ErrorService::Rack
-      end
-    end
-  end
-end

data/lib/scout_apm/error_service/sidekiq.rb

@@ -1,80 +0,0 @@
-module ScoutApm
-  module ErrorService
-    class Sidekiq
-      def initialize
-        @context = ScoutApm::Agent.instance.context
-      end
-
-      def install
-        return false unless defined?(::Sidekiq)
-
-        if ::Sidekiq::VERSION < "3"
-          install_sidekiq_with_middleware
-        else
-          install_sidekiq_with_error_handler
-        end
-
-        true
-      end
-
-      def install_sidekiq_with_middleware
-        # old behavior
-        ::Sidekiq.configure_server do |config|
-          config.server_middleware do |chain|
-            chain.add ScoutApm::ErrorService::Sidekiq::SidekiqExceptionMiddleware
-          end
-        end
-      end
-
-      def install_sidekiq_with_error_handler
-        ::Sidekiq.configure_server do |config|
-          config.error_handlers << proc { |exception, job_info|
-            context = ScoutApm::Agent.instance.context
-
-            # Bail out early, and reraise if the error is not interesting.
-            if context.ignored_exceptions.ignored?(exception)
-              raise
-            end
-
-            job_class =
-              begin
-                job_class = job_info[:job]["class"]
-                job_class = job_info[:job]["args"][0]["job_class"] if job_class == "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
-                job_class
-              rescue
-                "UnknownJob"
-              end
-
-            # Capture the error for further processing and shipping
-            context.error_buffer.capture(exception, job_info.merge(:custom_controller => job_class))
-          }
-        end
-      end
-
-      class SidekiqExceptionMiddleware
-        def call(worker, msg, queue)
-          yield
-        rescue => exception
-          context = ScoutApm::Agent.instance.context
-
-          # Bail out early, and reraise if the error is not interesting.
-          if context.ignored_exceptions.ignored?(exception)
-            raise
-          end
-
-          # Capture the error for further processing and shipping
-          context.error_buffer.capture(
-            exception,
-            {
-              :custom_params => msg,
-              :custom_controller => msg["class"]
-            }
-          )
-
-          # Finally, reraise
-          raise exception
-        end
-      end
-    end
-  end
-end

data/lib/scout_apm/error_service.rb

@@ -1,32 +0,0 @@
-require "net/http"
-require "net/https"
-require "uri"
-
-module ScoutApm
-  module ErrorService
-    API_VERSION = "1"
-
-    HEADERS = {
-      "Content-type" => "application/json",
-      "Accept" => "application/json"
-    }
-
-    # Public API to force a given exception to be captured.
-    # Still obeys the ignore list
-    # Used internally by SidekiqException
-    def self.capture(exception, params = {})
-      return if disabled?
-      return if ScoutApm::Agent.instance.context.ignored_exceptions.ignore?(exception)
-
-      context.errors_buffer.capture(exception, env)
-    end
-
-    def self.enabled?
-      ScoutApm::Agent.instance.context.config.value("errors_enabled")
-    end
-
-    def self.disabled?
-      !enabled?
-    end
-  end
-end

data/lib/scout_apm/extensions/config.rb

@@ -1,87 +0,0 @@
-module ScoutApm
-  module Extensions
-    # !!! Extensions are a 0.x level API and breakage is expected as the API is refined.
-    # Extensions fan out data collected by the agent to additional services.
-    class Config
-      attr_reader   :agent_context
-      attr_accessor :transaction_callbacks
-      attr_accessor :periodic_callbacks
-
-      # Adds a new callback that runs after a transaction completes.
-      # These run inline during the request and thus should add minimal overhead. 
-      # For example, a transaction callback should NOT make inline HTTP calls to outside services.
-      # +callback+ must be an object that respond to a +call(payload)+ method.
-      #
-      # Example:
-      # ScoutApm::Extensions::Config.add_transaction_callback(Proc.new { |payload| puts "Duration: #{payload.duration_ms}" })
-      #
-      # +payload+ is a +ScoutApm::Extensions::TransactionCallbackPayload+ object.
-      def self.add_transaction_callback(callback)
-        agent_context.extensions.transaction_callbacks << callback
-      end
-
-      # Adds a callback that runs when the per-minute report data is sent to Scout.
-      # These run in a background thread so external HTTP calls are OK.
-      # +callback+ must be an object that responds to a +call(reporting_period, metadata)+ method.
-      # 
-      # Example:
-      # ScoutApm::Extensions::Config.add_periodic_callback(Proc.new { |reporting_period, metadata| ... })
-      def self.add_periodic_callback(callback)
-        agent_context.extensions.periodic_callbacks << callback
-      end
-
-      def initialize(agent_context)
-        @agent_context = agent_context
-        @transaction_callbacks = []
-        @periodic_callbacks = []
-      end
-
-      # Runs each reporting period callback. 
-      # Each callback runs inside a begin/rescue block so a broken callback doesn't prevent other
-      # callbacks from executing or reporting data from being sent. 
-      def run_periodic_callbacks(reporting_period, metadata)
-        return unless periodic_callbacks.any?
-
-        periodic_callbacks.each do |callback|
-          begin
-            callback.call(reporting_period, metadata)
-          rescue => e
-            logger.warn "Error running reporting callback extension=#{callback}"
-            logger.info e.message
-            logger.debug e.backtrace
-          end
-        end
-      end
-
-      # Runs each transaction callback.
-      # Each callback runs inside a begin/rescue block so a broken callback doesn't prevent other
-      # callbacks from executing or the transaction from being recorded. 
-      def run_transaction_callbacks(converter_results, context, scope_layer)
-        # It looks like layer_finder.scope = nil when a Sidekiq job is retried
-        return unless scope_layer
-        return unless transaction_callbacks.any?
-
-        payload = ScoutApm::Extensions::TransactionCallbackPayload.new(agent_context,converter_results,context,scope_layer)
-
-        transaction_callbacks.each do |callback|
-          begin
-            callback.call(payload)
-          rescue => e
-            logger.warn "Error running transaction callback extension=#{callback}"
-            logger.info e.message
-            logger.debug e.backtrace
-          end
-        end
-      end
-
-      def self.agent_context
-        ScoutApm::Agent.instance.context
-      end
-
-      def logger
-        agent_context.logger
-      end
-
-    end
-  end
-end

data/lib/scout_apm/extensions/transaction_callback_payload.rb

@@ -1,74 +0,0 @@
-module ScoutApm
-  module Extensions
-    # A +TransactionCallbackPayload+ is passed to each Transaction callback's +call+ method. 
-    # It encapsulates the data about a specific transaction.
-    class TransactionCallbackPayload
-      # A Hash that stores the output of each layer converter by name. See the naming conventions in +TrackedRequest+.
-      attr_accessor :converter_results
-
-      def initialize(agent_context,converter_results,context,scope_layer)
-        @agent_context = agent_context
-        @converter_results = converter_results
-        @context = context
-        @scope_layer = scope_layer
-      end
-
-      # A flat hash of the context associated w/this transaction (ie user ip and another other data added to context).
-      def context
-        @context.to_flat_hash
-      end
-
-      # The total duration of the transaction
-      def duration_ms
-        @scope_layer.total_call_time*1000 # ms
-      end
-
-      # The time in queue of the transaction in ms. If not present, +nil+ is returned as this is unknown.
-      def queue_time_ms
-        # Controller logic
-        if converter_results[:queue_time] && converter_results[:queue_time].any?
-          converter_results[:queue_time].values.first.total_call_time*1000 # ms
-        # Job logic
-        elsif converter_results[:job]
-          stat = converter_results[:job].metric_set.metrics[ScoutApm::MetricMeta.new("Latency/all", :scope => transaction_name)]
-          stat ? stat.total_call_time*1000 : nil
-        else
-          nil
-        end
-      end
-
-      def hostname
-        @agent_context.environment.hostname
-      end
-
-      def app_name
-        @agent_context.config.value('name')
-      end
-
-      # Returns +true+ if the transaction raised an exception.
-      def error?
-        converter_results[:errors] && converter_results[:errors].any?
-      end
-
-      def transation_type
-        @scope_layer.type
-      end
-
-      def transaction_name
-        @scope_layer.legacy_metric_name
-      end
-
-      # Web/Job are more language-agnostic names for controller/job. For example, Python Django does not have controllers.
-      def transaction_type_slug
-        case transation_type
-        when 'Controller'
-          'web'
-        when 'Job'
-          'job'
-        else
-          'transaction'
-        end
-      end
-    end
-  end
-end