experimental-influxdb-rails 1.0.0.beta5

data/lib/influxdb/rails/context.rb

@@ -0,0 +1,51 @@
+module InfluxDB
+  module Rails
+    class Context # rubocop:disable Style/Documentation
+      def controller
+        Thread.current[:_influxdb_rails_controller]
+      end
+
+      def controller=(value)
+        Thread.current[:_influxdb_rails_controller] = value
+      end
+
+      def action
+        Thread.current[:_influxdb_rails_action]
+      end
+
+      def action=(value)
+        Thread.current[:_influxdb_rails_action] = value
+      end
+
+      def location
+        [
+          controller,
+          action,
+        ].reject(&:blank?).join("#")
+      end
+
+      def reset
+        Thread.current[:_influxdb_rails_controller] = nil
+        Thread.current[:_influxdb_rails_action] = nil
+        Thread.current[:_influxdb_rails_tags] = nil
+        Thread.current[:_influxdb_rails_values] = nil
+      end
+
+      def tags
+        Thread.current[:_influxdb_rails_tags] || {}
+      end
+
+      def tags=(tags)
+        Thread.current[:_influxdb_rails_tags] = tags
+      end
+
+      def values
+        Thread.current[:_influxdb_rails_values] || {}
+      end
+
+      def values=(values)
+        Thread.current[:_influxdb_rails_values] = values
+      end
+    end
+  end
+end

data/lib/influxdb/rails/exception_presenter.rb

@@ -0,0 +1,94 @@
+require "base64"
+require "socket"
+require "json"
+
+module InfluxDB
+  module Rails
+    class ExceptionPresenter # rubocop:disable Style/Documentation
+      attr_reader :exception
+      attr_reader :backtrace
+      attr_reader :params
+      attr_reader :session_data
+      attr_reader :current_user
+      attr_reader :controller
+      attr_reader :action
+      attr_reader :request_url
+      attr_reader :referer
+      attr_reader :remote_ip
+      attr_reader :user_agent
+      attr_reader :custom_data
+
+      def initialize(ex, params = {})
+        ex = ex.continued_exception if ex.respond_to?(:continued_exception)
+        ex = ex.original_exception if ex.respond_to?(:original_exception)
+
+        @exception    = ex.is_a?(String) ? Exception.new(ex) : ex
+        @backtrace    = InfluxDB::Rails::Backtrace.new(@exception.backtrace)
+        @dimensions   = {}
+        configure_from_params(params)
+
+        @environment_variables = ENV.to_hash || {}
+      end
+
+      def context # rubocop:disable Metrics/MethodLength
+        c = {
+          application_name:  InfluxDB::Rails.configuration.application_name,
+          application_root:  InfluxDB::Rails.configuration.application_root,
+          framework:         InfluxDB::Rails.configuration.framework,
+          framework_version: InfluxDB::Rails.configuration.framework_version,
+          language:          "Ruby",
+          language_version:  "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}",
+          custom_data:       @custom_data,
+        }
+
+        InfluxDB::Rails.configuration.add_custom_exception_data(self)
+        c
+      end
+
+      def dimensions
+        {
+          class:    @exception.class.to_s,
+          method:   "#{@controller}##{@action}",
+          filename: File.basename(@backtrace.lines.first.try(:file)),
+          server:   Socket.gethostname,
+          status:   "open",
+        }.merge(@dimensions)
+      end
+
+      def values
+        {
+          exception_message:   @exception.message,
+          exception_backtrace: JSON.generate(@backtrace.to_a),
+        }
+      end
+
+      def request_data
+        {
+          params:       @params,
+          session_data: @session_data,
+          controller:   @controller,
+          action:       @action,
+          request_url:  @request_url,
+          referer:      @referer,
+          remote_ip:    @remote_ip,
+          user_agent:   @user_agent,
+        }
+      end
+
+      private
+
+      def configure_from_params(params)
+        @params       = params[:params]
+        @session_data = params[:session_data] || {}
+        @current_user = params[:current_user]
+        @controller   = params[:controller]
+        @action       = params[:action]
+        @request_url  = params[:request_url]
+        @user_agent   = params[:user_agent]
+        @referer      = params[:referer]
+        @remote_ip    = params[:remote_ip]
+        @custom_data  = params[:custom_data] || {}
+      end
+    end
+  end
+end

data/lib/influxdb/rails/instrumentation.rb

@@ -0,0 +1,34 @@
+module InfluxDB
+  module Rails
+    module Instrumentation # rubocop:disable Style/Documentation
+      def benchmark_for_instrumentation # rubocop:disable Metrics/MethodLength
+        start = Time.now
+        yield
+
+        c = InfluxDB::Rails.configuration
+        return if c.ignore_current_environment?
+
+        InfluxDB::Rails.client.write_point \
+          c.series_name_for_instrumentation,
+          values: {
+            value: ((Time.now - start) * 1000).ceil,
+          },
+          tags:   configuration.tags_middleware.call(
+            method: "#{controller_name}##{action_name}",
+            server: Socket.gethostname
+          )
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods # rubocop:disable Style/Documentation
+        def instrument(methods = [])
+          methods = [methods] unless methods.is_a?(Array)
+          around_filter :benchmark_for_instrumentation, only: methods
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/logger.rb

@@ -0,0 +1,16 @@
+module InfluxDB
+  module Rails
+    module Logger # rubocop:disable Style/Documentation
+      PREFIX = "[InfluxDB::Rails] ".freeze
+
+      private
+
+      def log(level, message)
+        c = InfluxDB::Rails.configuration
+        return if level != :error && !c.debug?
+
+        c.logger&.send(level, PREFIX + message)
+      end
+    end
+  end
+end

data/lib/influxdb/rails/middleware/hijack_render_exception.rb

@@ -0,0 +1,16 @@
+module InfluxDB
+  module Rails
+    module Middleware
+      module HijackRenderException # rubocop:disable Style/Documentation
+        def render_exception(env, ex)
+          controller = env["action_controller.instance"] || env.controller_instance
+          request_data = controller.try(:influxdb_request_data) || {}
+          unless InfluxDB::Rails.configuration.ignore_user_agent?(request_data[:user_agent])
+            InfluxDB::Rails.report_exception_unless_ignorable(ex, request_data)
+          end
+          super
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/middleware/hijack_rescue_action_everywhere.rb

@@ -0,0 +1,31 @@
+module InfluxDB
+  module Rails
+    module Middleware
+      module HijackRescueActionEverywhere # rubocop:disable Style/Documentation
+        def self.included(base)
+          base.send(:alias_method_chain, :rescue_action_in_public, :influxdb)
+          base.send(:alias_method_chain, :rescue_action_locally, :influxdb)
+        end
+
+        private
+
+        def rescue_action_in_public_with_influxdb(ex)
+          handle_exception(ex)
+          rescue_action_in_public_without_influxdb(ex)
+        end
+
+        def rescue_action_locally_with_influxdb(ex)
+          handle_exception(ex)
+          rescue_action_locally_without_influxdb(ex)
+        end
+
+        def handle_exception(ex)
+          request_data = influxdb_request_data || {}
+          return if InfluxDB::Rails.configuration.ignore_user_agent?(request_data[:user_agent])
+
+          InfluxDB::Rails.report_exception_unless_ignorable(ex, request_data)
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/middleware/render_subscriber.rb

@@ -0,0 +1,26 @@
+require "influxdb/rails/middleware/simple_subscriber"
+
+module InfluxDB
+  module Rails
+    module Middleware
+      class RenderSubscriber < SimpleSubscriber # :nodoc:
+        private
+
+        def values(started, finished, payload)
+          super(started, finished, payload).merge(
+            count:      payload[:count],
+            cache_hits: payload[:cache_hits]
+          ).reject { |_, value| value.nil? }
+        end
+
+        def tags(payload)
+          tags = {
+            location: location,
+            filename: payload[:identifier],
+          }
+          super(tags)
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/middleware/request_subscriber.rb

@@ -0,0 +1,59 @@
+require "influxdb/rails/middleware/subscriber"
+
+module InfluxDB
+  module Rails
+    module Middleware
+      class RequestSubscriber < Subscriber # :nodoc:
+        def call(_name, start, finish, _id, payload) # rubocop:disable Metrics/MethodLength
+          return unless enabled?
+
+          finished = InfluxDB.convert_timestamp(finish.utc, configuration.time_precision)
+          started = InfluxDB.convert_timestamp(start.utc, configuration.time_precision)
+          tags = tags(payload)
+          begin
+            series(payload, start, finish).each do |series_name, value|
+              InfluxDB::Rails.client.write_point \
+                series_name,
+                values:    values(value, started),
+                tags:      tags,
+                timestamp: finished
+            end
+          rescue StandardError => e
+            log :error, "[InfluxDB::Rails] Unable to write points: #{e.message}"
+          ensure
+            InfluxDB::Rails.current.reset
+          end
+        end
+
+        private
+
+        def values(duration, started)
+          addititional_values = InfluxDB::Rails.current.values
+          { value: duration, started: started }.merge(addititional_values).reject do |_, value|
+            value.nil? || value == ""
+          end
+        end
+
+        def series(payload, start, finish)
+          {
+            configuration.series_name_for_controller_runtimes => ((finish - start) * 1000).ceil,
+            configuration.series_name_for_view_runtimes       => (payload[:view_runtime] || 0).ceil,
+            configuration.series_name_for_db_runtimes         => (payload[:db_runtime] || 0).ceil,
+          }
+        end
+
+        def tags(payload)
+          tags = {
+            method:      "#{payload[:controller]}##{payload[:action]}",
+            status:      payload[:status],
+            format:      payload[:format],
+            http_method: payload[:method],
+            server:      Socket.gethostname,
+            app_name:    configuration.application_name,
+          }
+          super(tags)
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/middleware/simple_subscriber.rb

@@ -0,0 +1,49 @@
+require "influxdb/rails/middleware/subscriber"
+
+module InfluxDB
+  module Rails
+    module Middleware
+      # Subscriber acts as base class for different *Subscriber classes,
+      # which are intended as ActiveSupport::Notifications.subscribe
+      # consumers.
+      class SimpleSubscriber < Subscriber
+        attr_reader :series_name
+
+        def initialize(configuration, series_name)
+          super(configuration)
+          @series_name = series_name
+        end
+
+        def call(_name, started, finished, _unique_id, payload)
+          return unless enabled?
+
+          begin
+            InfluxDB::Rails.client.write_point series_name,
+                                               values:    values(started, finished, payload),
+                                               tags:      tags(payload),
+                                               timestamp: timestamp(finished.utc)
+          rescue StandardError => e
+            log :error, "[InfluxDB::Rails] Unable to write points: #{e.message}"
+          end
+        end
+
+        private
+
+        def values(started, finished, _payload)
+          result = { value: ((finished - started) * 1000).ceil }
+          result.merge(InfluxDB::Rails.current.values).reject do |_, value|
+            value.nil? || value == ""
+          end
+        end
+
+        def timestamp(finished)
+          InfluxDB.convert_timestamp(finished.utc, configuration.time_precision)
+        end
+
+        def enabled?
+          super && series_name.present?
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/middleware/sql_subscriber.rb

@@ -0,0 +1,38 @@
+require "influxdb/rails/middleware/simple_subscriber"
+require "influxdb/rails/sql/query"
+
+module InfluxDB
+  module Rails
+    module Middleware
+      class SqlSubscriber < SimpleSubscriber # :nodoc:
+        def call(_name, started, finished, _unique_id, payload)
+          return unless InfluxDB::Rails::Sql::Query.new(payload).track?
+
+          super
+        end
+
+        private
+
+        def values(started, finished, payload)
+          super.merge(sql: InfluxDB::Rails::Sql::Normalizer.new(payload[:sql]).perform)
+        end
+
+        def location
+          result = super
+          result.empty? ? :raw : result
+        end
+
+        def tags(payload)
+          query = InfluxDB::Rails::Sql::Query.new(payload)
+          tags = {
+            location:   location,
+            operation:  query.operation,
+            class_name: query.class_name,
+            name:       query.name,
+          }
+          super(tags)
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/middleware/subscriber.rb

@@ -0,0 +1,48 @@
+require "influxdb/rails/logger"
+
+module InfluxDB
+  module Rails
+    module Middleware
+      # Subscriber acts as base class for different *Subscriber classes,
+      # which are intended as ActiveSupport::Notifications.subscribe
+      # consumers.
+      class Subscriber
+        include InfluxDB::Rails::Logger
+
+        attr_reader :configuration
+
+        def initialize(configuration)
+          @configuration = configuration
+        end
+
+        def call(*)
+          raise NotImplementedError, "must be implemented in subclass"
+        end
+
+        private
+
+        def tags(tags)
+          result = tags.merge(InfluxDB::Rails.current.tags)
+          result = configuration.tags_middleware.call(result)
+          result.reject! do |_, value|
+            value.nil? || value == ""
+          end
+          result
+        end
+
+        def enabled?
+          configuration.instrumentation_enabled? &&
+            !configuration.ignore_current_environment?
+        end
+
+        def location
+          current = InfluxDB::Rails.current
+          [
+            current.controller,
+            current.action,
+          ].reject(&:blank?).join("#")
+        end
+      end
+    end
+  end
+end