influxdb-rails 1.0.0.beta3 → 1.0.0.beta4

data/lib/influxdb/rails/configuration.rb

@@ -1,211 +1,107 @@
+require "active_support/concern"
+
 module InfluxDB
   module Rails
-    # rubocop:disable Metrics/ClassLength
-
-    class Configuration # rubocop:disable Style/Documentation
-      attr_accessor :influxdb_hosts
-      attr_accessor :influxdb_port
-      attr_accessor :influxdb_username
-      attr_accessor :influxdb_password
-      attr_accessor :influxdb_database
-      attr_accessor :async
-      attr_accessor :use_ssl
-      attr_accessor :retry
-      attr_accessor :open_timeout
-      attr_accessor :read_timeout
-      attr_accessor :max_delay
-      attr_accessor :time_precision
-
-      attr_accessor :series_name_for_controller_runtimes
-      attr_accessor :series_name_for_view_runtimes
-      attr_accessor :series_name_for_db_runtimes
-      attr_accessor :series_name_for_exceptions
-      attr_accessor :series_name_for_instrumentation
-      attr_accessor :series_name_for_render_template
-      attr_accessor :series_name_for_render_partial
-      attr_accessor :series_name_for_render_collection
-      attr_accessor :series_name_for_sql
-
-      attr_accessor :tags_middleware
-      attr_accessor :rails_app_name
-
-      attr_accessor :application_name
-      attr_accessor :application_root
-
-      attr_accessor :logger
-      attr_accessor :environment
-      attr_accessor :framework
-      attr_accessor :framework_version
-      attr_accessor :language
-      attr_accessor :language_version
-      attr_accessor :ignored_exceptions
-      attr_accessor :ignored_exception_messages
-      attr_accessor :ignored_reports
-      attr_accessor :ignored_environments
-      attr_accessor :ignored_user_agents
-      attr_accessor :backtrace_filters
-      attr_accessor :aggregated_exception_classes
-      attr_accessor :environment_variables
-      attr_accessor :environment_variable_filters
-
-      attr_accessor :instrumentation_enabled
-      attr_accessor :debug
-
-      DEFAULTS = {
-        influxdb_hosts:                      ["localhost"].freeze,
-        influxdb_port:                       8086,
-        influxdb_username:                   "root".freeze,
-        influxdb_password:                   "root".freeze,
-        influxdb_database:                   nil,
-        async:                               true,
-        use_ssl:                             false,
-        retry:                               nil,
-        open_timeout:                        5,
-        read_timeout:                        300,
-        max_delay:                           30,
-        time_precision:                      "s".freeze,
-
-        series_name_for_controller_runtimes: "rails.controller".freeze,
-        series_name_for_view_runtimes:       "rails.view".freeze,
-        series_name_for_db_runtimes:         "rails.db".freeze,
-        series_name_for_exceptions:          "rails.exceptions".freeze,
-        series_name_for_instrumentation:     "instrumentation".freeze,
-        series_name_for_render_template:     "rails.render_template".freeze,
-        series_name_for_render_partial:      "rails.render_partial".freeze,
-        series_name_for_render_collection:   "rails.render_collection".freeze,
-        series_name_for_sql:                 nil,
-
-        tags_middleware:                     ->(tags) { tags },
-        rails_app_name:                      nil,
-
-        ignored_exceptions:                  %w[
-          ActiveRecord::RecordNotFound
-          ActionController::RoutingError
-        ].freeze,
-
-        ignored_exception_messages:          [].freeze,
-        ignored_reports:                     [].freeze,
-        ignored_environments:                %w[test cucumber selenium].freeze,
-        ignored_user_agents:                 %w[GoogleBot].freeze,
-        environment_variable_filters:        [
-          /password/i,
-          /key/i,
-          /secret/i,
-          /ps1/i,
-          /rvm_.*_clr/i,
-          /color/i,
-        ].freeze,
-
-        backtrace_filters:                   [
-          ->(line) { line.gsub(%r{^\./}, "") },
-          lambda { |line|
-            return line if InfluxDB::Rails.configuration.application_root.to_s.empty?
-
-            line.gsub(/#{InfluxDB::Rails.configuration.application_root}/, "[APP_ROOT]")
-          },
-          lambda { |line|
-            if defined?(Gem) && !Gem.path.nil? && !Gem.path.empty?
-              Gem.path.each { |path| line = line.gsub(/#{path}/, "[GEM_ROOT]") }
-            end
-            line
-          },
-        ].freeze,
-      }.freeze
-
-      # rubocop:disable Metrics/MethodLength
-      # rubocop:disable Metrics/AbcSize
+    module Configurable
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def defaults
+          @defaults ||= {}
+        end
+
+        def set_defaults(**values) # rubocop:disable Naming/AccessorMethodName:
+          defaults.merge! values
+          attr_accessor(*defaults.keys)
+        end
+      end
+
+      def load_defaults
+        self.class.defaults.each do |key, value|
+          val = value.dup rescue value
+          public_send "#{key}=", val
+        end
+      end
+    end
+    private_constant :Configurable
+
+    class ClientConfig
+      include Configurable
+
+      set_defaults(
+        hosts:          ["localhost"].freeze,
+        port:           8086,
+        username:       "root".freeze,
+        password:       "root".freeze,
+        database:       nil,
+        async:          true,
+        use_ssl:        false,
+        retry:          nil,
+        open_timeout:   5,
+        read_timeout:   300,
+        max_delay:      30,
+        time_precision: "s".freeze
+      )
 
       def initialize
-        @influxdb_hosts     = DEFAULTS[:influxdb_hosts]
-        @influxdb_port      = DEFAULTS[:influxdb_port]
-        @influxdb_username  = DEFAULTS[:influxdb_username]
-        @influxdb_password  = DEFAULTS[:influxdb_password]
-        @influxdb_database  = DEFAULTS[:influxdb_database]
-        @async              = DEFAULTS[:async]
-        @use_ssl            = DEFAULTS[:use_ssl]
-        @retry              = DEFAULTS[:retry]
-        @open_timeout       = DEFAULTS[:open_timeout]
-        @read_timeout       = DEFAULTS[:read_timeout]
-        @max_delay          = DEFAULTS[:max_delay]
-        @time_precision     = DEFAULTS[:time_precision]
-
-        @series_name_for_controller_runtimes  = DEFAULTS[:series_name_for_controller_runtimes]
-        @series_name_for_view_runtimes        = DEFAULTS[:series_name_for_view_runtimes]
-        @series_name_for_db_runtimes          = DEFAULTS[:series_name_for_db_runtimes]
-        @series_name_for_exceptions           = DEFAULTS[:series_name_for_exceptions]
-        @series_name_for_instrumentation      = DEFAULTS[:series_name_for_instrumentation]
-        @series_name_for_render_template      = DEFAULTS[:series_name_for_render_template]
-        @series_name_for_render_partial       = DEFAULTS[:series_name_for_render_partial]
-        @series_name_for_render_collection    = DEFAULTS[:series_name_for_render_collection]
-        @series_name_for_sql                  = DEFAULTS[:series_name_for_sql]
-
-        @tags_middleware = DEFAULTS[:tags_middleware]
-        @rails_app_name = DEFAULTS[:rails_app_name]
-
-        @ignored_exceptions           = DEFAULTS[:ignored_exceptions].dup
-        @ignored_exception_messages   = DEFAULTS[:ignored_exception_messages].dup
-        @ignored_reports              = DEFAULTS[:ignored_reports].dup
-        @ignored_environments         = DEFAULTS[:ignored_environments].dup
-        @ignored_user_agents          = DEFAULTS[:ignored_user_agents].dup
-        @backtrace_filters            = DEFAULTS[:backtrace_filters].dup
-        @environment_variable_filters = DEFAULTS[:environment_variable_filters]
-        @aggregated_exception_classes = []
-
-        @debug                    = false
-        @rescue_global_exceptions = false
-        @instrumentation_enabled  = true
+        load_defaults
       end
+    end
+    private_constant :ClientConfig
+
+    class Configuration
+      include Configurable
+
+      set_defaults(
+        measurement_name:        "rails".freeze,
+        ignored_hooks:           [].freeze,
+        tags_middleware:         ->(tags) { tags },
+        rails_app_name:          nil,
+        ignored_environments:    %w[test cucumber selenium].freeze,
+        environment:             ::Rails.env,
+        debug:                   false,
+        instrumentation_enabled: true
+      )
+
+      # config option set after_initialize
+      attr_accessor(:environment, :application_name)
+
+      # configuration passed to InfluxDB::Client
+      attr_reader :client
+
+      # FIXME: Old configuration options, remove this in 1.0.1
+      attr_writer \
+        :series_name_for_controller_runtimes,
+        :series_name_for_view_runtimes,
+        :series_name_for_db_runtimes,
+        :series_name_for_render_template,
+        :series_name_for_render_partial,
+        :series_name_for_render_collection,
+        :series_name_for_sql,
+        :series_name_for_exceptions,
+        :series_name_for_instrumentation,
+        :ignored_exceptions,
+        :ignored_exception_messages,
+        :ignored_user_agents,
+        :environment_variable_filters,
+        :backtrace_filters
 
-      # rubocop:enable Metrics/MethodLength
-      # rubocop:enable Metrics/AbcSize
+      def initialize
+        @client = ClientConfig.new
+        load_defaults
+      end
 
       def debug?
-        !!@debug # rubocop:disable Style/DoubleNegation
+        @debug
       end
 
       def instrumentation_enabled?
-        !!@instrumentation_enabled # rubocop:disable Style/DoubleNegation
-      end
-
-      def ignore_user_agent?(incoming_user_agent)
-        return false if ignored_user_agents.nil?
-
-        ignored_user_agents.any? { |agent| incoming_user_agent =~ /#{agent}/ }
+        @instrumentation_enabled
       end
 
       def ignore_current_environment?
         ignored_environments.include?(environment)
       end
-
-      def ignore_exception?(ex)
-        !ignored_exception_messages.find { |msg| /.*#{msg}.*/ =~ ex.message }.nil? ||
-          ignored_exceptions.include?(ex.class.to_s)
-      end
-
-      def define_custom_exception_data(&block)
-        @custom_exception_data_handler = block
-      end
-
-      def add_custom_exception_data(exception_presenter)
-        @custom_exception_data_handler&.call(exception_presenter)
-      end
-
-      def load_rails_defaults
-        @logger           ||= ::Rails.logger
-        @environment      ||= ::Rails.env
-        @application_root ||= ::Rails.root
-        @application_name ||= ::Rails.application.class.parent_name
-        @framework          = "Rails"
-        @framework_version  = ::Rails.version
-      end
-
-      private
-
-      def initialize_http_connection
-        Net::HTTP.new(@app_host, "80")
-      end
     end
-
-    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/influxdb/rails/context.rb

@@ -1,6 +1,6 @@
 module InfluxDB
   module Rails
-    class Context # rubocop:disable Style/Documentation
+    class Context
       def controller
         Thread.current[:_influxdb_rails_controller]
       end
@@ -17,6 +17,14 @@ module InfluxDB
         Thread.current[:_influxdb_rails_action] = value
       end
 
+      def request_id=(value)
+        Thread.current[:_influxdb_rails_request_id] = value
+      end
+
+      def request_id
+        Thread.current[:_influxdb_rails_request_id]
+      end
+
       def location
         [
           controller,
@@ -28,6 +36,8 @@ module InfluxDB
         Thread.current[:_influxdb_rails_controller] = nil
         Thread.current[:_influxdb_rails_action] = nil
         Thread.current[:_influxdb_rails_tags] = nil
+        Thread.current[:_influxdb_rails_values] = nil
+        Thread.current[:_influxdb_rails_request_id] = nil
       end
 
       def tags
@@ -37,6 +47,14 @@ module InfluxDB
       def tags=(tags)
         Thread.current[:_influxdb_rails_tags] = tags
       end
+
+      def values
+        Thread.current[:_influxdb_rails_values].to_h.merge(request_id: request_id)
+      end
+
+      def values=(values)
+        Thread.current[:_influxdb_rails_values] = values
+      end
     end
   end
 end

data/lib/influxdb/rails/instrumentation.rb

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

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

@@ -4,6 +4,12 @@ module InfluxDB
   module Rails
     module Middleware
       class RenderSubscriber < SimpleSubscriber # :nodoc:
+        def short_hook_name
+          return "render_template" if hook_name.include?("render_template")
+          return "render_partial" if hook_name.include?("render_partial")
+          return "render_collection" if hook_name.include?("render_collection")
+        end
+
         private
 
         def values(started, finished, payload)
@@ -16,6 +22,7 @@ module InfluxDB
         def tags(payload)
           tags = {
             location: location,
+            hook:     short_hook_name,
             filename: payload[:identifier],
           }
           super(tags)

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

@@ -4,39 +4,26 @@ module InfluxDB
   module Rails
     module Middleware
       class RequestSubscriber < Subscriber # :nodoc:
-        def call(_name, start, finish, _id, payload) # rubocop:disable Metrics/MethodLength
+        def call(_name, start, finish, _id, payload)
           return unless enabled?
 
-          ts = InfluxDB.convert_timestamp(finish.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:    { value: value },
-                tags:      tags,
-                timestamp: ts
-            end
-          rescue StandardError => e
-            log :error, "[InfluxDB::Rails] Unable to write points: #{e.message}"
-          ensure
-            InfluxDB::Rails.current.reset
-          end
+          InfluxDB::Rails.client.write_point \
+            configuration.measurement_name,
+            values:    values(start, finish, payload),
+            tags:      tags(payload),
+            timestamp: timestamp(finish)
+        rescue StandardError => e
+          ::Rails.logger.error("[InfluxDB::Rails] Unable to write points: #{e.message}")
+        ensure
+          InfluxDB::Rails.current.reset
         end
 
         private
 
-        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]}",
+            hook:        "process_action",
             status:      payload[:status],
             format:      payload[:format],
             http_method: payload[:method],
@@ -45,6 +32,17 @@ module InfluxDB
           }
           super(tags)
         end
+
+        def values(started, finished, payload)
+          {
+            controller: ((finished - started) * 1000).ceil,
+            view:       (payload[:view_runtime] || 0).ceil,
+            db:         (payload[:db_runtime] || 0).ceil,
+            started:    timestamp(started),
+          }.merge(InfluxDB::Rails.current.values).reject do |_, value|
+            value.nil? || value == ""
+          end
+        end
       end
     end
   end

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

@@ -7,38 +7,25 @@ module InfluxDB
       # 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)
+        def call(_name, started, finished, _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
+          InfluxDB::Rails.client.write_point \
+            configuration.measurement_name,
+            values:    values(started, finished, payload),
+            tags:      tags(payload),
+            timestamp: timestamp(finished)
+        rescue StandardError => e
+          ::Rails.logger.error("[InfluxDB::Rails] Unable to write points: #{e.message}")
         end
 
         private
 
         def values(started, finished, _payload)
-          { value: ((finished - started) * 1000).ceil }
-        end
-
-        def timestamp(finished)
-          InfluxDB.convert_timestamp(finished.utc, configuration.time_precision)
-        end
-
-        def enabled?
-          super && series_name.present?
+          result = { value: ((finished - started) * 1000).ceil }
+          result.merge(InfluxDB::Rails.current.values).reject do |_, value|
+            value.nil? || value == ""
+          end
         end
       end
     end

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

@@ -6,9 +6,7 @@ module InfluxDB
     module Middleware
       class SqlSubscriber < SimpleSubscriber # :nodoc:
         def call(_name, started, finished, _unique_id, payload)
-          return unless InfluxDB::Rails::Sql::Query.new(payload).track?
-
-          super
+          super if InfluxDB::Rails::Sql::Query.new(payload).track?
         end
 
         private
@@ -17,10 +15,16 @@ module InfluxDB
           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,
+            hook:       "sql",
             operation:  query.operation,
             class_name: query.class_name,
             name:       query.name,

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

@@ -1,5 +1,3 @@
-require "influxdb/rails/logger"
-
 module InfluxDB
   module Rails
     module Middleware
@@ -7,12 +5,12 @@ module InfluxDB
       # which are intended as ActiveSupport::Notifications.subscribe
       # consumers.
       class Subscriber
-        include InfluxDB::Rails::Logger
-
         attr_reader :configuration
+        attr_reader :hook_name
 
-        def initialize(configuration)
+        def initialize(configuration, hook_name)
           @configuration = configuration
+          @hook_name = hook_name
         end
 
         def call(*)
@@ -21,14 +19,27 @@ module InfluxDB
 
         private
 
+        def timestamp(time)
+          InfluxDB.convert_timestamp(time.utc, client.time_precision)
+        end
+
+        def client
+          @client = configuration.client
+        end
+
         def tags(tags)
-          merged_tags = tags.merge(InfluxDB::Rails.current.tags).reject { |_, value| value.nil? }
-          configuration.tags_middleware.call(merged_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?
+            !configuration.ignore_current_environment? &&
+            !configuration.ignored_hooks.include?(hook_name)
         end
 
         def location

data/lib/influxdb/rails/railtie.rb

@@ -4,47 +4,44 @@ require "rails"
 module InfluxDB
   module Rails
     class Railtie < ::Rails::Railtie # :nodoc:
-      initializer "influxdb.insert_rack_middleware" do |app|
-        app.config.middleware.insert 0, InfluxDB::Rails::Rack
-      end
-
-      config.after_initialize do # rubocop:disable Metrics/BlockLength
-        InfluxDB::Rails.configure(true, &:load_rails_defaults)
+      # rubocop:disable Metrics/BlockLength
+      config.after_initialize do
+        InfluxDB::Rails.configure do |config|
+          config.environment ||= ::Rails.env
+        end
 
         ActiveSupport.on_load(:action_controller) do
-          require "influxdb/rails/air_traffic_controller"
-          include InfluxDB::Rails::AirTrafficController
           require "influxdb/rails/instrumentation"
           include InfluxDB::Rails::Instrumentation
-        end
 
-        require "influxdb/rails/middleware/hijack_render_exception"
-        ::ActionDispatch::DebugExceptions.prepend InfluxDB::Rails::Middleware::HijackRenderException
-
-        if defined?(ActiveSupport::Notifications)
-          cache = lambda do |_, _, _, _, payload|
+          before_action do
             current = InfluxDB::Rails.current
-            current.controller = payload[:controller]
-            current.action     = payload[:action]
+            current.request_id = request.request_id if request.respond_to?(:request_id)
           end
-          ActiveSupport::Notifications.subscribe "start_processing.action_controller", &cache
-
-          c = InfluxDB::Rails.configuration
-          requests = Middleware::RequestSubscriber.new(c)
-          ActiveSupport::Notifications.subscribe "process_action.action_controller", requests
-
-          templates = Middleware::RenderSubscriber.new(c, c.series_name_for_render_template)
-          ActiveSupport::Notifications.subscribe "render_template.action_view", templates
-
-          partials = Middleware::RenderSubscriber.new(c, c.series_name_for_render_partial)
-          ActiveSupport::Notifications.subscribe "render_partial.action_view", partials
-
-          collections = Middleware::RenderSubscriber.new(c, c.series_name_for_render_collection)
-          ActiveSupport::Notifications.subscribe "render_collection.action_view", collections
+        end
 
-          sql = Middleware::SqlSubscriber.new(c, c.series_name_for_sql)
-          ActiveSupport::Notifications.subscribe "sql.active_record", sql
+        cache = lambda do |_, _, _, _, payload|
+          current = InfluxDB::Rails.current
+          current.controller = payload[:controller]
+          current.action     = payload[:action]
         end
+        ActiveSupport::Notifications.subscribe "start_processing.action_controller", &cache
+
+        {
+          "process_action.action_controller" => Middleware::RequestSubscriber,
+          "render_template.action_view"      => Middleware::RenderSubscriber,
+          "render_partial.action_view"       => Middleware::RenderSubscriber,
+          "render_collection.action_view"    => Middleware::RenderSubscriber,
+          "sql.active_record"                => Middleware::SqlSubscriber,
+        }.each do |hook_name, subscriber_class|
+          subscribe_to(hook_name, subscriber_class)
+        end
+      end
+      # rubocop:enable Metrics/BlockLength
+
+      def subscribe_to(hook_name, subscriber_class)
+        subscriber = subscriber_class.new(InfluxDB::Rails.configuration, hook_name)
+        ActiveSupport::Notifications.subscribe hook_name, subscriber
       end
     end
   end