skylight 3.1.4 → 5.3.4

data/lib/skylight/normalizers/active_job/perform.rb

@@ -0,0 +1,87 @@
+module Skylight
+  module Normalizers
+    module ActiveJob
+      class Perform < Normalizer
+        register "perform.active_job"
+
+        DELIVERY_JOB = /\AActionMailer::(Mail)?DeliveryJob\Z/.freeze
+        DELAYED_JOB_WRAPPER = "ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper".freeze
+
+        def self.normalize_title(job_instance)
+          job_instance
+            .class
+            .name
+            .to_s
+            .tap do |str|
+              if str.match(DELIVERY_JOB)
+                mailer_class, mailer_method, * = job_instance.arguments
+                return "#{mailer_class}##{mailer_method}", str if mailer_class && mailer_method
+              end
+            end
+        end
+
+        CAT = "app.job.perform".freeze
+
+        def normalize(trace, _name, payload)
+          title = payload[:job].class.to_s
+          adapter_name = normalize_adapter_name(payload[:adapter])
+          desc = "{ adapter: '#{adapter_name}', queue: '#{payload[:job].queue_name}' }"
+
+          maybe_set_endpoint(trace, payload)
+
+          [CAT, title, desc]
+        end
+
+        def normalize_after(trace, _span, _name, payload)
+          maybe_set_endpoint(trace, payload)
+        end
+
+        private
+
+        def process_meta_options(payload)
+          # provide hints to override default source_location behavior
+          super.merge(source_location_hint: [:instance_method, payload[:job].class.to_s, "perform"])
+        end
+
+        def normalize_adapter_name(adapter)
+          adapter_string = adapter.is_a?(Class) ? adapter.to_s : adapter.class.to_s
+          adapter_string[/ActiveJob::QueueAdapters::(\w+)Adapter/, 1].underscore
+        rescue StandardError
+          "active_job"
+        end
+
+        def maybe_set_endpoint(trace, payload)
+          endpoint = normalize_title(payload[:job])
+
+          # Always assign the endpoint if it has not yet been assigned by the ActiveJob probe.
+          if !trace.endpoint ||
+               (defined?(Skylight::Probes::ActiveJob::TITLE) && trace.endpoint == Skylight::Probes::ActiveJob::TITLE) ||
+               (
+                 defined?(Skylight::Probes::DelayedJob::Probe::UNKNOWN) &&
+                   trace.endpoint == Skylight::Probes::DelayedJob::Probe::UNKNOWN
+               ) ||
+               # If a job is called using #perform_now inside a controller action
+               # or within another job's #perform method, we do not want this to
+               # overwrite the existing endpoint name (unless it is the default from ActiveJob).
+               #
+               # If the current endpoint name matches this payload, return true to allow the
+               # segment to be assigned by normalize_after.
+               trace.endpoint =~ DELIVERY_JOB ||
+               # This adapter wrapper needs to be handled specifically due to interactions with the
+               # standalone Delayed::Job probe, as there is no consistent way to get the wrapped
+               # job name among all Delayed::Job backends.
+               trace.endpoint == DELAYED_JOB_WRAPPER
+            trace.endpoint = endpoint
+          end
+
+          trace.segment = payload[:job].queue_name if trace.endpoint == endpoint && config.enable_segments?
+        end
+
+        def normalize_title(job_instance)
+          title, * = self.class.normalize_title(job_instance)
+          title
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_model_serializers/render.rb

@@ -0,0 +1,32 @@
+module Skylight
+  module Normalizers
+    module ActiveModelSerializers
+      class Render < Normalizer
+        register "render.active_model_serializers"
+
+        CAT = "view.render.active_model_serializers".freeze
+        ANONYMOUS = "<Anonymous Serializer>".freeze
+
+        def normalize(_trace, _name, payload)
+          serializer_class = payload[:serializer]
+
+          title = serializer_class.name || ANONYMOUS
+          title = title.sub(/^ActiveModel::(Serializer::)?/, "")
+
+          if (adapter_instance = payload[:adapter])
+            adapter_name =
+              adapter_instance
+                .class
+                .name
+                .to_s
+                .sub(/^ActiveModel::Serializer::Adapter::/, "")
+                .sub(/^ActiveModelSerializers::Adapter::/, "")
+            desc = "Adapter: #{adapter_name}"
+          end
+
+          [CAT, title, desc]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_record/instantiation.rb

@@ -0,0 +1,16 @@
+module Skylight
+  module Normalizers
+    module ActiveRecord
+      class Instantiation < Normalizer
+        register "instantiation.active_record"
+
+        CAT = "db.active_record.instantiation".freeze
+
+        def normalize(_trace, _name, payload)
+          # Payload also includes `:record_count` but this will be variable
+          [CAT, "#{payload[:class_name]} Instantiation", nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_record/sql.rb

@@ -0,0 +1,20 @@
+require "skylight/normalizers/sql"
+
+module Skylight
+  module Normalizers
+    module ActiveRecord
+      # Normalizer for SQL requests
+      class SQL < Skylight::Normalizers::SQL
+        register "sql.active_record"
+      end
+
+      class FutureResult < Normalizer
+        register "future_result.active_record"
+
+        def normalize(_trace, _name, payload)
+          ["db.future_result", "Async #{payload[:args][1] || "Query"}"]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_storage.rb

@@ -0,0 +1,28 @@
+module Skylight
+  module Normalizers
+    class ActiveStorage < Normalizer
+      TITLES = {
+        "preview.active_storage" => "Preview",
+        "transform.active_storage" => "Transform",
+        "service_download.active_storage" => "Download",
+        "service_upload.active_storage" => "Upload",
+        "service_streaming_download.active_storage" => "Streaming Download",
+        "service_download_chunk.active_storage" => "Download Chunk",
+        "service_delete.active_storage" => "Delete",
+        "service_delete_prefixed.active_storage" => "Delete Prefixed",
+        "service_exist.active_storage" => "Exist",
+        "service_url.active_storage" => "Url"
+      }.freeze
+
+      TITLES.each_key { |key| register key }
+
+      def normalize(_trace, name, _payload)
+        title = ["ActiveStorage", TITLES[name]].join(" ")
+
+        cat = "app.#{name.split(".").reverse.join(".")}"
+
+        [cat, title, nil]
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_support/cache.rb

@@ -0,0 +1,11 @@
+module Skylight
+  module Normalizers
+    module ActiveSupport
+      class Cache < Normalizer
+        %w[clear decrement delete exist fetch_hit generate increment read read_multi write].each do |type|
+          require "skylight/normalizers/active_support/cache_#{type}"
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_support/cache_clear.rb

@@ -0,0 +1,16 @@
+module Skylight
+  module Normalizers
+    module ActiveSupport
+      class CacheClear < Cache
+        register "cache_clear.active_support"
+
+        CAT = "app.cache.clear".freeze
+        TITLE = "cache clear".freeze
+
+        def normalize(_trace, _name, _payload)
+          [CAT, TITLE, nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_support/cache_decrement.rb

@@ -0,0 +1,16 @@
+module Skylight
+  module Normalizers
+    module ActiveSupport
+      class CacheDecrement < Cache
+        register "cache_decrement.active_support"
+
+        CAT = "app.cache.decrement".freeze
+        TITLE = "cache decrement".freeze
+
+        def normalize(_trace, _name, _payload)
+          [CAT, TITLE, nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_support/cache_delete.rb

@@ -0,0 +1,16 @@
+module Skylight
+  module Normalizers
+    module ActiveSupport
+      class CacheDelete < Cache
+        register "cache_delete.active_support"
+
+        CAT = "app.cache.delete".freeze
+        TITLE = "cache delete".freeze
+
+        def normalize(_trace, _name, _payload)
+          [CAT, TITLE, nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_support/cache_exist.rb

@@ -0,0 +1,16 @@
+module Skylight
+  module Normalizers
+    module ActiveSupport
+      class CacheExist < Cache
+        register "cache_exist?.active_support"
+
+        CAT = "app.cache.exist".freeze
+        TITLE = "cache exist?".freeze
+
+        def normalize(_trace, _name, _payload)
+          [CAT, TITLE, nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_support/cache_fetch_hit.rb

@@ -0,0 +1,16 @@
+module Skylight
+  module Normalizers
+    module ActiveSupport
+      class CacheFetchHit < Cache
+        register "cache_fetch_hit.active_support"
+
+        CAT = "app.cache.fetch_hit".freeze
+        TITLE = "cache fetch hit".freeze
+
+        def normalize(_trace, _name, _payload)
+          [CAT, TITLE, nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_support/cache_generate.rb

@@ -0,0 +1,16 @@
+module Skylight
+  module Normalizers
+    module ActiveSupport
+      class CacheGenerate < Cache
+        register "cache_generate.active_support"
+
+        CAT = "app.cache.generate".freeze
+        TITLE = "cache generate".freeze
+
+        def normalize(_trace, _name, _payload)
+          [CAT, TITLE, nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_support/cache_increment.rb

@@ -0,0 +1,16 @@
+module Skylight
+  module Normalizers
+    module ActiveSupport
+      class CacheIncrement < Cache
+        register "cache_increment.active_support"
+
+        CAT = "app.cache.increment".freeze
+        TITLE = "cache increment".freeze
+
+        def normalize(_trace, _name, _payload)
+          [CAT, TITLE, nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_support/cache_read.rb

@@ -0,0 +1,16 @@
+module Skylight
+  module Normalizers
+    module ActiveSupport
+      class CacheRead < Cache
+        register "cache_read.active_support"
+
+        CAT = "app.cache.read".freeze
+        TITLE = "cache read".freeze
+
+        def normalize(_trace, _name, _payload)
+          [CAT, TITLE, nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_support/cache_read_multi.rb

@@ -0,0 +1,16 @@
+module Skylight
+  module Normalizers
+    module ActiveSupport
+      class CacheReadMulti < Cache
+        register "cache_read_multi.active_support"
+
+        CAT = "app.cache.read_multi".freeze
+        TITLE = "cache read multi".freeze
+
+        def normalize(_trace, _name, _payload)
+          [CAT, TITLE, nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/active_support/cache_write.rb

@@ -0,0 +1,16 @@
+module Skylight
+  module Normalizers
+    module ActiveSupport
+      class CacheWrite < Cache
+        register "cache_write.active_support"
+
+        CAT = "app.cache.write".freeze
+        TITLE = "cache write".freeze
+
+        def normalize(_trace, _name, _payload)
+          [CAT, TITLE, nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/coach/handler_finish.rb

@@ -0,0 +1,44 @@
+module Skylight
+  module Normalizers
+    module Coach
+      class HandlerFinish < Normalizer
+        begin
+          require "coach/version"
+          version = Gem::Version.new(::Coach::VERSION)
+        rescue LoadError # rubocop:disable Lint/SuppressedException
+        end
+
+        if version && version < Gem::Version.new("1.0")
+          register "coach.handler.finish"
+        else
+          register "finish_handler.coach"
+        end
+
+        CAT = "app.coach.handler".freeze
+
+        # See information on the events Coach emits here:
+        # https://github.com/gocardless/coach#instrumentation
+
+        # Run when the handler first starts, we need to set the trace endpoint to be the
+        # handler name.
+        #
+        # We can expect the payload to have the :middleware key.
+        def normalize(trace, _name, payload)
+          trace.endpoint = payload[:middleware]
+          [CAT, payload[:middleware], nil]
+        end
+
+        def normalize_after(trace, _span, _name, payload)
+          return unless config.enable_segments?
+
+          segments = []
+
+          response_status = payload.fetch(:response, {}).fetch(:status, "").to_s
+          segments << "error" if response_status.start_with?("4", "5")
+
+          trace.segment = segments.join("+") if segments.any?
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/coach/middleware_finish.rb

@@ -0,0 +1,33 @@
+module Skylight
+  module Normalizers
+    module Coach
+      class MiddlewareFinish < Normalizer
+        begin
+          require "coach/version"
+          version = Gem::Version.new(::Coach::VERSION)
+        rescue LoadError # rubocop:disable Lint/SuppressedException
+        end
+
+        if version && version < Gem::Version.new("1.0")
+          register "coach.middleware.finish"
+        else
+          register "finish_middleware.coach"
+        end
+
+        CAT = "app.coach.middleware".freeze
+
+        # See information on the events Coach emits here:
+        # https://github.com/gocardless/coach#instrumentation
+
+        # Called whenever a new middleware is executed. We can expect this to happen
+        # within a Coach::Handler.
+        #
+        # We can expect the payload to have the :middleware key.
+        def normalize(trace, _name, payload)
+          trace.endpoint = payload[:middleware]
+          [CAT, payload[:middleware], nil]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/couch_potato/query.rb

@@ -0,0 +1,20 @@
+require "json"
+
+module Skylight
+  module Normalizers
+    module CouchPotato
+      class Query < Normalizer
+        register "couch_potato.load"
+        register "couch_potato.view"
+
+        CAT = "db.couch_db.query".freeze
+
+        def normalize(_trace, name, payload)
+          description = payload[:name] if payload
+          name = name.sub("couch_potato.", "")
+          [CAT, name, description]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/data_mapper/sql.rb

@@ -0,0 +1,12 @@
+require "skylight/normalizers/sql"
+
+module Skylight
+  module Normalizers
+    module DataMapper
+      # Normalizer for SQL requests
+      class SQL < Skylight::Normalizers::SQL
+        register "sql.data_mapper"
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/default.rb

@@ -0,0 +1,24 @@
+module Skylight
+  module Normalizers
+    # The default normalizer, used if no other is found.
+    class Default < Normalizer
+      def initialize
+        super(nil) # Pass no config and handle it in new method
+      end
+
+      def config
+        Skylight.config
+      end
+
+      # @param trace [Skylight::Messages::Trace::Builder] ignored, only present to match API
+      # @param name [String]
+      # @param payload [Hash]
+      # @option payload [String] :title
+      # @option payload [String] :description
+      # @return [Array, :skip] the normalized array or `:skip` if `name` is not part of a known {Skylight::TIERS tier}
+      def normalize(_trace, name, payload)
+        name =~ Skylight::TIER_REGEX ? [name, payload[:title], payload[:description]] : :skip
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/elasticsearch/request.rb

@@ -0,0 +1,20 @@
+module Skylight
+  module Normalizers
+    module Elasticsearch
+      class Request < Normalizer
+        register "request.elasticsearch"
+
+        CAT = "db.elasticsearch.request".freeze
+
+        def normalize(_trace, _name, payload)
+          path = payload[:path].split("/")
+          title = [payload[:method], path[0]].compact.join(" ")
+          desc = {}
+          desc[:type] = path[1] if path[1]
+          desc[:id] = "?" if path[2]
+          [CAT, title, desc.empty? ? nil : desc.to_json]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/faraday/request.rb

@@ -0,0 +1,38 @@
+require "skylight/formatters/http"
+
+module Skylight
+  module Normalizers
+    module Faraday
+      class Request < Normalizer
+        register "request.faraday"
+
+        DISABLED_KEY = :__skylight_faraday_disabled
+
+        def self.disable
+          old_value = Thread.current[DISABLED_KEY]
+          Thread.current[DISABLED_KEY] = true
+          yield
+        ensure
+          Thread.current[DISABLED_KEY] = old_value
+        end
+
+        def disabled?
+          !!Thread.current[DISABLED_KEY]
+        end
+
+        def normalize(_trace, _name, payload)
+          uri = payload[:url]
+
+          return :skip if disabled?
+
+          opts = Formatters::HTTP.build_opts(payload[:method], uri.scheme, uri.host, uri.port, uri.path, uri.query)
+          description = opts[:title]
+
+          # We use "Faraday" as the title to differentiate it in the UI in
+          # case it's wrapping or is wrapped by another HTTP backend
+          [opts[:category], "Faraday", description, opts[:meta]]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/grape/endpoint.rb

@@ -0,0 +1,28 @@
+module Skylight
+  module Normalizers
+    module Grape
+      class Endpoint < Normalizer
+        %w[run render run_filters].each { |type| require "skylight/normalizers/grape/endpoint_#{type}" }
+
+        require "skylight/normalizers/grape/format_response"
+
+        private
+
+        def get_method(endpoint)
+          method = endpoint.options[:method].first
+          method = "#{method}..." if endpoint.options[:method].length > 1
+          method
+        end
+
+        def get_path(endpoint)
+          endpoint.options[:path].join("/")
+        end
+
+        def get_namespace(endpoint)
+          # slice off preceding slash for data continuity
+          ::Grape::Namespace.joined_space_path(endpoint.namespace_stackable(:namespace)).to_s[1..]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/grape/endpoint_render.rb

@@ -0,0 +1,25 @@
+module Skylight
+  module Normalizers
+    module Grape
+      class EndpointRender < Endpoint
+        register "endpoint_render.grape"
+
+        CAT = "app.grape.endpoint".freeze
+
+        def normalize(_trace, _name, payload)
+          if (endpoint = payload[:endpoint])
+            path = get_path(endpoint)
+            namespace = get_namespace(endpoint)
+            method = get_method(endpoint)
+
+            title = [method, namespace, path].join(" ").gsub(/\s+/, " ")
+
+            [CAT, title, nil]
+          else
+            :skip
+          end
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/grape/endpoint_run.rb

@@ -0,0 +1,39 @@
+module Skylight
+  module Normalizers
+    module Grape
+      class EndpointRun < Endpoint
+        register "endpoint_run.grape"
+
+        def normalize(trace, _name, payload)
+          trace.endpoint = get_endpoint_name(payload[:endpoint]) if payload[:endpoint]
+
+          # We don't necessarily want this to be all instrumented since it's fairly internal.
+          # However, it is a good place to get the endpoint name.
+          :skip
+        end
+
+        private
+
+        def get_endpoint_name(endpoint)
+          method = get_method(endpoint)
+          path = get_path(endpoint)
+          namespace = get_namespace(endpoint)
+
+          if namespace && !namespace.empty?
+            path = "/#{path}" if path[0] != "/"
+            path = "#{namespace}#{path}"
+          end
+
+          "#{base_app_name(endpoint)} [#{method}] #{path}".strip
+        end
+
+        def base_app_name(endpoint)
+          ep = endpoint.options[:for]
+          return ep.name if ep.name
+
+          ep.base.name if ep.respond_to?(:base) && ep.base.respond_to?(:name)
+        end
+      end
+    end
+  end
+end