influxdb-rails 1.0.0.beta1 → 1.0.0.beta2

data/lib/influxdb-rails.rb

@@ -2,6 +2,10 @@ require "net/http"
 require "net/https"
 require "rubygems"
 require "socket"
+require "influxdb/rails/middleware/render_subscriber"
+require "influxdb/rails/middleware/request_subscriber"
+require "influxdb/rails/middleware/sql_subscriber"
+require "influxdb/rails/sql/query"
 require "influxdb/rails/version"
 require "influxdb/rails/logger"
 require "influxdb/rails/exception_presenter"
@@ -69,11 +73,14 @@ module InfluxDB
         env = influxdb_request_data if env.empty? && defined? influxdb_request_data
         exception_presenter = ExceptionPresenter.new(ex, env)
         log :info, "Exception: #{exception_presenter.to_json[0..512]}..."
+        tags = configuration.tags_middleware.call(
+          exception_presenter.context.merge(exception_presenter.dimensions)
+        )
 
         client.write_point \
           configuration.series_name_for_exceptions,
           values:    exception_presenter.values.merge(ts: timestamp),
-          tags:      exception_presenter.context.merge(exception_presenter.dimensions),
+          tags:      tags,
           timestamp: timestamp
       rescue StandardError => ex
         log :info, "[InfluxDB::Rails] Something went terribly wrong." \
@@ -81,56 +88,11 @@ module InfluxDB
       end
       alias transmit report_exception
 
-      def handle_action_controller_metrics(_name, start, finish, _id, payload)
-        tags = {
-          method:      "#{payload[:controller]}##{payload[:action]}",
-          status:      payload[:status],
-          format:      payload[:format],
-          http_method: payload[:method],
-          path:        payload[:path],
-          server:      Socket.gethostname,
-          app_name:    configuration.application_name,
-        }.reject { |_, value| value.nil? }
-
-        ts = convert_timestamp(finish.utc)
-
-        begin
-          {
-            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,
-          }.each do |series_name, value|
-            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}"
-        end
-      end
-
       # rubocop:enable Metrics/MethodLength
       # rubocop:enable Metrics/AbcSize
 
-      TIMESTAMP_CONVERSIONS = {
-        "ns" => 1e9.to_r,
-        nil  => 1e9.to_r,
-        "u"  => 1e6.to_r,
-        "ms" => 1e3.to_r,
-        "s"  => 1.to_r,
-        "m"  => 1.to_r / 60,
-        "h"  => 1.to_r / 60 / 60,
-      }.freeze
-      private_constant :TIMESTAMP_CONVERSIONS
-
-      def convert_timestamp(time)
-        conv = TIMESTAMP_CONVERSIONS.fetch(configuration.time_precision) do
-          raise "Invalid time precision: #{configuration.time_precision}"
-        end
-
-        (time.to_r * conv).to_i
-      end
-
       def current_timestamp
-        convert_timestamp(Time.now.utc)
+        InfluxDB.now(configuration.time_precision)
       end
 
       def ignorable_exception?(ex)

data/spec/integration/metrics_spec.rb

@@ -1,21 +1,28 @@
 require File.expand_path(File.dirname(__FILE__) + "/integration_helper")
 
-RSpec.describe "collecting metrics through ActiveSupport::Notifications", type: :request do
+RSpec.describe WidgetsController, type: :controller do
+  render_views
+
   before do
-    InfluxDB::Rails.configure do |config|
-      config.ignored_environments = %w[development]
-    end
+    allow_any_instance_of(InfluxDB::Rails::Configuration).to receive(:ignored_environments).and_return(%w[development])
   end
 
   describe "in a normal request" do
-    it "should attempt to handle ActionController metrics" do
-      expect(InfluxDB::Rails).to receive(:handle_action_controller_metrics).once
-      get "/widgets"
+    it "should result in attempts to write metrics via the client" do
+      expect(InfluxDB::Rails.client).to receive(:write_point).exactly(6).times
+      get :index
     end
 
-    it "should result in attempts to write metrics via the client" do
-      expect(InfluxDB::Rails.client).to receive(:write_point).exactly(3).times
-      get "/widgets"
+    context "with sql reports enabled" do
+      before do
+        allow_any_instance_of(InfluxDB::Rails::Middleware::SqlSubscriber).to receive(:series_name).and_return("rails.sql")
+        get :index # to not count ActiveRecord initialization
+      end
+
+      it "should result in attempts to write metrics via the client" do
+        expect(InfluxDB::Rails.client).to receive(:write_point).exactly(7).times
+        get :index
+      end
     end
   end
 end

data/spec/support/rails4/app.rb

@@ -1,11 +1,13 @@
 require "action_controller/railtie"
+require "active_record"
 
 app = Class.new(Rails::Application)
+app.config.secret_key_base = "1234567890abcdef1234567890abcdef"
 app.config.secret_token = "1234567890abcdef1234567890abcdef"
 app.config.session_store :cookie_store, key: "_myapp_session"
 app.config.active_support.deprecation = :log
 app.config.eager_load = false
-app.config.root = File.dirname(__FILE__)
+app.config.root = __dir__
 Rails.backtrace_cleaner.remove_silencers!
 app.initialize!
 
@@ -16,10 +18,22 @@ end
 InfluxDB::Rails.configure do |config|
 end
 
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+ActiveRecord::Schema.define do
+  create_table :widgets, force: true do |t|
+    t.string :title
+
+    t.timestamps
+  end
+end
+
+class Widget < ActiveRecord::Base; end
 class ApplicationController < ActionController::Base; end
 class WidgetsController < ApplicationController
+  prepend_view_path File.join(__dir__, "..", "views")
+
   def index
-    render nothing: true
+    Widget.create!(title: "test")
   end
 
   def new

data/spec/support/rails5/app.rb

@@ -1,4 +1,5 @@
 require "action_controller/railtie"
+require "active_record"
 
 app = Class.new(Rails::Application)
 app.config.secret_key_base = "1234567890abcdef1234567890abcdef"
@@ -6,7 +7,7 @@ app.config.secret_token = "1234567890abcdef1234567890abcdef"
 app.config.session_store :cookie_store, key: "_myapp_session"
 app.config.active_support.deprecation = :log
 app.config.eager_load = false
-app.config.root = File.dirname(__FILE__)
+app.config.root = __dir__
 Rails.backtrace_cleaner.remove_silencers!
 app.initialize!
 
@@ -17,10 +18,22 @@ end
 InfluxDB::Rails.configure do |config|
 end
 
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+ActiveRecord::Schema.define do
+  create_table :widgets, force: true do |t|
+    t.string :title
+
+    t.timestamps
+  end
+end
+
+class Widget < ActiveRecord::Base; end
 class ApplicationController < ActionController::Base; end
 class WidgetsController < ApplicationController
+  prepend_view_path File.join(__dir__, "..", "views")
+
   def index
-    head 200
+    Widget.create!(title: "test")
   end
 
   def new

data/spec/support/views/widgets/_item.html.erb

@@ -0,0 +1 @@
+<div>item</div

data/spec/support/views/widgets/index.html.erb

@@ -0,0 +1,5 @@
+<h1>Index page</h1>
+<div>
+  <%= render partial: 'item' %>
+  <%= render partial: 'item', collection: [1,2,3] %>
+</div>

data/spec/unit/configuration_spec.rb

@@ -105,4 +105,21 @@ RSpec.describe InfluxDB::Rails::Configuration do
       expect(InfluxDB::Rails.configuration.rails_app_name).to eq("my-app")
     end
   end
+
+  describe "#tags_middleware" do
+    let(:middleware) { InfluxDB::Rails.configuration.tags_middleware }
+    let(:tags_example) { { a: 1, b: 2 } }
+
+    it "by default returns unmodified tags" do
+      expect(middleware.call(tags_example)).to eq tags_example
+    end
+
+    it "can be updated" do
+      InfluxDB::Rails.configure do |config|
+        config.tags_middleware = ->(tags) { tags.merge(c: 3) }
+      end
+
+      expect(middleware.call(tags_example)).to eq(tags_example.merge(c: 3))
+    end
+  end
 end

data/spec/unit/influxdb_rails_spec.rb

@@ -9,101 +9,15 @@ RSpec.describe InfluxDB::Rails do
     end
   end
 
-  describe ".handle_action_controller_metrics" do
-    let(:start)   { Time.at(1_517_567_368) }
-    let(:finish)  { Time.at(1_517_567_370) }
-    let(:payload) { { view_runtime: 2, db_runtime: 2, controller: "MyController", action: "show", method: "GET", format: "*/*", path: "/posts", status: 200 } }
-    let(:data)    do
-      {
-        values:    {
-          value: 2
-        },
-        tags:      {
-          method:      "MyController#show",
-          status:      200,
-          format:      "*/*",
-          http_method: "GET",
-          path:        "/posts",
-          server:      Socket.gethostname,
-          app_name:    "my-rails-app",
-        },
-        timestamp: 1_517_567_370_000
-      }
-    end
-
-    context "application_name is set" do
-      it "sends metrics with taggings and timestamps" do
-        expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with(
-          "rails.controller", data.merge(values: { value: 2000 })
-        )
-        expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with("rails.view", data)
-        expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with("rails.db", data)
-
-        described_class.handle_action_controller_metrics("unused", start, finish, "unused", payload)
-      end
-    end
-
-    context "application_name is nil" do
-      before do
-        InfluxDB::Rails.configure do |config|
-          config.application_name = nil
-        end
-      end
-
-      it "does not add the app_name tag to metrics" do
-        tags = {
-          method:      "MyController#show",
-          status:      200,
-          format:      "*/*",
-          http_method: "GET",
-          path:        "/posts",
-          server:      Socket.gethostname,
-        }
-
-        expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with(
-          "rails.controller", data.merge(values: { value: 2000 }, tags: tags)
-        )
-        expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with("rails.view", data.merge(tags: tags))
-        expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with("rails.db", data.merge(tags: tags))
-
-        described_class.handle_action_controller_metrics("unused", start, finish, "unused", payload)
-      end
-    end
-  end
-
-  describe ".convert_timestamp" do
-    let(:sometime) { Time.parse("2017-12-11 16:20:29.111222333 UTC") }
-    let(:configuration) { double("Configuration") }
-    before { allow(InfluxDB::Rails).to receive(:configuration).and_return configuration }
-
-    {
-      "ns" => 1_513_009_229_111_222_333,
-      nil  => 1_513_009_229_111_222_333,
-      "u"  => 1_513_009_229_111_222,
-      "ms" => 1_513_009_229_111,
-      "s"  => 1_513_009_229,
-      "m"  => 25_216_820,
-      "h"  => 420_280,
-    }.each do |precision, converted_value|
-      it "should return the timestamp in nanoseconds when precision is #{precision.inspect}" do
-        allow(configuration).to receive(:time_precision).and_return(precision)
-        expect(InfluxDB::Rails.convert_timestamp(sometime)).to eq(converted_value)
-      end
-    end
-
-    it "should raise an excpetion when precision is unrecognized" do
-      allow(configuration).to receive(:time_precision).and_return("whatever")
-      expect { InfluxDB::Rails.convert_timestamp(sometime) }
-        .to raise_exception(/invalid time precision.*whatever/i)
-    end
-  end
-
   describe ".current_timestamp" do
+    let(:timestamp) { 1_513_009_229_111 }
+
     it "should return the current timestamp in the configured precision" do
-      now = Time.parse("2017-12-11 16:20:29.111222333 UTC")
-      allow(Time).to receive(:now).and_return(now)
-      InfluxDB::Rails.configure { |config| config.time_precision = "ms" }
-      expect(InfluxDB::Rails.current_timestamp).to eq(1_513_009_229_111)
+      expect(Process).to receive(:clock_gettime)
+        .with(Process::CLOCK_REALTIME, :millisecond)
+        .and_return(timestamp)
+
+      expect(InfluxDB::Rails.current_timestamp).to eq(timestamp)
     end
   end
 

data/spec/unit/middleware/render_subscriber_spec.rb

@@ -0,0 +1,90 @@
+require "spec_helper"
+
+RSpec.describe InfluxDB::Rails::Middleware::RenderSubscriber do
+  let(:config) { InfluxDB::Rails::Configuration.new }
+  let(:logger) { double(:logger) }
+
+  before do
+    allow(config).to receive(:application_name).and_return("my-rails-app")
+    allow(config).to receive(:ignored_environments).and_return([])
+    allow(config).to receive(:time_precision).and_return("ms")
+  end
+
+  describe ".call" do
+    let(:start_time)   { Time.at(1_517_567_368) }
+    let(:finish_time)  { Time.at(1_517_567_370) }
+    let(:series_name) { "series_name" }
+    let(:payload) { { identifier: "index.html", count: 43, cache_hits: 42 } }
+    let(:result) do
+      {
+        values:    {
+          value: 2000
+        },
+        tags:      {
+          filename:   "index.html",
+          location:   "Foo#bar",
+          count:      43,
+          cache_hits: 42
+        },
+        timestamp: 1_517_567_370_000
+      }
+    end
+
+    subject { described_class.new(config, series_name) }
+
+    before do
+      Thread.current[:_influxdb_rails_controller] = "Foo"
+      Thread.current[:_influxdb_rails_action]     = "bar"
+    end
+
+    after do
+      Thread.current[:_influxdb_rails_action]     = nil
+      Thread.current[:_influxdb_rails_controller] = nil
+    end
+
+    context "successfully" do
+      it "writes to InfluxDB" do
+        expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with(
+          series_name, result
+        )
+        subject.call("name", start_time, finish_time, "id", payload)
+      end
+
+      context "with empty tags" do
+        before do
+          payload[:count] = nil
+          result[:tags].delete(:count)
+        end
+
+        it "does not write empty tags" do
+          expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with(
+            series_name, result
+          )
+          subject.call("name", start_time, finish_time, "id", payload)
+        end
+      end
+
+      context "disabled" do
+        subject { described_class.new(config, nil) }
+
+        it "does not write a data point" do
+          expect_any_instance_of(InfluxDB::Client).not_to receive(:write_point)
+          subject.call("name", start_time, finish_time, "id", payload)
+        end
+      end
+    end
+
+    context "unsuccessfully" do
+      before do
+        allow(config).to receive(:logger).and_return(logger)
+        InfluxDB::Rails.configuration = config
+      end
+
+      it "does log exceptions" do
+        allow_any_instance_of(InfluxDB::Client).to receive(:write_point).and_raise("boom")
+        expect(logger).to receive(:error).with(/boom/)
+        subject.call("name", start_time, finish_time, "id", payload)
+      end
+    end
+  end
+end

data/spec/unit/middleware/request_subscriber_spec.rb

@@ -0,0 +1,106 @@
+require "spec_helper"
+
+RSpec.describe InfluxDB::Rails::Middleware::RequestSubscriber do
+  let(:config) { InfluxDB::Rails::Configuration.new }
+
+  before do
+    allow(config).to receive(:time_precision).and_return("ms")
+  end
+
+  subject { described_class.new(config) }
+
+  describe "#call" do
+    let(:start)   { Time.at(1_517_567_368) }
+    let(:finish)  { Time.at(1_517_567_370) }
+    let(:payload) { { view_runtime: 2, db_runtime: 2, controller: "MyController", action: "show", method: "GET", format: "*/*", status: 200 } }
+    let(:data)    do
+      {
+        values:    {
+          value: 2
+        },
+        tags:      {
+          method:      "MyController#show",
+          status:      200,
+          format:      "*/*",
+          http_method: "GET",
+          server:      Socket.gethostname,
+          app_name:    "my-rails-app",
+        },
+        timestamp: 1_517_567_370_000
+      }
+    end
+
+    context "application_name is set" do
+      before do
+        allow(config).to receive(:application_name).and_return("my-rails-app")
+      end
+
+      it "sends metrics with taggings and timestamps" do
+        expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with(
+          "rails.controller", data.merge(values: { value: 2000 })
+        )
+        expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with("rails.view", data)
+        expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with("rails.db", data)
+
+        subject.call("unused", start, finish, "unused", payload)
+      end
+
+      context "when tags_middleware is overwritten" do
+        before do
+          allow(config).to receive(:tags_middleware).and_return(tags_middleware)
+        end
+
+        let(:tags_middleware) { ->(tags) { tags.merge(static: "value") } }
+
+        it "processes tags throught the middleware" do
+          tags = data[:tags].merge(static: "value")
+
+          expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with("rails.controller", include(tags: tags))
+          expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with("rails.view", include(tags: tags))
+          expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with("rails.db", include(tags: tags))
+
+          subject.call("unused", start, finish, "unused", payload)
+        end
+      end
+    end
+
+    context "application_name is nil" do
+      before do
+        allow(config).to receive(:application_name).and_return(nil)
+      end
+
+      it "does not add the app_name tag to metrics" do
+        tags = {
+          method:      "MyController#show",
+          status:      200,
+          format:      "*/*",
+          http_method: "GET",
+          server:      Socket.gethostname,
+        }
+
+        expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with(
+          "rails.controller", data.merge(values: { value: 2000 }, tags: tags)
+        )
+        expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with("rails.view", data.merge(tags: tags))
+        expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with("rails.db", data.merge(tags: tags))
+
+        subject.call("unused", start, finish, "unused", payload)
+      end
+    end
+
+    context "not successfull" do
+      let(:logger) { double(:logger) }
+
+      before do
+        allow(config).to receive(:logger).and_return(logger)
+        InfluxDB::Rails.configuration = config
+      end
+
+      it "does log an error" do
+        allow_any_instance_of(InfluxDB::Client).to receive(:write_point).and_raise("boom")
+        expect(logger).to receive(:error).with(/boom/)
+        subject.call("name", start, finish, "id", payload)
+      end
+    end
+  end
+end

data/spec/unit/middleware/sql_subscriber_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper"
+
+RSpec.describe InfluxDB::Rails::Middleware::SqlSubscriber do
+  let(:config) { InfluxDB::Rails::Configuration.new }
+  let(:logger) { double(:logger) }
+
+  before do
+    allow(config).to receive(:application_name).and_return("my-rails-app")
+    allow(config).to receive(:ignored_environments).and_return([])
+    allow(config).to receive(:time_precision).and_return("ms")
+  end
+
+  describe ".call" do
+    let(:start_time)   { Time.at(1_517_567_368) }
+    let(:finish_time)  { Time.at(1_517_567_370) }
+    let(:series_name) { "series_name" }
+    let(:payload) { { sql: "SELECT * FROM POSTS WHERE id = 1", name: "Post Load", binds: %w[1 2 3] } }
+    let(:result) do
+      {
+        values:    {
+          value: 2000,
+          sql:   "SELECT * FROM POSTS WHERE id = xxx"
+        },
+        tags:      {
+          location:   "Foo#bar",
+          operation:  "SELECT",
+          class_name: "Post",
+          name:       "Post Load",
+        },
+        timestamp: 1_517_567_370_000
+      }
+    end
+
+    subject { described_class.new(config, series_name) }
+
+    before do
+      Thread.current[:_influxdb_rails_controller] = "Foo"
+      Thread.current[:_influxdb_rails_action]     = "bar"
+    end
+
+    after do
+      Thread.current[:_influxdb_rails_action]     = nil
+      Thread.current[:_influxdb_rails_controller] = nil
+    end
+
+    context "successfully" do
+      it "writes to InfluxDB" do
+        expect_any_instance_of(InfluxDB::Client).to receive(:write_point).with(
+          series_name, result
+        )
+        subject.call("name", start_time, finish_time, "id", payload)
+      end
+
+      context "with not relevant queries" do
+        before do
+          payload[:sql] = "SHOW FULL FIELDS FROM `users`"
+        end
+
+        it "does not write to InfluxDB" do
+          expect_any_instance_of(InfluxDB::Client).not_to receive(:write_point)
+          subject.call("name", start_time, finish_time, "id", payload)
+        end
+      end
+    end
+
+    context "unsuccessfully" do
+      before do
+        allow(config).to receive(:logger).and_return(logger)
+        InfluxDB::Rails.configuration = config
+      end
+
+      it "does log exceptions" do
+        allow_any_instance_of(InfluxDB::Client).to receive(:write_point).and_raise("boom")
+        expect(logger).to receive(:error).with(/boom/)
+        subject.call("name", start_time, finish_time, "id", payload)
+      end
+    end
+  end
+end

data/spec/unit/sql/normalizer_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+RSpec.describe InfluxDB::Rails::Sql::Normalizer do
+  describe "#perform" do
+    it { expect(described_class.new("SELECT * FROM posts WHERE id = 1").perform).to eq("SELECT * FROM posts WHERE id = xxx") }
+    it { expect(described_class.new("SELECT * FROM posts WHERE id = 1".freeze).perform).to eq("SELECT * FROM posts WHERE id = xxx") }
+    it { expect(described_class.new("SELECT * FROM posts LIMIT 10").perform).to eq("SELECT * FROM posts LIMIT xxx") }
+    it { expect(described_class.new("SELECT * FROM posts OFFSET 10").perform).to eq("SELECT * FROM posts OFFSET xxx") }
+    it { expect(described_class.new("SELECT * FROM posts WHERE name LIKE '%foobar%'").perform).to eq("SELECT * FROM posts WHERE name LIKE xxx") }
+    it { expect(described_class.new("SELECT * FROM posts WHERE id IN (1,2,3)").perform).to eq("SELECT * FROM posts WHERE id IN (xxx)") }
+    it { expect(described_class.new("SELECT * FROM products WHERE price BETWEEN 10 AND 20").perform).to eq("SELECT * FROM products WHERE price BETWEEN xxx AND xxx") }
+    it { expect(described_class.new("INSERT INTO products (title, price) VALUES ('Computer', 100)").perform).to eq("INSERT INTO products (title, price) VALUES (xxx)") }
+    it { expect(described_class.new("   SELECT * FROM   POSTS    ").perform).to eq("SELECT * FROM POSTS") }
+  end
+end

data/spec/unit/sql/query_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+RSpec.describe InfluxDB::Rails::Sql::Query do
+  let(:payload) do
+    {
+      sql:  "select * from users where user_id = 42;",
+      name: "User Load",
+    }
+  end
+  subject { described_class.new(payload) }
+
+  describe "#class_name" do
+    it { expect(subject.class_name).to eq("User") }
+  end
+
+  describe "#operation" do
+    it { expect(subject.operation).to eq("SELECT") }
+  end
+
+  describe "#track?" do
+    it { expect(described_class.new(sql: "INSERT").track?).to be true }
+    it { expect(described_class.new(sql: "UPDATE").track?).to be true }
+    it { expect(described_class.new(sql: "SELECT").track?).to be true }
+    it { expect(described_class.new(sql: "DELETE").track?).to be true }
+    it { expect(described_class.new(sql: "SCHEMA").track?).to be false }
+    it { expect(described_class.new(sql: "BEGIN").track?).to be false }
+  end
+end