influxdb-rails 1.0.0 → 1.0.1.beta1

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

@@ -0,0 +1,67 @@
+require "influxdb/rails/middleware/subscriber"
+
+module InfluxDB
+  module Rails
+    module Middleware
+      class ActiveJobSubscriber < Subscriber # :nodoc:
+        private
+
+        def values
+          {
+            value: value,
+          }
+        end
+
+        def tags
+          {
+            hook:  short_hook_name,
+            state: job_state,
+            job:   job.class.name,
+            queue: job.queue_name,
+          }
+        end
+
+        def job_state
+          return "failed" if failed?
+
+          case short_hook_name
+          when "enqueue"
+            "queued"
+          when "perform_start"
+            "running"
+          when "perform"
+            "succeeded"
+          end
+        end
+
+        def measure_performance?
+          short_hook_name == "perform"
+        end
+
+        def short_hook_name
+          @short_hook_name ||= fetch_short_hook_name
+        end
+
+        def fetch_short_hook_name
+          return "enqueue" if hook_name.include?("enqueue")
+          return "perform_start" if hook_name.include?("perform_start")
+          return "perform" if hook_name.include?("perform")
+        end
+
+        def job
+          @job ||= payload[:job]
+        end
+
+        def value
+          return duration if measure_performance?
+
+          1
+        end
+
+        def failed?
+          payload[:exception_object]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require "influxdb/rails/middleware/subscriber"
+require "influxdb/rails/sql/query"
+
+module InfluxDB
+  module Rails
+    module Middleware
+      class ActiveRecordSubscriber < Subscriber # :nodoc:
+        private
+
+        def values
+          {
+            value:        duration,
+            record_count: payload[:record_count],
+          }
+        end
+
+        def tags
+          {
+            hook:       "instantiation",
+            class_name: payload[:class_name],
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require "influxdb/rails/middleware/subscriber"
+
+module InfluxDB
+  module Rails
+    module Middleware
+      class BlockInstrumentationSubscriber < Subscriber
+        private
+
+        def values
+          {
+            value: duration,
+          }.merge(payload[:values].to_h)
+        end
+
+        def tags
+          {
+            hook: "block_instrumentation",
+            name: payload[:name],
+          }.merge(payload[:tags].to_h)
+        end
+      end
+    end
+  end
+end

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

@@ -1,31 +1,30 @@
-require "influxdb/rails/middleware/simple_subscriber"
+require "influxdb/rails/middleware/subscriber"
 
 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
-
+      class RenderSubscriber < Subscriber # :nodoc:
         private
 
-        def values(started, finished, payload)
-          super(started, finished, payload).merge(
+        def values
+          {
+            value:      duration,
             count:      payload[:count],
-            cache_hits: payload[:cache_hits]
-          ).reject { |_, value| value.nil? }
+            cache_hits: payload[:cache_hits],
+          }
         end
 
-        def tags(payload)
-          tags = {
-            location: location,
+        def tags
+          {
             hook:     short_hook_name,
             filename: payload[:identifier],
           }
-          super(tags)
+        end
+
+        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
       end
     end

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

@@ -4,44 +4,39 @@ module InfluxDB
   module Rails
     module Middleware
       class RequestSubscriber < Subscriber # :nodoc:
-        def call(_name, start, finish, _id, payload)
-          return unless enabled?
-
-          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}")
+        def write
+          super
         ensure
           InfluxDB::Rails.current.reset
         end
 
         private
 
-        def tags(payload)
-          tags = {
+        def tags
+          {
             method:      "#{payload[:controller]}##{payload[:action]}",
             hook:        "process_action",
             status:      payload[:status],
             format:      payload[:format],
             http_method: payload[:method],
-            server:      Socket.gethostname,
-            app_name:    configuration.application_name,
+            exception:   payload[:exception]&.first,
           }
-          super(tags)
         end
 
-        def values(started, finished, payload)
+        def values
           {
-            controller: ((finished - started) * 1000).ceil,
+            controller: duration,
             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
+            started:    started,
+          }
+        end
+
+        def started
+          InfluxDB.convert_timestamp(
+            start.utc,
+            configuration.client.time_precision
+          )
         end
       end
     end

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

@@ -1,35 +1,35 @@
-require "influxdb/rails/middleware/simple_subscriber"
+require "influxdb/rails/middleware/subscriber"
 require "influxdb/rails/sql/query"
 
 module InfluxDB
   module Rails
     module Middleware
-      class SqlSubscriber < SimpleSubscriber # :nodoc:
-        def call(_name, started, finished, _unique_id, payload)
-          super if InfluxDB::Rails::Sql::Query.new(payload).track?
-        end
-
+      class SqlSubscriber < Subscriber # :nodoc:
         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
+        def values
+          {
+            value: duration,
+            sql:   InfluxDB::Rails::Sql::Normalizer.new(payload[:sql]).perform,
+          }
         end
 
-        def tags(payload)
-          query = InfluxDB::Rails::Sql::Query.new(payload)
-          tags = {
-            location:   location,
+        def tags
+          {
             hook:       "sql",
             operation:  query.operation,
             class_name: query.class_name,
             name:       query.name,
+            location:   :raw,
           }
-          super(tags)
+        end
+
+        def disabled?
+          super || !query.track?
+        end
+
+        def query
+          @query ||= InfluxDB::Rails::Sql::Query.new(payload)
         end
       end
     end

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

@@ -1,3 +1,5 @@
+require "influxdb/rails/metric"
+
 module InfluxDB
   module Rails
     module Middleware
@@ -5,49 +7,60 @@ module InfluxDB
       # which are intended as ActiveSupport::Notifications.subscribe
       # consumers.
       class Subscriber
-        attr_reader :configuration
-        attr_reader :hook_name
-
-        def initialize(configuration, hook_name)
+        def initialize(configuration:, hook_name:, start:, finish:, payload:)
           @configuration = configuration
           @hook_name = hook_name
+          @start = start
+          @finish = finish
+          @payload = payload
         end
 
-        def call(*)
-          raise NotImplementedError, "must be implemented in subclass"
+        def self.call(name, start, finish, _id, payload)
+          new(
+            configuration: InfluxDB::Rails.configuration,
+            start:         start,
+            finish:        finish,
+            payload:       payload,
+            hook_name:     name
+          ).write
+        end
+
+        def write
+          return if disabled?
+
+          metric.write
+        rescue StandardError => e
+          ::Rails.logger.error("[InfluxDB::Rails] Unable to write points: #{e.message}")
         end
 
         private
 
-        def timestamp(time)
-          InfluxDB.convert_timestamp(time.utc, client.time_precision)
+        attr_reader :configuration, :hook_name, :start, :finish, :payload
+
+        def metric
+          InfluxDB::Rails::Metric.new(
+            values:        values,
+            tags:          tags,
+            configuration: configuration,
+            timestamp:     finish
+          )
         end
 
-        def client
-          @client = configuration.client
+        def tags
+          raise NotImplementedError, "must be implemented in subclass"
         end
 
-        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
+        def values
+          raise NotImplementedError, "must be implemented in subclass"
         end
 
-        def enabled?
-          configuration.instrumentation_enabled? &&
-            !configuration.ignore_current_environment? &&
-            !configuration.ignored_hooks.include?(hook_name)
+        def duration
+          ((finish - start) * 1000).ceil
         end
 
-        def location
-          current = InfluxDB::Rails.current
-          [
-            current.controller,
-            current.action,
-          ].reject(&:blank?).join("#")
+        def disabled?
+          configuration.ignore_current_environment? ||
+            configuration.ignored_hooks.include?(hook_name)
         end
       end
     end

data/lib/influxdb/rails/railtie.rb

@@ -11,38 +11,35 @@ module InfluxDB
         end
 
         ActiveSupport.on_load(:action_controller) do
-          require "influxdb/rails/instrumentation"
-          include InfluxDB::Rails::Instrumentation
-
           before_action do
             current = InfluxDB::Rails.current
-            current.request_id = request.request_id if request.respond_to?(:request_id)
+            current.values = { request_id: request.request_id } if request.respond_to?(:request_id)
           end
         end
 
         cache = lambda do |_, _, _, _, payload|
           current = InfluxDB::Rails.current
-          current.controller = payload[:controller]
-          current.action     = payload[:action]
+          location = [payload[:controller], payload[:action]].join("#")
+          current.tags = { location: location }
         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)
+          "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,
+          "instantiation.active_record"          => Middleware::ActiveRecordSubscriber,
+          "enqueue.active_job"                   => Middleware::ActiveJobSubscriber,
+          "perform_start.active_job"             => Middleware::ActiveJobSubscriber,
+          "perform.active_job"                   => Middleware::ActiveJobSubscriber,
+          "block_instrumentation.influxdb_rails" => Middleware::BlockInstrumentationSubscriber,
+        }.each do |hook_name, subscriber|
+          ActiveSupport::Notifications.subscribe(hook_name, subscriber)
         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
 end

data/lib/influxdb/rails/tags.rb

@@ -0,0 +1,33 @@
+module InfluxDB
+  module Rails
+    class Tags
+      def initialize(tags: {}, config:, additional_tags: InfluxDB::Rails.current.tags)
+        @tags = tags
+        @config = config
+        @additional_tags = additional_tags
+      end
+
+      def to_h
+        expanded_tags.reject do |_, value|
+          value.nil? || value == ""
+        end
+      end
+
+      private
+
+      attr_reader :additional_tags, :tags, :config
+
+      def expanded_tags
+        config.tags_middleware.call(tags.merge(default_tags))
+      end
+
+      def default_tags
+        {
+          server:   Socket.gethostname,
+          app_name: config.application_name,
+          location: :raw,
+        }.merge(additional_tags)
+      end
+    end
+  end
+end