skylight-core 2.0.0.beta1

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

@@ -0,0 +1,17 @@
+module Skylight::Core
+  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/core/normalizers/active_record/sql.rb

@@ -0,0 +1,33 @@
+require 'skylight/core/normalizers/sql'
+
+module Skylight::Core
+  module Normalizers
+    module ActiveRecord
+      # Normalizer for SQL requests
+      class SQL < Skylight::Core::Normalizers::SQL
+        register "sql.active_record"
+
+        def normalize(trace, name, payload)
+          ret = super
+          return :skip if ret == :skip
+
+          name, title, description, meta = ret
+
+          meta ||= {}
+
+          # FIXME: This may not be correct if the class has a different connection
+          begin
+            config = ::ActiveRecord::Base.connection_config
+            meta[:adapter] = config[:adapter]
+            meta[:database] = config[:database]
+          rescue => e
+            warn "Unable to get ActiveRecord config; e=#{e}"
+          end
+
+          [name, title, description, meta]
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Skylight::Core
+  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/core/normalizers/active_support/cache_#{type}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Skylight::Core
+  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/core/normalizers/active_support/cache_decrement.rb

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,36 @@
+module Skylight::Core
+  module Normalizers
+    module Coach
+      class HandlerFinish < Normalizer
+        register "coach.handler.finish"
+
+        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')
+
+          if segments.any?
+            trace.endpoint += "<sk-segment>#{segments.join("+")}</sk-segment>"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Skylight::Core
+  module Normalizers
+    module Coach
+      class MiddlewareFinish < Normalizer
+        register "coach.middleware.finish"
+
+        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/core/normalizers/couch_potato/query.rb

@@ -0,0 +1,20 @@
+require "json"
+
+module Skylight::Core
+  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/core/normalizers/data_mapper/sql.rb

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

data/lib/skylight/core/normalizers/default.rb

@@ -0,0 +1,27 @@
+module Skylight::Core
+  module Normalizers
+
+    # The default normalizer, used if no other is found.
+    class Default
+
+      # @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/core/normalizers/elasticsearch/request.rb

@@ -0,0 +1,20 @@
+module Skylight::Core
+  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/core/normalizers/faraday/request.rb

@@ -0,0 +1,37 @@
+module Skylight::Core
+  module Normalizers
+    module Faraday
+      class Request < Normalizer
+        register "request.faraday"
+
+        DISABLED_KEY = :__skylight_faraday_disabled
+
+        def self.disable
+          Thread.current[DISABLED_KEY] = true
+          yield
+        ensure
+          Thread.current[DISABLED_KEY] = false
+        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/core/normalizers/grape/endpoint.rb

@@ -0,0 +1,30 @@
+module Skylight::Core
+  module Normalizers
+    module Grape
+      class Endpoint < Normalizer
+        %w(run
+            render
+            run_filters).each do |type|
+          require "skylight/core/normalizers/grape/endpoint_#{type}"
+        end
+
+        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)
+            ::Grape::Namespace.joined_space(endpoint.namespace_stackable(:namespace))
+          end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Skylight::Core
+  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/core/normalizers/grape/endpoint_run.rb

@@ -0,0 +1,33 @@
+module Skylight::Core
+  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
+
+            "#{endpoint.options[:for]} [#{method}] #{path}"
+          end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Skylight::Core
+  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/core/normalizers/moped/query.rb

@@ -0,0 +1,100 @@
+module Skylight::Core
+  module Normalizers
+    module Moped
+      class Query < Normalizer
+        register "query.moped"
+
+        CAT = "db.mongo.query".freeze
+
+        # Normalizes a Moped operation
+        #
+        # @param trace [Skylight::Messages::Trace::Builder] ignored, only present to match API
+        # @param name [String] ignored, only present to match API
+        # @param payload [Hash]
+        # @option payload [Array<Moped::Protocol::*>] :ops array of performed operations. Supported operations are
+        #   `Query`, `GetMore`, `Insert`, `Update`, and `Delete`.
+        # @option payload [String] :prefix ignored, provided by Moped
+        # @return [Array, :skip] the normalized array or `:skip` if not a known operation type
+        def normalize(trace, name, payload)
+          # payload: { prefix: "  MOPED: #{address.resolved}", ops: operations }
+
+          # We can sometimes have multiple operations. However, it seems like this only happens when doing things
+          # like an insert, followed by a get last error, so we can probably ignore all but the first.
+          operation = payload[:ops] ? payload[:ops].first : nil
+          type = operation && operation.class.to_s =~ /^Moped::Protocol::(.+)$/ ? $1 : nil
+
+          case type
+          when "Query".freeze   then normalize_query(operation)
+          when "GetMore".freeze then normalize_get_more(operation)
+          when "Insert".freeze  then normalize_insert(operation)
+          when "Update".freeze  then normalize_update(operation)
+          when "Delete".freeze  then normalize_delete(operation)
+          else :skip
+          end
+        end
+
+      private
+
+        def normalize_query(operation)
+          title = normalize_title("QUERY".freeze, operation)
+
+          hash = extract_binds(operation.selector)
+          description = hash.to_json
+
+          [CAT, title, description, { database: operation.database }]
+        end
+
+        def normalize_get_more(operation)
+          title = normalize_title("GET_MORE".freeze, operation)
+
+          [CAT, title, nil, { database: operation.database }]
+        end
+
+        def normalize_insert(operation)
+          title = normalize_title("INSERT".freeze, operation)
+
+          [CAT, title, nil, { database: operation.database }]
+        end
+
+        def normalize_update(operation)
+          title = normalize_title("UPDATE".freeze, operation)
+
+          selector_hash = extract_binds(operation.selector)
+          update_hash = extract_binds(operation.update)
+
+          description = { selector: selector_hash, update: update_hash }.to_json
+
+          [CAT, title, description, { database: operation.database }]
+        end
+
+        def normalize_delete(operation)
+          title = normalize_title("DELETE".freeze, operation)
+
+          hash = extract_binds(operation.selector)
+          description = hash.to_json
+
+          [CAT, title, description, { database: operation.database }]
+        end
+
+        def normalize_title(type, operation)
+          "#{type} #{operation.collection}"
+        end
+
+        def extract_binds(hash)
+          ret = {}
+
+          hash.each do |k,v|
+            if v.is_a?(Hash)
+              ret[k] = extract_binds(v)
+            else
+              ret[k] = '?'.freeze
+            end
+          end
+
+          ret
+        end
+
+      end
+    end
+  end
+end

data/lib/skylight/core/normalizers/sequel/sql.rb

@@ -0,0 +1,12 @@
+require 'skylight/core/normalizers/sql'
+
+module Skylight::Core
+  module Normalizers
+    module Sequel
+      # Normalizer for SQL requests
+      class SQL < Skylight::Core::Normalizers::SQL
+        register "sql.sequel"
+      end
+    end
+  end
+end