influxdb-rails 1.0.0.beta1 → 1.0.1.beta1

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/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

@@ -0,0 +1,32 @@
+require "influxdb/rails/middleware/subscriber"
+
+module InfluxDB
+  module Rails
+    module Middleware
+      class RenderSubscriber < Subscriber # :nodoc:
+        private
+
+        def values
+          {
+            value:      duration,
+            count:      payload[:count],
+            cache_hits: payload[:cache_hits],
+          }
+        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
+  end
+end

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

@@ -0,0 +1,44 @@
+require "influxdb/rails/middleware/subscriber"
+
+module InfluxDB
+  module Rails
+    module Middleware
+      class RequestSubscriber < Subscriber # :nodoc:
+        def write
+          super
+        ensure
+          InfluxDB::Rails.current.reset
+        end
+
+        private
+
+        def tags
+          {
+            method:      "#{payload[:controller]}##{payload[:action]}",
+            hook:        "process_action",
+            status:      payload[:status],
+            format:      payload[:format],
+            http_method: payload[:method],
+            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
+  end
+end

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

@@ -0,0 +1,37 @@
+require "influxdb/rails/middleware/subscriber"
+require "influxdb/rails/sql/query"
+
+module InfluxDB
+  module Rails
+    module Middleware
+      class SqlSubscriber < Subscriber # :nodoc:
+        private
+
+        def values
+          {
+            value: duration,
+            sql:   InfluxDB::Rails::Sql::Normalizer.new(payload[:sql]).perform,
+          }
+        end
+
+        def tags
+          {
+            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
+end

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

@@ -0,0 +1,68 @@
+require "influxdb/rails/metric"
+
+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
+        def initialize(configuration:, hook_name:, start:, finish:, payload:)
+          @configuration = configuration
+          @hook_name = hook_name
+          @start = start
+          @finish = finish
+          @payload = payload
+        end
+
+        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
+
+        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
+
+        def values
+          raise NotImplementedError, "must be implemented in subclass"
+        end
+
+        def duration
+          ((finish - start) * 1000).ceil
+        end
+
+        def disabled?
+          configuration.ignore_current_environment? ||
+            configuration.ignored_hooks.include?(hook_name)
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/railtie.rb

@@ -4,39 +4,42 @@ 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
-
+      # rubocop:disable Metrics/BlockLength
       config.after_initialize do
-        InfluxDB::Rails.configure(true, &:load_rails_defaults)
+        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
+          before_action do
+            current = InfluxDB::Rails.current
+            current.values = { request_id: request.request_id } if request.respond_to?(:request_id)
+          end
         end
 
-        require "influxdb/rails/middleware/hijack_render_exception"
-        ::ActionDispatch::DebugExceptions.prepend InfluxDB::Rails::Middleware::HijackRenderException
-
-        if defined?(ActiveSupport::Notifications)
-          listen = lambda do |name, start, finish, id, payload|
-            c = InfluxDB::Rails.configuration
-
-            if c.instrumentation_enabled? && !c.ignore_current_environment?
-              begin
-                InfluxDB::Rails.handle_action_controller_metrics(name, start, finish, id, payload)
-              rescue StandardError => e
-                c.logger.error "[InfluxDB::Rails] Failed writing points to InfluxDB: #{e.message}"
-              end
-            end
-          end
+        cache = lambda do |_, _, _, _, payload|
+          current = InfluxDB::Rails.current
+          location = [payload[:controller], payload[:action]].join("#")
+          current.tags = { location: location }
+        end
+        ActiveSupport::Notifications.subscribe "start_processing.action_controller", &cache
 
-          ActiveSupport::Notifications.subscribe "process_action.action_controller", &listen
+        {
+          "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
     end
   end
 end