truex-skylight 0.6.0

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

@@ -0,0 +1,79 @@
+require "sql_lexer"
+require "json"
+
+module Skylight
+  module Normalizers
+    module ActiveRecord
+      class SQL < Normalizer
+        register "sql.active_record"
+        register "sql.sequel"
+        register "sql.data_mapper"
+
+        CAT = "db.sql.query".freeze
+
+        def normalize(trace, name, payload)
+          case payload[:name]
+          when "SCHEMA", "CACHE"
+            return :skip
+          else
+            name  = CAT
+            title = payload[:name] || "SQL"
+          end
+
+          binds = payload[:binds]
+
+          if binds && !binds.empty?
+            binds = binds.map { |col, val| val.inspect }
+          end
+
+          extracted_title, sql, binds, _ = extract_binds(payload, binds)
+          title = extracted_title if extracted_title
+
+          if sql
+            annotations = {
+              sql:   sql,
+              binds: binds,
+            }
+          end
+
+          [ name, title, sql, annotations ]
+        end
+
+      private
+        def extract_binds(payload, precalculated)
+          title, sql, binds = SqlLexer::Lexer.bindify(payload[:sql], precalculated, true)
+          [ title, sql, binds, nil ]
+        rescue => e
+          group = "sql_parse"
+          description = e.inspect
+          details = encode(backtrace: e.backtrace,
+                            original_exception: {
+                              class_name: e.class.name,
+                              message: e.message
+                            },
+                            payload: payload,
+                            precalculated: precalculated)
+
+          error = [group, description, details]
+          [ nil, nil, nil, error ]
+        end
+
+        # While operating in place would save memory, some of these passed in items are re-used elsewhere
+        # and, as such, should not be modified.
+        def encode(body)
+          if body.is_a?(Hash)
+            hash = {}
+            body.each{|k,v| hash[k] = encode(v) }
+            hash
+          elsif body.is_a?(Array)
+            body.map{|v| encode(v) }
+          elsif body.respond_to?(:encoding) && (body.encoding == Encoding::BINARY || !body.valid_encoding?)
+            Base64.encode64(body)
+          else
+            body
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Skylight
+  module Normalizers
+    module ActiveSupport
+      # NOTE: Instrumentation may not be turned on by default and is possibly buggy
+      # https://github.com/mperham/dalli/pull/284
+      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
+
+# See https://github.com/rails/rails/pull/15943
+if defined?(ActiveSupport::Cache::Store.instrument)
+  deprecated = false
+
+  # If it's deprecated, setting to false will cause a deprecation warning
+  # and the value will remain true
+  ActiveSupport::Deprecation.silence do
+    ActiveSupport::Cache::Store.instrument = false
+    deprecated = ActiveSupport::Cache::Store.instrument
+  end
+
+  unless deprecated
+    class ActiveSupport::Cache::Store
+      def self.instrument
+        true
+      end
+
+      def self.instrument=(val)
+        unless val
+          Rails.logger.warn "[WARNING] Skylight has patched ActiveSupport::Cache::Store.instrument to always be true. " \
+                            "In future versions of Rails, this method will no longer be settable. " \
+                            "See https://github.com/rails/rails/pull/15943 for more information."
+        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, payload ]
+        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"
+
+        def normalize(trace, name, payload)
+          [ CAT, TITLE, nil, payload ]
+        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"
+
+        def normalize(trace, name, payload)
+          [ CAT, TITLE, nil, payload ]
+        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?"
+
+        def normalize(trace, name, payload)
+          [ CAT, TITLE, nil, payload ]
+        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"
+
+        def normalize(trace, name, payload)
+          [ CAT, TITLE, nil, payload ]
+        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"
+
+        def normalize(trace, name, payload)
+          [ CAT, TITLE, nil, payload ]
+        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"
+
+        def normalize(trace, name, payload)
+          [ CAT, TITLE, nil, payload ]
+        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"
+
+        def normalize(trace, name, payload)
+          [ CAT, TITLE, nil, payload ]
+        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"
+
+        def normalize(trace, name, payload)
+          [ CAT, TITLE, nil, payload ]
+        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"
+
+        def normalize(trace, name, payload)
+          [ CAT, TITLE, nil, payload ]
+        end
+      end
+    end
+  end
+end

data/lib/skylight/normalizers/default.rb

@@ -0,0 +1,21 @@
+module Skylight
+  module Normalizers
+    class Default
+
+      def normalize(trace, name, payload)
+        if name =~ TIER_REGEX
+          annot = payload.dup
+          [
+            name,
+            annot.delete(:title),
+            annot.delete(:description),
+            annot
+          ]
+        else
+          :skip
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+module Skylight
+  module Normalizers
+    module Moped
+      class Query < Normalizer
+        register "query.moped"
+
+        CAT = "db.mongo.query".freeze
+
+        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"       then normalize_query(operation)
+          when "GetMore"     then normalize_get_more(operation)
+          when "Insert"      then normalize_insert(operation)
+          when "Update"      then normalize_update(operation)
+          when "Delete"      then normalize_delete(operation)
+          else :skip
+          end
+        end
+
+      private
+
+        def normalize_query(operation)
+          title = normalize_title("QUERY", operation)
+
+          hash, binds = extract_binds(operation.selector)
+          description = hash.to_json
+
+          annotations = build_annotations(operation)
+          annotations[:skip] = operation.skip
+          if operation.fields
+            annotations[:fields] = operation.fields.select{|k,v| v == 1 }.keys.map(&:to_s)
+          end
+          annotations[:binds] = binds unless binds.empty?
+
+          [CAT, title, description, annotations]
+        end
+
+        def normalize_get_more(operation)
+          title = normalize_title("GET_MORE", operation)
+
+          annotations = build_annotations(operation)
+          annotations[:limit] = operation.limit
+
+          [CAT, title, nil, annotations]
+        end
+
+        def normalize_insert(operation)
+          title = normalize_title("INSERT", operation)
+
+          annotations = build_annotations(operation)
+          annotations[:count] = operation.documents.count
+
+          [CAT, title, nil, annotations]
+        end
+
+        def normalize_update(operation)
+          title = normalize_title("UPDATE", operation)
+
+          selector_hash, selector_binds = extract_binds(operation.selector)
+          update_hash, update_binds = extract_binds(operation.update)
+
+          description = { selector: selector_hash, update: update_hash }.to_json
+
+          annotations = build_annotations(operation)
+
+          binds = {}
+          binds[:selector] = selector_binds unless selector_binds.empty?
+          binds[:update]   = update_binds   unless update_binds.empty?
+          annotations[:binds] = binds unless binds.empty?
+
+          [CAT, title, description, annotations]
+        end
+
+        def normalize_delete(operation)
+          title = normalize_title("DELETE", operation)
+
+          hash, binds = extract_binds(operation.selector)
+          description = hash.to_json
+
+          annotations = build_annotations(operation)
+          annotations[:binds] = binds unless binds.empty?
+
+          [CAT, title, description, annotations]
+        end
+
+        def normalize_title(type, operation)
+          "#{type} #{operation.collection}"
+        end
+
+        def build_annotations(operation)
+          annotations = {}
+
+          if operation.respond_to?(:flags)
+            flags = operation.flags.map{|f| flag_name(f) }
+            annotations[:flags] = flags unless flags.empty?
+          end
+
+          annotations
+        end
+
+        # Some flags used by Moped don't map directly to the Mongo docs
+        # See http://docs.mongodb.org/meta-driver/latest/legacy/mongodb-wire-protocol/
+        FLAG_MAP = {
+          tailable: "TailableCursor",
+          multi:    "MultiUpdate"
+        }
+
+        def flag_name(flag)
+          FLAG_MAP[flag] || flag.to_s.sub(/^[a-z\d]*/) { $&.capitalize }.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }
+        end
+
+        def extract_binds(hash, binds=[])
+          ret = {}
+
+          hash.each do |k,v|
+            if v.is_a?(Hash)
+              ret[k] = extract_binds(v, binds)[0]
+            else
+              binds << stringify(hash[k])
+              ret[k] = '?'
+            end
+          end
+
+          [ret, binds]
+        end
+
+        def stringify(value)
+          value.is_a?(Regexp) ? value.inspect : value.to_s
+        end
+
+      end
+    end
+  end
+end