scout_apm 3.0.0.pre28 → 4.0.0

data/lib/scout_apm/detailed_trace.rb

@@ -0,0 +1,217 @@
+# DetailedTrace contains all details about a certain transaction, spans with
+# start & stop times, tags, etc.
+
+# {
+# "version": 1,
+# "identity": {
+#   "transaction_id": "req-....",
+#   "revision": "abcdef",
+#   "start_instant": "01-01-01T00:00:00.0000Z",
+#   "stop_instant": "01-01-01T00:00:01.0000Z",
+#   "type": "Web",
+#   "naming": {
+#     "path": "/users",
+#     "code": "UsersController#index",
+#   },
+#   "score": {
+#     "total": 10.5,
+#     "percentile": 4.5,
+#     "age": 2.0,
+#     "memory_delta": 3,
+#     "allocations": 1
+#   }
+# },
+#
+# "tags": {
+#   "allocations": 1000
+# },
+#
+# "spans": [
+#   ...
+# ]
+
+class DetailedTrace
+  attr_reader :spans
+  attr_reader :tags
+
+  attr_reader :transaction_id
+  attr_reader :revision
+  attr_reader :start_instant
+  attr_reader :stop_instant
+  attr_reader :duration
+  attr_reader :type # "Web" or "Job"
+  attr_reader :host
+
+  attr_reader :path # /users/1
+  attr_reader :code # UsersController#show or similar
+
+  attr_reader :total_score
+  attr_reader :percentile_score
+  attr_reader :age_score
+  attr_reader :memory_delta_score
+  attr_reader :memory_allocations_score
+
+  VERSION = 1
+
+  def initialize(transaction_id, revision, host, start_instant, stop_instant, type, path, code, spans, tags)
+    @spans = spans
+    @tags = DetailedTraceTags(tags)
+
+    @transaction_id = transaction_id
+    @revision = revision
+    @host = host
+    @start_instant = start_instant
+    @stop_instant = stop_instant
+    @type = type
+
+    @path = path
+    @code = code
+
+    @total_score = 0
+    @percentile_score = 0
+    @age_score = 0
+    @memory_delta_score = 0
+    @memory_allocations_score = 0
+
+  end
+
+  def as_json(*)
+    {
+      :version => VERSION,
+      :identity => {
+        :transaction_id => transaction_id,
+        :revision => revision,
+        :host => host,
+        :start_instant => start_instant.iso8601(6),
+        :stop_instant => stop_instant.iso8601(6),
+        :type => type,
+        :naming => {
+          :path => path,
+          :code => code,
+        },
+        :score => {
+          :total => total_score,
+          :percentile => percentile_score,
+          :age => age_score,
+          :memory_delta => memory_delta_score,
+          :allocations => memory_allocations_score,
+        }
+      },
+      :tags => tags.as_json,
+      :spans => spans.map{|span| span.as_json},
+    }
+  end
+
+  ########################
+  # Scorable interface
+  #
+  # Needed so we can merge ScoredItemSet instances
+  def call
+    self
+  end
+
+  def name
+    code
+  end
+
+  def score
+    @total_score
+  end
+
+end
+
+##########
+#  SPAN  #
+##########
+
+#
+# {
+#   "type": "Standard",
+#   "identity": {
+#     "id": "....",
+#     "parent_id": "....",
+#     "start_time": "01-01-01T00:00:00.0000Z",
+#     "stop_time": "01-01-01T00:00:00.0001Z",
+#     "operation": "SQL/User/find"
+#   },
+#   "tags": {
+#     "allocations": 1000,
+#     "db.statement": "SELECT * FROM users where id = 1",
+#     "db.rows": 1,
+#     "backtrace": [ {
+#       "file": "app/controllers/users_controller.rb",
+#       "line": 10,
+#       "function": "index"
+#     } ]
+#   }
+class DetailedTraceSpan
+  attr_reader :tags
+
+  attr_reader :span_type
+  attr_reader :span_id, :parent_id
+  attr_reader :start_instant, :stop_instant
+
+  # What is the "name" of this span.
+  #
+  # Examples:
+  #   SQL/User/find
+  #   Controller/Users/index
+  #   HTTP/GET/example.com
+  attr_reader :operation
+
+  def initialize(span_id, parent_id, start_instant, stop_instant, operation, tags)
+    # This will be dynamic when we implement limited spans
+    @span_type = "Standard"
+
+    @span_id = span_id
+    @parent_id = parent_id
+
+    @start_instant = start_instant
+    @stop_instant = stop_instant
+    @operation = operation
+    @tags = DetailedTraceTags(tags)
+  end
+
+  def as_json(*)
+    {
+      :type => @span_type,
+      :identity => {
+        :id => span_id,
+        :parent_id => parent_id,
+        :start_instant => start_instant.iso8601(6),
+        :stop_instant => stop_instant.iso8601(6),
+        :operation => operation,
+      },
+      :tags => @tags.as_json,
+    }
+  end
+end
+
+
+#############
+#  content  #
+#############
+
+# Tags for either a request, or a span
+class DetailedTraceTags
+  attr_reader :tags
+
+  def initialize(hash)
+    @tags = hash
+  end
+
+  # @tags is already a hash, so no conversion needed
+  def as_json(*)
+    @tags
+  end
+end
+
+# Converter function to turn an input into a DetailedTraceTags object
+def DetailedTraceTags(arg)
+  if DetailedTraceTags === arg
+    arg
+  elsif Hash === arg
+    DetailedTraceTags.new(arg)
+  end
+end
+

data/lib/scout_apm/environment.rb

@@ -26,7 +26,10 @@ module ScoutApm
     BACKGROUND_JOB_INTEGRATIONS = [
       ScoutApm::BackgroundJobIntegrations::Resque.new,
       ScoutApm::BackgroundJobIntegrations::Sidekiq.new,
+      ScoutApm::BackgroundJobIntegrations::Shoryuken.new,
+      ScoutApm::BackgroundJobIntegrations::Sneakers.new,
       ScoutApm::BackgroundJobIntegrations::DelayedJob.new,
+      ScoutApm::BackgroundJobIntegrations::Que.new,
     ]
 
     FRAMEWORK_INTEGRATIONS = [

data/lib/scout_apm/error.rb

@@ -0,0 +1,27 @@
+# Public API for the Scout Error Monitoring service
+#
+# See-Also ScoutApm::Transaction and ScoutApm::Tracing for APM related APIs
+module ScoutApm
+  module Error
+    # Capture an exception, optionally with an environment hash. This may be a
+    # Rack environment, but is not required.
+    def self.capture(exception, env={})
+      context = ScoutApm::Agent.instance.context
+
+      # Skip if error monitoring isn't enabled at all
+      if ! context.config.value("errors_enabled")
+        return false
+      end
+
+      # Skip if this one error is ignored
+      if context.ignored_exceptions.ignored?(exception)
+        return false
+      end
+
+      # Capture the error for further processing and shipping
+      context.error_buffer.capture(exception, env)
+
+      return true
+    end
+  end
+end

data/lib/scout_apm/error_service.rb

@@ -0,0 +1,32 @@
+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/error_service/error_buffer.rb

@@ -0,0 +1,39 @@
+# Holds onto exceptions, and moves them forward to shipping when appropriate
+module ScoutApm
+  module ErrorService
+    class ErrorBuffer
+      include Enumerable
+
+      attr_reader :agent_context
+
+      def initialize(agent_context)
+        @agent_context = agent_context
+        @error_records = []
+        @mutex = Monitor.new
+      end
+
+      def capture(exception, env)
+        context = ScoutApm::Context.current
+
+        @mutex.synchronize {
+          @error_records << ErrorRecord.new(agent_context, exception, env, context)
+        }
+      end
+
+      def get_and_reset_error_records
+        @mutex.synchronize {
+          ret = @error_records
+          @error_records = []
+          ret
+        }
+      end
+
+      # Enables enumerable - for count and each and similar methods
+      def each
+        @error_records.each do |error_record|
+          yield error_record
+        end
+      end
+    end
+  end
+end

data/lib/scout_apm/error_service/error_record.rb

@@ -0,0 +1,211 @@
+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