influx_reporter 1.0.0

data/lib/influx_reporter/error_message/stacktrace.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  class ErrorMessage
+    class Stacktrace
+      def initialize(config, frames)
+        @config = config
+        @frames = frames
+      end
+
+      attr_reader :frames
+
+      def self.from(config, exception)
+        return unless exception.backtrace
+
+        new(config, exception.backtrace.reverse.map do |line|
+          Frame.from_line config, line
+        end)
+      end
+
+      def to_h
+        { frames: frames.map(&:to_h) }
+      end
+
+      private
+
+      class Frame < Struct.new(:filename, :lineno, :abs_path, :function, :vars,
+          :pre_context, :context_line, :post_context)
+
+        BACKTRACE_REGEX = /^(.+?):(\d+)(?::in `(.+?)')?$/
+
+        class << self
+          def from_line(config, line)
+            _, abs_path, lineno, function = line.match(BACKTRACE_REGEX).to_a
+            lineno = lineno.to_i
+            filename = strip_load_path(abs_path)
+
+            if lines = config.context_lines
+              pre_context, context_line, post_context =
+                get_contextlines(abs_path, lineno, lines)
+            end
+
+            new filename, lineno, abs_path, function, nil,
+                pre_context, context_line, post_context
+          end
+
+          private
+
+          def strip_load_path(path)
+            prefix = $LOAD_PATH
+                         .map(&:to_s)
+                         .select { |s| path.start_with?(s) }
+                         .sort_by(&:length)
+                         .last
+
+            return path unless prefix
+
+            path[prefix.chomp(File::SEPARATOR).length + 1..-1]
+          end
+
+          def get_contextlines(path, line, context)
+            lines = (2 * context + 1).times.map do |i|
+              LineCache.find(path, line - context + i)
+            end
+
+            pre =  lines[0..(context - 1)]
+            line = lines[context]
+            post = lines[(context + 1)..-1]
+
+            [pre, line, post]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/influx_reporter/error_message/user.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  class ErrorMessage
+    class User < Struct.new(:is_authenticated, :id, :username, :email)
+      CONTROLLER_KEY = 'action_controller.instance'
+
+      def self.from_rack_env(config, env)
+        controller = env[CONTROLLER_KEY]
+        method = config.current_user_method.to_sym
+
+        return unless controller && controller.respond_to?(method)
+
+        user = controller.send method
+
+        new(
+            true,
+            user.respond_to?(:id) ? user.id : nil,
+            user.respond_to?(:username) ? user.username : nil,
+            user.respond_to?(:email) ? user.email : nil
+        )
+      end
+    end
+  end
+end

data/lib/influx_reporter/filter.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  # @api private
+  class Filter
+    MASK = '[FILTERED]'
+
+    def initialize(config)
+      @config = config
+      @params = rails_filters || config.filter_parameters
+    end
+
+    attr_reader :config
+
+    def apply(data, _opts = {})
+      case data
+        when String
+          apply_to_string data, opts = {}
+        when Hash
+          apply_to_hash data
+      end
+    end
+
+    def apply_to_string(str, opts = {})
+      sep = opts[:separator] || '&'
+      kv_sep = opts[:kv_separator] || '='
+
+      str.split(sep).map do |kv|
+        key, value = kv.split(kv_sep)
+        [key, kv_sep, sanitize(key, value)].join
+      end.join(sep)
+    end
+
+    def apply_to_hash(hsh)
+      hsh.each_with_object({}) do |kv, filtered|
+        key, value = kv
+        filtered[key] = sanitize(key, value)
+      end
+    end
+
+    def sanitize(key, value)
+      should_filter?(key) ? MASK : value
+    end
+
+    private
+
+    def should_filter?(key)
+      @params.any? do |param|
+        case param
+          when String, Symbol
+            key.to_s == param.to_s
+          when Regexp
+            param.match(key)
+        end
+      end
+    end
+
+    def rails_filters
+      if defined?(::Rails) && Rails.respond_to?(:application) && Rails.application
+        if filters = ::Rails.application.config.filter_parameters
+          filters.any? ? filters : nil
+        end
+      end
+    end
+  end
+end

data/lib/influx_reporter/http_client.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+require 'json'
+
+module InfluxReporter
+  # @api private
+  class HttpClient
+    include Logging
+
+    USER_AGENT = "influx_reporter-ruby/#{InfluxReporter::VERSION}"
+
+    attr_reader :state
+    attr_reader :adapter
+
+    def initialize(config)
+      @config = config
+      @adapter = HTTPAdapter.new(config)
+      @state = ClientState.new config
+    end
+
+    attr_reader :config
+
+    def post(resource, body)
+      path = abs_path(resource)
+      debug "POST #{resource}"
+
+      unless state.should_try?
+        info 'Temporarily skipping sending to InfluxReporter due to previous failure.'
+        return
+      end
+
+      body = JSON.dump(body) if body.is_a?(Hash) || body.is_a?(Array)
+
+      request = adapter.post path do |req|
+        req['Authorization'] = auth_header
+        req['Content-Type'] = 'application/json'
+        req['Content-Length'] = body.bytesize.to_s
+        req['User-Agent'] = USER_AGENT
+        req.body = body
+      end
+
+      begin
+        response = adapter.perform_request request
+        unless response.code.to_i.between?(200, 299)
+          raise Error, "Error from InfluxReporter server (#{response.code}): #{response.body}"
+        end
+      rescue
+        debug { JSON.parse(body).inspect }
+        @state.fail!
+        raise
+      end
+
+      @state.success!
+
+      response
+    end
+
+    private
+
+    def auth_header
+      "Bearer #{@config.secret_token}"
+    end
+
+    def abs_path(path)
+      "/api/v1/organizations/#{@config.organization_id}" \
+        "/apps/#{@config.app_id}#{path}"
+    end
+
+    def encode(event)
+      event_hash = @filter.process_event_hash(event.to_hash)
+      event_hash.to_json
+    end
+
+    class HTTPAdapter
+      def initialize(conf)
+        @config = conf
+      end
+
+      def post(path)
+        req = Net::HTTP::Post.new path
+        yield req if block_given?
+        req
+      end
+
+      def perform_request(req)
+        http.start do |http|
+          http.request req
+        end
+      end
+
+      private
+
+      def http
+        return @http if @http
+
+        http = Net::HTTP.new server_uri.host, server_uri.port
+        http.use_ssl = @config.use_ssl
+        http.read_timeout = @config.timeout
+        http.open_timeout = @config.open_timeout
+
+        @http = http
+      end
+
+      def server_uri
+        @uri ||= URI(@config.server)
+      end
+    end
+
+    class ClientState
+      def initialize(config)
+        @config = config
+        @retry_number = 0
+        @last_check = Time.now.utc
+      end
+
+      def should_try?
+        return true if @status == :online
+
+        interval = ([@retry_number, 6].min**2) * @config.backoff_multiplier
+        return true if Time.now.utc - @last_check > interval
+
+        false
+      end
+
+      def fail!
+        @status = :error
+        @retry_number += 1
+        @last_check = Time.now.utc
+      end
+
+      def success!
+        @status = :online
+        @retry_number = 0
+        @last_check = nil
+      end
+    end
+  end
+end

data/lib/influx_reporter/influx_db_client.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'influxdb'
+
+module InfluxReporter
+  # @api private
+  class InfluxDBClient
+    include Logging
+
+    attr_reader :state
+    attr_reader :client
+
+    # @param config [InfluxReporter::Configuration]
+    def initialize(config)
+      @config = config
+      @client = InfluxDB::Client.new config.database, config.influx_db.merge(time_precision: 'ns')
+      @state = ClientState.new config
+    end
+
+    attr_reader :config
+
+    def post(resource, data)
+      debug "POST #{resource}"
+
+      unless state.should_try?
+        info 'Temporarily skipping sending to InfluxReporter due to previous failure.'
+        return
+      end
+
+      begin
+        data = [data] unless data.is_a?(Array)
+        client.write_points data
+      rescue StandardError => e
+        debug { e.message }
+        @state.fail!
+        raise
+      end
+
+      @state.success!
+
+      true
+    end
+
+    class ClientState
+      def initialize(config)
+        @config = config
+        @retry_number = 0
+        @last_check = Time.now.utc
+      end
+
+      def should_try?
+        return true if @status == :online
+
+        interval = ([@retry_number, 6].min**2) * @config.backoff_multiplier
+        return true if Time.now.utc - @last_check > interval
+
+        false
+      end
+
+      def fail!
+        @status = :error
+        @retry_number += 1
+        @last_check = Time.now.utc
+      end
+
+      def success!
+        @status = :online
+        @retry_number = 0
+        @last_check = nil
+      end
+    end
+  end
+end

data/lib/influx_reporter/injections.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'influx_reporter/util/constantize'
+
+module InfluxReporter
+  # @api private
+  module Injections
+    class Registration
+      def initialize(const_name, require_paths, injector)
+        @const_name = const_name
+        @require_paths = Array(require_paths)
+        @injector = injector
+      end
+
+      attr_reader :const_name, :require_paths, :injector
+
+      def install
+        injector.install
+      end
+    end
+
+    def self.require_hooks
+      @require_hooks ||= {}
+    end
+
+    def self.installed
+      @installed ||= {}
+    end
+
+    def self.register(*args)
+      registration = Registration.new(*args)
+
+      if const_defined?(registration.const_name)
+        installed[registration.const_name] = registration
+        registration.install
+      else
+        register_require_hook registration
+      end
+    end
+
+    def self.register_require_hook(registration)
+      registration.require_paths.each do |path|
+        require_hooks[path] = registration
+      end
+    end
+
+    def self.hook_into(name)
+      return unless registration = lookup(name)
+
+      if const_defined?(registration.const_name)
+        installed[registration.const_name] = registration
+        registration.install
+
+        registration.require_paths.each do |path|
+          require_hooks.delete path
+        end
+      end
+    end
+
+    def self.lookup(require_path)
+      require_hooks[require_path]
+    end
+
+    def self.const_defined?(const_name)
+      const = begin
+                Util.constantize(const_name)
+              rescue
+                nil
+              end
+      !!const
+    end
+  end
+end
+
+# @api private
+module ::Kernel
+  alias_method :require_without_op, :require
+
+  def require(name)
+    res = require_without_op name
+
+    begin
+      InfluxReporter::Injections.hook_into name
+    rescue Exception
+    end
+
+    res
+  end
+end