skylight 4.3.1 → 5.0.0.beta

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,32 @@
+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)
+        if name =~ Skylight::TIER_REGEX
+          [
+            name,
+            payload[:title],
+            payload[:description]
+          ]
+        else
+          :skip
+        end
+      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,40 @@
+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]
+
+          if disabled?
+            return :skip
+          end
+
+          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,34 @@
+module Skylight
+  module Normalizers
+    module Grape
+      class Endpoint < Normalizer
+        %w[
+          run
+          render
+          run_filters
+        ].each do |type|
+          require "skylight/normalizers/grape/endpoint_#{type}"
+        end
+
+        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..-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,41 @@
+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
+
+            if ep.respond_to?(:base) && ep.base.respond_to?(:name)
+              ep.base.name
+            end
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Skylight
+  module Normalizers
+    module Grape
+      class EndpointRunFilters < Endpoint
+        register "endpoint_run_filters.grape"
+
+        CAT = "app.grape.filters".freeze
+
+        def normalize(_trace, _name, payload)
+          filters = payload[:filters]
+          type = payload[:type]
+
+          if (!filters || filters.empty?) || !type
+            return :skip
+          end
+
+          [CAT, "#{type.to_s.capitalize} Filters", nil]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Skylight
+  module Normalizers
+    module Grape
+      class FormatResponse < Normalizer
+        register "format_response.grape"
+
+        CAT = "view.grape.format_response".freeze
+
+        def normalize(_trace, _name, payload)
+          if (formatter = payload[:formatter])
+            title = formatter.is_a?(Module) ? formatter.to_s : formatter.class.to_s
+            [CAT, title, nil]
+          else
+            :skip
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Skylight
+  module Normalizers
+    module Graphiti
+      class Render < Normalizer
+        register "render.graphiti"
+
+        CAT = "view.render.graphiti"
+        ANONYMOUS = "<Anonymous Resource>"
+
+        def normalize(_trace, _name, payload)
+          resource_class = payload[:proxy]&.resource&.class
+          title = "Render #{resource_class&.name || ANONYMOUS}"
+          desc = nil
+
+          [CAT, title, desc]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/graphiti/resolve.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Skylight
+  module Normalizers
+    module Graphiti
+      class Resolve < Normalizer
+        register "resolve.graphiti"
+
+        CAT = "app.resolve.graphiti"
+
+        ANONYMOUS_RESOURCE = "<Anonymous Resource>"
+        ANONYMOUS_ADAPTER = "<Anonymous Adapter>"
+
+        def normalize(_trace, _name, payload)
+          resource = payload[:resource]
+
+          if (sideload = payload[:sideload])
+            type = sideload.type.to_s.split("_").map(&:capitalize).join(" ")
+            desc = "Custom Scope" if sideload.class.scope_proc
+          else
+            type = "Primary"
+          end
+
+          title = "Resolve #{type} #{resource.class.name || ANONYMOUS_RESOURCE}"
+
+          [CAT, title, desc]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/graphql/base.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "active_support/inflector"
+
+module Skylight::Normalizers::GraphQL
+  # Some AS::N events in GraphQL are not super useful.
+  # We are purposefully ignoring the following keys (and you probably shouldn't add them):
+  #  - "graphql.analyze_multiplex"
+  #  - "graphql.execute_field" (very frequently called)
+  #  - "graphql.execute_field_lazy"
+
+  class Base < Skylight::Normalizers::Normalizer
+    ANONYMOUS = "[anonymous]"
+    CAT = "app.graphql"
+
+    if defined?(::GraphQL::VERSION) && Gem::Version.new(::GraphQL::VERSION) >= Gem::Version.new("1.10")
+      def self.register_graphql
+        register("#{key}.graphql")
+      end
+    else
+      def self.register_graphql
+        register("graphql.#{key}")
+      end
+    end
+
+    def self.inherited(klass)
+      klass.const_set(
+        :KEY,
+        ActiveSupport::Inflector.underscore(
+          ActiveSupport::Inflector.demodulize(klass.name)
+        ).freeze
+      )
+    end
+
+    def self.key
+      self::KEY
+    end
+
+    def normalize(_trace, _name, _payload)
+      [CAT, "graphql.#{key}", nil]
+    end
+
+    private
+
+      def key
+        self.class.key
+      end
+
+      def extract_query_name(query)
+        query&.context&.[](:skylight_endpoint) ||
+          query&.operation_name ||
+          ANONYMOUS
+      end
+  end
+
+  class Lex < Base
+    register_graphql
+  end
+
+  class Parse < Base
+    register_graphql
+  end
+
+  class Validate < Base
+    register_graphql
+  end
+
+  class ExecuteMultiplex < Base
+    register_graphql
+
+    def normalize_after(trace, _span, _name, payload)
+      # This is in normalize_after because the queries may not have
+      # an assigned operation name before they are executed.
+      # For example, if you send a single query with a defined operation name, e.g.:
+      # ```graphql
+      #   query MyNamedQuery { user(id: 1) { name } }
+      # ```
+      # ... but do _not_ send the operationName request param, the GraphQL docs[1]
+      # specify that the executor should use the operation name from the definition.
+      #
+      # In graphql-ruby's case, the calculation of the operation name is lazy, and
+      # has not been done yet at the point where execute_multiplex starts.
+      # [1] https://graphql.org/learn/serving-over-http/#post-request
+      queries, has_errors = payload[:multiplex].queries.each_with_object([Set.new, Set.new]) do |query, (names, errors)|
+        names << extract_query_name(query)
+        errors << query.static_errors.any?
+      end
+
+      trace.endpoint = "graphql:#{queries.sort.join('+')}"
+      trace.compound_response_error_status = if has_errors.all?
+                                               :all
+                                             elsif has_errors.any?
+                                               :partial
+                                             end
+    end
+  end
+
+  class AnalyzeQuery < Base
+    register_graphql
+  end
+
+  class ExecuteQuery < Base
+    register_graphql
+
+    def normalize(trace, _name, payload)
+      query_name = extract_query_name(payload[:query])
+
+      if query_name == ANONYMOUS
+        meta = { mute_children: true }
+      end
+
+      # This is probably always overriden by execute_multiplex#normalize_after,
+      # but in the case of a single query, it will be the same value anyway.
+      trace.endpoint = "graphql:#{query_name}"
+
+      [CAT, "graphql.#{key}: #{query_name}", nil, meta]
+    end
+  end
+
+  class ExecuteQueryLazy < ExecuteQuery
+    register_graphql
+
+    def normalize(trace, _name, payload)
+      if payload[:query]
+        super
+      elsif payload[:multiplex]
+        [CAT, "graphql.#{key}.multiplex", nil]
+      end
+    end
+  end
+end