influx_reporter 1.0.0

data/lib/influx_reporter/line_cache.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  # @api private
+  class LineCache
+    CACHE = {}
+
+    def self.all(path)
+      CACHE[path] ||= begin
+        File.readlines(path)
+      rescue
+        []
+      end
+    end
+
+    def self.find(path, line)
+      return nil if line < 1
+      all(path)[line - 1]
+    end
+  end
+end

data/lib/influx_reporter/logging.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  # @api private
+  module Logging
+    PREFIX = '** [InfluxReporter] '
+
+    def debug(*args, &block)
+      config.logger.debug(log_message(*args, &block)) if has_logger?
+    end
+
+    def info(*args, &block)
+      config.logger.info(log_message(*args, &block)) if has_logger?
+    end
+
+    def warn(*args, &block)
+      config.logger.warn(log_message(*args, &block)) if has_logger?
+    end
+
+    def error(*args, &block)
+      config.logger.error(log_message(*args, &block)) if has_logger?
+    end
+
+    def fatal(*args, &block)
+      config.logger.fatal(log_message(*args, &block)) if has_logger?
+    end
+
+    private
+
+    def has_logger?
+      respond_to?(:config) && config && config.logger
+    end
+
+    def log_message(*args)
+      msg = block_given? && yield || args.first
+      "#{PREFIX}#{msg}"
+    end
+  end
+end

data/lib/influx_reporter/middleware.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      begin
+        transaction = InfluxReporter.transaction 'Rack', 'app.rack.request'
+        resp = @app.call env
+        resp[2] = BodyProxy.new(resp[2]) { transaction.submit(resp[0]) } if transaction
+      rescue Error
+        raise # Don't report InfluxReporter errors
+      rescue Exception => e
+        InfluxReporter.report e, rack_env: env
+        transaction&.submit(500)
+        raise
+      ensure
+        transaction&.release
+      end
+
+      if error = env['rack.exception'] || env['sinatra.error']
+        InfluxReporter.report error, rack_env: env
+      end
+
+      resp
+    end
+  end
+
+  class BodyProxy
+    def initialize(body, &block)
+      @body = body
+      @block = block
+      @closed = false
+    end
+
+    def respond_to?(*args)
+      super || @body.respond_to?(*args)
+    end
+
+    def close
+      return if closed?
+
+      @closed = true
+
+      begin
+        @body.close if @body.respond_to?(:close)
+      ensure
+        @block.call
+      end
+    end
+
+    def closed?
+      @closed
+    end
+
+    def method_missing(*args, &block)
+      @body.__send__(*args, &block)
+    end
+  end
+end

data/lib/influx_reporter/normalizers.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  # @api private
+  module Normalizers
+    class Normalizer
+      def self.register(name)
+        Normalizers.register name, self
+      end
+
+      def initialize(config)
+        @config = config
+      end
+
+      attr_reader :config
+    end
+
+    class Default < Normalizer
+      def normalize(_transaction, _name, _payload)
+        :skip
+      end
+    end
+
+    DEFAULT = Default.new nil
+
+    def self.register(name, cls)
+      (@registered ||= {})[name] = cls
+    end
+
+    def self.build(config)
+      normalizers = @registered.each_with_object({}) do |kv, coll|
+        name, cls = kv
+        coll[name] = cls.new config
+      end
+
+      Container.new(normalizers)
+    end
+
+    class Container
+      def initialize(normalizers)
+        @normalizers = normalizers
+      end
+
+      def keys
+        @normalizers.keys
+      end
+
+      def normalizer_for(name)
+        @normalizers[name] || DEFAULT
+      end
+
+      def normalize(transaction, name, payload)
+        normalizer_for(name).normalize transaction, name, payload
+      end
+    end
+
+    %w[
+      action_controller
+      active_record
+      action_view
+    ].each do |f|
+      require "influx_reporter/normalizers/#{f}"
+    end
+  end
+end

data/lib/influx_reporter/normalizers/action_controller.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  module Normalizers
+    module ActionController
+      class ProcessAction < Normalizer
+        register 'process_action.action_controller'
+        KIND = 'app.controller.action'
+
+        def normalize(transaction, _name, payload)
+          transaction.endpoint = endpoint(payload)
+          extra(transaction, payload)
+          [transaction.endpoint, KIND, nil]
+        end
+
+        private
+
+        # @param transaction [InfluxReporter::Transaction]
+        def extra(transaction, payload)
+          transaction.extra_tags do |tags|
+            config.payload_tags.each { |key| tags[key] = payload[key] }
+          end
+          transaction.extra_values do |values|
+            config.payload_values.each { |key| values[key] = payload[key] }
+          end
+        end
+
+        def endpoint(payload)
+          "#{payload[:controller]}##{payload[:action]}"
+        end
+      end
+    end
+  end
+end

data/lib/influx_reporter/normalizers/action_view.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  module Normalizers
+    module ActionView
+      class RenderNormalizer < Normalizer
+        def normalize_render(payload, kind)
+          signature = path_for(payload[:identifier])
+
+          [signature, kind, nil]
+        end
+
+        private
+
+        def path_for(identifier)
+          return 'Unknown template' unless path = identifier
+          return path unless path.start_with?('/')
+
+          path && relative_path(path)
+        end
+
+        def relative_path(path)
+          root = config.view_paths.find { |vp| path.start_with? vp }
+          type = :app
+
+          unless root
+            root = Gem.path.find { |gp| path.start_with? gp }
+            type = :gem
+          end
+
+          return 'Absolute path' unless root
+
+          start = root.length
+          start += 1 if path[root.length] == '/'
+
+          if type == :gem
+            "$GEM_PATH/#{path[start, path.length]}"
+          else
+            path[start, path.length]
+          end
+        end
+      end
+
+      class RenderTemplate < RenderNormalizer
+        register 'render_template.action_view'
+        KIND = 'template.view'
+
+        def normalize(_transaction, _name, payload)
+          normalize_render(payload, KIND)
+        end
+      end
+
+      class RenderPartial < RenderNormalizer
+        register 'render_partial.action_view'
+        KIND = 'template.view.partial'
+
+        def normalize(_transaction, _name, payload)
+          normalize_render(payload, KIND)
+        end
+      end
+
+      class RenderCollection < RenderNormalizer
+        register 'render_collection.action_view'
+        KIND = 'template.view.collection'
+
+        def normalize(_transaction, _name, payload)
+          normalize_render(payload, KIND)
+        end
+      end
+    end
+  end
+end

data/lib/influx_reporter/normalizers/active_record.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'influx_reporter/sql_summarizer'
+
+module InfluxReporter
+  module Normalizers
+    module ActiveRecord
+      class SQL < Normalizer
+        register 'sql.active_record'
+
+        def initialize(*args)
+          super(*args)
+          adapter = begin
+                      ::ActiveRecord::Base.connection.adapter_name.downcase
+                    rescue
+                      nil
+                    end
+          @kind = "db.#{adapter || 'unknown'}.sql"
+          @sql_parser = SqlSummarizer.new config
+        end
+
+        def normalize(_transaction, _name, payload)
+          return :skip if %w[SCHEMA CACHE].include? payload[:name]
+
+          signature =
+            signature_for(payload[:sql]) || # SELECT FROM "users"
+            payload[:name] ||               # Users load
+            'SQL'
+
+          return :skip if signature == 'SELECT FROM "schema_migrations"'
+
+          extra = payload[:sql].length < 256 ? { values: { sql: payload[:sql] } } : nil
+
+          [signature, @kind, extra]
+        end
+
+        private
+
+        def signature_for(sql)
+          @sql_parser.signature_for(sql)
+        end
+      end
+    end
+  end
+end

data/lib/influx_reporter/sql_summarizer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  # @api private
+  class SqlSummarizer
+    CACHE = {}.freeze
+    TBL = '[^ ]+'
+    REGEXES = {
+        /^SELECT .* FROM (#{TBL})/i => 'SELECT FROM ',
+        /^INSERT INTO (#{TBL})/i => 'INSERT INTO ',
+        /^UPDATE (#{TBL})/i => 'UPDATE ',
+        /^DELETE FROM (#{TBL})/i => 'DELETE FROM '
+    }.freeze
+
+    def initialize(config)
+      @config = config
+    end
+
+    def signature_for(sql)
+      return CACHE[sql] if CACHE[sql]
+
+      result = REGEXES.find do |regex, sig|
+        if match = sql.match(regex)
+          break sig + match[1]
+        end
+      end
+
+      result || 'SQL'
+    end
+  end
+end

data/lib/influx_reporter/subscriber.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'active_support/notifications'
+require 'influx_reporter/normalizers'
+
+module InfluxReporter
+  # @api private
+  class Subscriber
+    include Logging
+
+    def initialize(config, client)
+      @config = config
+      @client = client
+      @normalizers = Normalizers.build config
+    end
+
+    attr_reader :config
+
+    def register!
+      unregister! if @subscription
+      @subscription = ActiveSupport::Notifications.subscribe actions_regex, self
+    end
+
+    def unregister!
+      ActiveSupport::Notifications.unsubscribe @subscription
+      @subscription = nil
+    end
+
+    # AS::Notifications API
+
+    class Notification
+      def initialize(id, trace)
+        @id = id
+        @trace = trace
+      end
+      attr_reader :id, :trace
+    end
+
+    def start(name, id, payload)
+      return unless transaction = @client.current_transaction
+
+      normalized = @normalizers.normalize(transaction, name, payload)
+
+      trace = nil
+
+      unless normalized == :skip
+        sig, kind, extra = normalized
+
+        trace = Trace.new(transaction, sig, kind, transaction.running_traces, extra)
+        offset = transaction.current_offset
+
+        transaction.traces << trace
+
+        trace.start offset
+      end
+
+      transaction.notifications << Notification.new(id, trace)
+    end
+
+    def finish(_name, id, _payload)
+      return unless transaction = @client.current_transaction
+
+      while notification = transaction.notifications.pop
+        next unless notification.id == id
+        if trace = notification.trace
+          trace.done
+        end
+        return
+      end
+    end
+
+    private
+
+    def actions_regex
+      @actions_regex ||= Regexp.new(
+          '(' + @normalizers.keys.join('|') + ')'
+      )
+    end
+  end
+end