influx_reporter 1.0.0

data/lib/influx_reporter/configuration.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module InfluxReporter
+  class Configuration
+    DEFAULTS = {
+        influx_db: {},
+        database: 'endpoints',
+        logger: Logger.new(nil),
+        context_lines: 3,
+        enabled_environments: %w[production],
+        excluded_exceptions: [],
+        filter_parameters: [/(authorization|password|passwd|secret)/i],
+        timeout: 100,
+        open_timeout: 100,
+        backoff_multiplier: 2,
+        current_user_method: :current_user,
+        environment: ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'default',
+        transaction_post_interval: 60,
+        worker_quit_timeout: 5,
+
+        payload_tags: [],
+        payload_values: [],
+
+        disable_performance: false,
+        disable_errors: false,
+
+        debug_traces: false,
+
+        view_paths: [],
+
+        tags: {},
+
+        # for tests
+        disable_worker: false
+    }.freeze
+
+    attr_accessor :influx_db
+    attr_accessor :database
+    attr_accessor :logger
+    attr_accessor :context_lines
+    attr_accessor :enabled_environments
+    attr_accessor :excluded_exceptions
+    attr_accessor :filter_parameters
+    attr_accessor :timeout
+    attr_accessor :open_timeout
+    attr_accessor :backoff_multiplier
+    attr_accessor :use_ssl
+    attr_accessor :current_user_method
+    attr_accessor :environment
+    attr_accessor :transaction_post_interval
+    attr_accessor :worker_quit_timeout
+
+    attr_accessor :payload_tags
+    attr_accessor :payload_values
+
+    attr_accessor :disable_performance
+    attr_accessor :disable_errors
+
+    attr_accessor :debug_traces
+
+    attr_accessor :disable_worker
+
+    attr_accessor :view_paths
+
+    attr_accessor :tags
+
+    def initialize(opts = {})
+      DEFAULTS.merge(opts).each do |k, v|
+        send("#{k}=", v)
+      end
+
+      yield self if block_given?
+    end
+
+    def validate!
+      %w[database influx_db tags].each do |key|
+        raise Error, "InfluxReporter Configuration missing `#{key}'" unless send(key)
+      end
+
+      true
+    rescue Error => e
+      logger.error e.message
+      false
+    end
+  end
+end

data/lib/influx_reporter/data_builders.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  # @api private
+  module DataBuilders
+    class DataBuilder
+      def initialize(config)
+        @config = config
+      end
+
+      attr_reader :config
+    end
+
+    %w[transactions error].each do |f|
+      require "influx_reporter/data_builders/#{f}"
+    end
+  end
+end

data/lib/influx_reporter/data_builders/error.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'influx_reporter/filter'
+
+module InfluxReporter
+  module DataBuilders
+    class Error < DataBuilder
+      # @param error_message [InfluxReporter::ErrorMessage]
+      def build(error_message)
+        {
+            series: 'errors',
+            values: build_values(error_message),
+            tags: build_tags(error_message),
+            timestamp: error_message.timestamp
+        }
+      end
+
+      private
+
+      # @param error_message [InfluxReporter::ErrorMessage]
+      def build_tags(error_message)
+        tags = {
+            level: error_message.level,
+            excpetion: error_message.exception&.type,
+            module: error_message.exception&.module,
+            user_id: error_message.user&.id,
+            method: error_message.http&.method
+        }
+        tags = error_message.extra[:tags].merge(tags) if error_message.extra && error_message.extra[:tags].is_a?(Hash)
+        tags = error_message.config.tags.merge(tags)
+        tags.reject { |_, value| value.nil? || value == '' }
+      end
+
+      # @param error_message [InfluxReporter::ErrorMessage]
+      def build_values(error_message)
+        values = {
+            message: error_message.message,
+            culprit: error_message.culprit
+        }
+        if error_message.http
+          values[:url] = error_message.http.url
+          values[:user_agent] = error_message.http.user_agent
+          values[:user_agent] = error_message.http.user_agent
+          values[:uuid] = error_message.http.uuid
+        end
+        values = error_message.extra[:values].merge(values) if error_message.extra && error_message.extra[:values].is_a?(Hash)
+
+        values.reject { |_, value| value.nil? }
+      end
+    end
+  end
+end

data/lib/influx_reporter/data_builders/transactions.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+require 'influx_reporter/transaction'
+
+module InfluxReporter
+  module DataBuilders
+    class Transactions < DataBuilder
+      def build(transactions)
+        data_points = []
+        transactions.each do |transaction|
+          data_points << build_transaction(transaction)
+          transaction.traces.each do |trace|
+            next if trace.kind == InfluxReporter::Transaction::ROOT_TRACE_NAME
+            data_points << build_trace(trace)
+          end
+        end
+        data_points
+      end
+
+      private
+
+      # @param transaction [InfluxReporter::Transaction]
+      def build_transaction(transaction)
+        {
+            series: series(transaction),
+            tags: tags(transaction),
+            values: values(transaction),
+            timestamp: transaction.timestamp
+        }
+      end
+
+      # @param transaction [InfluxReporter::Transaction, InfluxReporter::Trace]
+      # @return [String]
+      def series(transaction)
+        transaction.kind.split('.').first(2).join('.')
+      end
+
+      # @param transaction [InfluxReporter::Transaction]
+      # @return [Hash]
+      def tags(transaction)
+        tags = {
+            endpoint: transaction.endpoint,
+            result: transaction.result.to_i,
+            kind: transaction.kind.split('.')[2..-1].join('.')
+        }
+        tags = (transaction.root_trace.extra[:tags] || {}).merge(tags)
+        tags = transaction.config.tags.merge(tags) if transaction.config
+        clean tags
+      end
+
+      # @param transaction [InfluxReporter::Transaction]
+      # @return [Hash]
+      def values(transaction)
+        values = {
+            duration: ms(transaction.duration)
+        }.merge(values_from_traces(transaction))
+        values = (transaction.root_trace.extra[:values] || {}).merge(values)
+        clean values
+      end
+
+      # @param transaction [InfluxReporter::Transaction]
+      # @return [Hash]
+      def values_from_traces(transaction)
+        values = {}
+        transaction.traces.each do |trace|
+          next if trace.signature == InfluxReporter::Transaction::ROOT_TRACE_NAME || trace.transaction.root_trace == trace
+          values["#{trace.kind}.count"] ||= 0
+          values["#{trace.kind}.duration"] ||= 0
+          values["#{trace.kind}.count"] += 1
+          values["#{trace.kind}.duration"] += ms(trace.duration)
+        end
+        values
+      end
+
+      # @param trace [InfluxReporter::Trace]
+      # @return [Hash]
+      def build_trace(trace)
+        {
+            series: "trace.#{trace.kind.split('.').first}",
+            tags: trace_tags(trace),
+            values: trace_values(trace),
+            timestamp: trace.timestamp
+        }
+      end
+
+      # @param trace [InfluxReporter::Trace]
+      def trace_tags(trace)
+        tags = {
+            endpoint: trace.transaction.endpoint,
+            signature: trace.signature,
+            kind: trace.kind.split('.')[1..-1].join('.')
+        }
+        tags = (trace.transaction.root_trace.extra[:tags] || {}).merge(trace.extra[:tags] || {}).merge(tags)
+        tags = trace.transaction.config.tags.merge(tags) if trace.transaction.config
+        clean tags
+      end
+
+      # @param trace [InfluxReporter::Trace]
+
+      def trace_values(trace)
+        values = {
+            duration: ms(trace.duration),
+            start_time: ms(trace.relative_start)
+        }
+        values = (trace.extra[:values] || {}).merge(values)
+        values[:uuid] ||= trace.transaction.root_trace.extra[:values][:uuid] if trace.transaction.root_trace.extra[:values]
+        clean values
+      end
+
+      # @param hash [Hash]
+      # @return [Hash]
+      def clean(hash)
+        hash.reject { |_, value| value.nil? || value == '' }
+      end
+
+      def ms(nanos)
+        nanos.to_f / 1_000_000
+      end
+    end
+  end
+end

data/lib/influx_reporter/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  # @api private
+  class Error < StandardError
+  end
+end

data/lib/influx_reporter/error_message.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'influx_reporter/line_cache'
+require 'influx_reporter/error_message/exception'
+require 'influx_reporter/error_message/stacktrace'
+require 'influx_reporter/error_message/http'
+require 'influx_reporter/error_message/user'
+require 'influx_reporter/util/timestamp'
+
+module InfluxReporter
+  class ErrorMessage
+    extend Logging
+
+    DEFAULTS = {
+        level: :error,
+        logger: 'root'
+    }.freeze
+
+    def initialize(config, message, attrs = {})
+      @config = config
+
+      @message = message
+      @timestamp = Util.nanos
+
+      DEFAULTS.merge(attrs).each do |k, v|
+        send(:"#{k}=", v)
+      end
+      @filter = Filter.new config
+
+      yield self if block_given?
+    end
+
+    attr_reader :config
+    attr_accessor :message
+    attr_reader :timestamp
+    attr_reader :filter
+    attr_accessor :level
+    attr_accessor :logger
+    attr_accessor :culprit
+    attr_accessor :machine
+    attr_accessor :extra
+    attr_accessor :param_message
+    attr_accessor :exception
+    attr_accessor :stacktrace
+    attr_accessor :http
+    attr_accessor :user
+
+    def self.from_exception(config, exception, opts = {})
+      message = "#{exception.class}: #{exception.message}"
+
+      if config.excluded_exceptions.include? exception.class.to_s
+        info "Skipping excluded exception #{exception.class}"
+        return nil
+      end
+
+      error_message = new(config, message) do |msg|
+        msg.level = :error
+        msg.exception = Exception.from(exception)
+        msg.stacktrace = Stacktrace.from(config, exception)
+      end
+
+      if frames = error_message.stacktrace&.frames
+        if first_frame = frames.last
+          error_message.culprit = "#{first_frame.filename}:#{first_frame.lineno}:in `#{first_frame.function}'"
+        end
+      end
+
+      if env = opts[:rack_env]
+        error_message.http = HTTP.from_rack_env env, filter: error_message.filter
+        error_message.user = User.from_rack_env config, env
+      end
+
+      if extra = opts[:extra]
+        error_message.extra = extra
+      end
+
+      error_message
+    end
+
+    def add_extra(info)
+      @extra ||= {}
+      @extra.merge! info
+    end
+  end
+end

data/lib/influx_reporter/error_message/exception.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  class ErrorMessage
+    class Exception < Struct.new(:type, :value, :module)
+      SPLIT = '::'
+
+      def self.from(exception)
+        new exception.class.to_s, exception.message,
+            exception.class.to_s.split(SPLIT)[0...-1].join(SPLIT)
+      end
+    end
+  end
+end

data/lib/influx_reporter/error_message/http.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  class ErrorMessage
+    class HTTP < Struct.new(:url, :method, :data, :query_string, :cookies,
+        :headers, :remote_host, :http_host, :user_agent,
+        :secure, :env, :uuid)
+
+      HTTP_ENV_KEY = /^HTTP_/
+      UNDERSCORE = '_'
+
+      DASH = '-'
+      QUESTION = '?'
+
+      def self.from_rack_env(env, opts = {})
+        req = if defined?(ActionDispatch::Request) && env.is_a?(ActionDispatch::Request)
+                env
+              else
+                Rack::Request.new env
+              end
+
+        http = new(
+            req.url.split(QUESTION).first,               # url
+            req.request_method,                          # method
+            nil,                                         # data
+            req.query_string,                            # query string
+            env['HTTP_COOKIE'],                          # cookies
+            {},                                          # headers
+            req.ip,                                      # remote host
+            req.host_with_port,                          # http host
+            req.user_agent,                              # user agent
+            req.scheme == 'https', # secure
+            {}, # env
+            req.respond_to?(:uuid) ? req.uuid : nil
+        )
+
+        # In Rails < 5 ActionDispatch::Request inherits from Hash
+        headers = env.respond_to?(:headers) ? env.headers : env
+
+        headers.each do |k, v|
+          next unless k.upcase == k # lower case stuff isn't relevant
+
+          if k.match(HTTP_ENV_KEY)
+            header = k.gsub(HTTP_ENV_KEY, '')
+                         .split(UNDERSCORE).map(&:capitalize).join(DASH)
+            http.headers[header] = v.to_s
+          else
+            http.env[k] = v.to_s
+          end
+        end
+
+        if req.form_data?
+          http.data = req.POST
+        elsif req.body
+          http.data = req.body.read
+          req.body.rewind
+        end
+
+        if filter = opts[:filter]
+          http.apply_filter filter
+        end
+
+        http
+      end
+
+      def apply_filter(filter)
+        self.data = filter.apply data
+        self.query_string = filter.apply query_string
+        self.cookies = filter.apply cookies
+      end
+    end
+  end
+end