scout_apm 3.0.0.pre28 → 4.0.4

data/lib/scout_apm/background_job_integrations/sneakers.rb

@@ -0,0 +1,87 @@
+module ScoutApm
+  module BackgroundJobIntegrations
+    class Sneakers
+      def name
+        :sneakers
+      end
+
+      def present?
+        defined?(::Sneakers) && supported_version?
+      end
+      
+      # Only support Sneakers 2.7 and up
+      def supported_version?
+        result = Gem::Version.new(::Sneakers::VERSION) > Gem::Version.new("2.7.0")
+        ScoutApm::Agent.instance.logger.info("Skipping Sneakers instrumentation. Only versions 2.7+ are supported. See docs or contact support@scoutapm.com for instrumentation of older versions.")
+        result
+      rescue
+        ScoutApm::Agent.instance.logger.info("Failed comparing Sneakers Version. Skipping")
+        false
+      end
+
+      def forking?
+        false
+      end
+
+      def install
+        install_worker_override
+      end
+
+      def install_worker_override
+        ::Sneakers::Worker.module_eval do
+          def initialize_with_scout(*args)
+            agent = ::ScoutApm::Agent.instance
+            agent.start
+            initialize_without_scout(*args)
+          end
+
+          alias_method :initialize_without_scout, :initialize
+          alias_method :initialize, :initialize_with_scout
+
+          def process_work_with_scout(*args)
+            delivery_info, _metadata, msg, _handler = args
+
+            queue = delivery_info[:routing_key] || UNKNOWN_QUEUE_PLACEHOLDER
+
+            job_class = begin
+              if self.class == ActiveJob::QueueAdapters::SneakersAdapter::JobWrapper
+                msg["job_class"] || UNKNOWN_CLASS_PLACEHOLDER
+              else
+                self.class.name
+              end
+            rescue => e
+              UNKNOWN_CLASS_PLACEHOLDER
+            end
+
+            req = ScoutApm::RequestManager.lookup
+
+            # RabbitMQ does not store a created-at timestamp
+            # req.annotate_request(:queue_latency => latency(msg))
+
+            begin
+              req.start_layer(ScoutApm::Layer.new('Queue', queue))
+              started_queue = true
+              req.start_layer(ScoutApm::Layer.new('Job', job_class))
+              started_job = true
+
+              process_work_without_scout(*args)
+            rescue Exception => e
+              req.error!
+              raise
+            ensure
+              req.stop_layer if started_job
+              req.stop_layer if started_queue
+            end
+          end
+
+          alias_method :process_work_without_scout, :process_work
+          alias_method :process_work, :process_work_with_scout
+        end
+      end
+
+      ACTIVE_JOB_KLASS = 'ActiveJob::QueueAdapters::SneakersAdapter::JobWrapper'.freeze
+      UNKNOWN_CLASS_PLACEHOLDER = 'UnknownJob'.freeze
+      UNKNOWN_QUEUE_PLACEHOLDER = 'default'.freeze
+    end
+  end
+end

data/lib/scout_apm/config.rb

@@ -6,10 +6,11 @@ require 'scout_apm/environment'
 # Valid Config Options:
 #
 # This list is complete, but some are old and unused, or for developers of
-# scout_apm itself. See the documentation at http://help.apm.scoutapp.com for
+# scout_apm itself. See the documentation at https://docs.scoutapm.com for
 # customer-focused documentation.
 #
 # application_root - override the detected directory of the application
+# collect_remote_ip - automatically capture user's IP into a Trace's Context
 # compress_payload - true/false to enable gzipping of payload
 # data_file        - override the default temporary storage location. Must be a location in a writable directory
 # dev_trace        - true or false. Enables always-on tracing in development environmen only
@@ -30,6 +31,10 @@ require 'scout_apm/environment'
 # uri_reporting    - 'path' or 'full_path' default is 'full_path', which reports URL params as well as the path.
 # remote_agent_host - Internal: What host to bind to, and also send messages to for remote. Default: 127.0.0.1.
 # remote_agent_port - What port to bind the remote webserver to
+# start_resque_server_instrument - Used in special situations with certain Resque installs
+# timeline_traces - true/false to enable sending of of the timeline trace format.
+# auto_instruments - true/false whether to install autoinstruments. Only installed if on a supported Ruby version.
+# auto_instruments_ignore - An array of file names to exclude from autoinstruments (Ex: ['application_controller']).
 #
 # Any of these config settings can be set with an environment variable prefixed
 # by SCOUT_ and uppercasing the key: SCOUT_LOG_LEVEL for instance.
@@ -39,6 +44,7 @@ module ScoutApm
     KNOWN_CONFIG_OPTIONS = [
         'application_root',
         'async_recording',
+        'collect_remote_ip',
         'compress_payload',
         'config_file',
         'data_file',
@@ -66,9 +72,21 @@ module ScoutApm
         'remote_agent_host',
         'remote_agent_port',
         'report_format',
+        'revision_sha',
         'scm_subdirectory',
+        'start_resque_server_instrument',
+        'ssl_cert_file',
         'uri_reporting',
         'instrument_http_url_length',
+        'timeline_traces',
+        'auto_instruments',
+        'auto_instruments_ignore',
+
+        # Error Service Related Configuration
+        'errors_enabled',
+        'errors_ignored_exceptions',
+        'errors_filtered_params',
+        'errors_host',
     ]
 
     ################################################################################
@@ -148,16 +166,25 @@ module ScoutApm
 
 
     SETTING_COERCIONS = {
-      "async_recording"        => BooleanCoercion.new,
-      "detailed_middleware"    => BooleanCoercion.new,
-      "dev_trace"              => BooleanCoercion.new,
-      "enable_background_jobs" => BooleanCoercion.new,
-      "ignore"                 => JsonCoercion.new,
-      "max_traces"             => IntegerCoercion.new,
-      "monitor"                => BooleanCoercion.new,
+      'async_recording' => BooleanCoercion.new,
+      'detailed_middleware' => BooleanCoercion.new,
+      'dev_trace' => BooleanCoercion.new,
+      'enable_background_jobs' => BooleanCoercion.new,
+      'ignore' => JsonCoercion.new,
+      'max_traces' => IntegerCoercion.new,
+      'monitor' => BooleanCoercion.new,
+      'collect_remote_ip' => BooleanCoercion.new,
+      'compress_payload' => BooleanCoercion.new,
       'database_metric_limit'  => IntegerCoercion.new,
       'database_metric_report_limit' => IntegerCoercion.new,
       'instrument_http_url_length' => IntegerCoercion.new,
+      'start_resque_server_instrument' => BooleanCoercion.new,
+      'timeline_traces' => BooleanCoercion.new,
+      'auto_instruments' => BooleanCoercion.new,
+      'auto_instruments_ignore' => JsonCoercion.new,
+      'errors_enabled' => BooleanCoercion.new,
+      'errors_ignored_exceptions' => JsonCoercion.new,
+      'errors_filtered_params' => JsonCoercion.new,
     }
 
 
@@ -263,6 +290,16 @@ module ScoutApm
         'database_metric_limit'  => 5000, # The hard limit on db metrics
         'database_metric_report_limit' => 1000,
         'instrument_http_url_length' => 300,
+        'start_resque_server_instrument' => true, # still only starts if Resque is detected
+        'collect_remote_ip' => true,
+        'timeline_traces' => true,
+        'auto_instruments' => false,
+        'auto_instruments_ignore' => [],
+        'ssl_cert_file' => File.join( File.dirname(__FILE__), *%w[.. .. data cacert.pem] ),
+        'errors_enabled' => false,
+        'errors_ignored_exceptions' => %w(ActiveRecord::RecordNotFound ActionController::RoutingError),
+        'errors_filtered_params' => %w(password s3-key),
+        'errors_host' => 'https://errors.scoutapm.com',
       }.freeze
 
       def value(key)

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,11 @@ 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,
+      ScoutApm::BackgroundJobIntegrations::Faktory.new,
     ]
 
     FRAMEWORK_INTEGRATIONS = [
@@ -179,9 +183,24 @@ module ScoutApm
       @ruby_2 = defined?(RUBY_VERSION) && RUBY_VERSION.match(/^2/)
     end
 
+    def ruby_3?
+      return @ruby_3 if defined?(@ruby_3)
+      @ruby_3 = defined?(RUBY_VERSION) && RUBY_VERSION.match(/^3/)
+    end
+
+    def ruby_minor
+      return @ruby_minor if defined?(@ruby_minor)
+      @ruby_minor = defined?(RUBY_VERSION) && RUBY_VERSION.split(".")[1].to_i
+    end
+
     # Returns true if this Ruby version supports Module#prepend.
     def supports_module_prepend?
-      ruby_2?
+      ruby_2? || ruby_3?
+    end
+
+    # Returns true if this Ruby version makes positional and keyword arguments incompatible
+    def supports_kwarg_delegation?
+      ruby_3? || (ruby_2? && ruby_minor >= 7)
     end
 
     # Returns a string representation of the OS (ex: darwin, linux)

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