influxdb-rails 1.0.0.beta2 → 1.0.1.beta2

data/lib/influxdb/rails/context.rb

@@ -0,0 +1,26 @@
+module InfluxDB
+  module Rails
+    class Context
+      def reset
+        Thread.current[:_influxdb_rails_tags] = {}
+        Thread.current[:_influxdb_rails_values] = {}
+      end
+
+      def tags
+        Thread.current[:_influxdb_rails_tags].to_h
+      end
+
+      def tags=(tags)
+        Thread.current[:_influxdb_rails_tags] = self.tags.merge(tags)
+      end
+
+      def values
+        Thread.current[:_influxdb_rails_values].to_h
+      end
+
+      def values=(values)
+        Thread.current[:_influxdb_rails_values] = self.values.merge(values)
+      end
+    end
+  end
+end

data/lib/influxdb/rails/helpers/rspec_matchers.rb

@@ -0,0 +1,48 @@
+require_relative "../test_client"
+require "launchy"
+
+module InfluxDB
+  module Rails
+    module Matchers
+      def expect_metric(name: "rails", **options)
+        expect(metrics).to include(
+          a_hash_including(options.merge(name: name))
+        )
+      end
+
+      def expect_no_metric(name: "rails", **options)
+        expect(metrics).not_to include(
+          a_hash_including(options.merge(name: name))
+        )
+      end
+
+      def save_and_open_metrics
+        dir = File.join(File.dirname(__FILE__), "..", "..", "tmp")
+        FileUtils.mkdir_p(dir)
+        file_path = File.join(dir, "metrics.json")
+        output = JSON.pretty_generate(metrics)
+        File.write(file_path, output, mode: "wb")
+        ::Launchy.open(file_path)
+      end
+
+      def metrics
+        TestClient.metrics
+      end
+
+      RSpec.configure do |config|
+        config.before :each do
+          InfluxDB::Rails.instance_variable_set :@configuration, nil
+          InfluxDB::Rails.configure
+
+          allow(InfluxDB::Rails).to receive(:client).and_return(InfluxDB::Rails::TestClient.new)
+          allow_any_instance_of(InfluxDB::Rails::Configuration)
+            .to receive(:ignored_environments).and_return(%w[development])
+
+          InfluxDB::Rails::TestClient.metrics.clear
+        end
+
+        config.include InfluxDB::Rails::Matchers
+      end
+    end
+  end
+end

data/lib/influxdb/rails/metric.rb

@@ -0,0 +1,39 @@
+require "influxdb/rails/values"
+require "influxdb/rails/tags"
+
+module InfluxDB
+  module Rails
+    class Metric
+      def initialize(configuration:, timestamp:, tags: {}, values: {})
+        @configuration = configuration
+        @timestamp = timestamp
+        @tags = tags
+        @values = values
+      end
+
+      def write
+        client.write_point configuration.measurement_name, options
+      end
+
+      private
+
+      attr_reader :configuration, :tags, :values, :timestamp
+
+      def options
+        {
+          values:    Values.new(values: values).to_h,
+          tags:      Tags.new(tags: tags, config: configuration).to_h,
+          timestamp: timestamp_with_precision,
+        }
+      end
+
+      def timestamp_with_precision
+        InfluxDB.convert_timestamp(timestamp.utc, configuration.client.time_precision)
+      end
+
+      def client
+        InfluxDB::Rails.client
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require "influxdb/rails/middleware/subscriber"
+
+module InfluxDB
+  module Rails
+    module Middleware
+      class ActionMailerSubscriber < Subscriber # :nodoc:
+        private
+
+        def values
+          { value: 1 }
+        end
+
+        def tags
+          {
+            hook:   "deliver",
+            mailer: payload[:mailer],
+          }
+        end
+      end
+    end
+  end
+end

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,18 +1,30 @@
-require "influxdb/rails/middleware/simple_subscriber"
+require "influxdb/rails/middleware/subscriber"
 
 module InfluxDB
   module Rails
     module Middleware
-      class RenderSubscriber < SimpleSubscriber # :nodoc:
+      class RenderSubscriber < Subscriber # :nodoc:
         private
 
-        def tags(payload)
+        def values
           {
-            location:   location,
-            filename:   payload[:identifier],
+            value:      duration,
             count:      payload[:count],
             cache_hits: payload[:cache_hits],
-          }.reject { |_, value| value.blank? }
+          }
+        end
+
+        def tags
+          {
+            hook:     short_hook_name,
+            filename: payload[:identifier],
+          }
+        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,46 +4,39 @@ module InfluxDB
   module Rails
     module Middleware
       class RequestSubscriber < Subscriber # :nodoc:
-        def call(_name, start, finish, _id, payload) # rubocop:disable Metrics/MethodLength
-          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
-            Thread.current[:_influxdb_rails_controller] = nil
-            Thread.current[:_influxdb_rails_action]     = nil
-          end
+        def write
+          super
+        ensure
+          InfluxDB::Rails.current.reset
         end
 
         private
 
-        def series(payload, start, finish)
+        def tags
           {
-            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)
-          configuration.tags_middleware.call({
             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,
-          }.reject { |_, value| value.nil? })
+            exception:   payload[:exception]&.first,
+          }
+        end
+
+        def values
+          {
+            controller: duration,
+            view:       (payload[:view_runtime] || 0).ceil,
+            db:         (payload[:db_runtime] || 0).ceil,
+            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,31 +1,36 @@
-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)
-          return unless InfluxDB::Rails::Sql::Query.new(payload).track?
-
-          super
-        end
-
+      class SqlSubscriber < Subscriber # :nodoc:
         private
 
-        def values(started, finished, payload)
-          super.merge(sql: InfluxDB::Rails::Sql::Normalizer.new(payload[:sql]).perform)
+        def values
+          {
+            value: duration,
+            sql:   InfluxDB::Rails::Sql::Normalizer.new(payload[:sql]).perform,
+          }
         end
 
-        def tags(payload)
-          query = InfluxDB::Rails::Sql::Query.new(payload)
+        def tags
           {
-            location:   location,
+            hook:       "sql",
             operation:  query.operation,
             class_name: query.class_name,
             name:       query.name,
+            location:   :raw,
           }
         end
+
+        def disabled?
+          super || !query.track?
+        end
+
+        def query
+          @query ||= InfluxDB::Rails::Sql::Query.new(payload)
+        end
       end
     end
   end

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

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