asklytics-influxdb-rails 1.0.0.beta3

data/lib/influxdb/rails/logger.rb

@@ -0,0 +1,16 @@
+module InfluxDB
+  module Rails
+    module Logger # rubocop:disable Style/Documentation
+      PREFIX = "[InfluxDB::Rails] ".freeze
+
+      private
+
+      def log(level, message)
+        c = InfluxDB::Rails.configuration
+        return if level != :error && !c.debug?
+
+        c.logger&.send(level, PREFIX + message)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module InfluxDB
+  module Rails
+    module Middleware
+      module HijackRenderException # rubocop:disable Style/Documentation
+        def render_exception(env, ex)
+          controller = env["action_controller.instance"] || env.controller_instance
+          request_data = controller.try(:influxdb_request_data) || {}
+          unless InfluxDB::Rails.configuration.ignore_user_agent?(request_data[:user_agent])
+            InfluxDB::Rails.report_exception_unless_ignorable(ex, request_data)
+          end
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module InfluxDB
+  module Rails
+    module Middleware
+      module HijackRescueActionEverywhere # rubocop:disable Style/Documentation
+        def self.included(base)
+          base.send(:alias_method_chain, :rescue_action_in_public, :influxdb)
+          base.send(:alias_method_chain, :rescue_action_locally, :influxdb)
+        end
+
+        private
+
+        def rescue_action_in_public_with_influxdb(ex)
+          handle_exception(ex)
+          rescue_action_in_public_without_influxdb(ex)
+        end
+
+        def rescue_action_locally_with_influxdb(ex)
+          handle_exception(ex)
+          rescue_action_locally_without_influxdb(ex)
+        end
+
+        def handle_exception(ex)
+          request_data = influxdb_request_data || {}
+          return if InfluxDB::Rails.configuration.ignore_user_agent?(request_data[:user_agent])
+
+          InfluxDB::Rails.report_exception_unless_ignorable(ex, request_data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require "influxdb/rails/middleware/simple_subscriber"
+
+module InfluxDB
+  module Rails
+    module Middleware
+      class RenderSubscriber < SimpleSubscriber # :nodoc:
+        private
+
+        def values(started, finished, payload)
+          super(started, finished, payload).merge(
+            count:      payload[:count],
+            cache_hits: payload[:cache_hits]
+          ).reject { |_, value| value.nil? }
+        end
+
+        def tags(payload)
+          tags = {
+            location: location,
+            filename: payload[:identifier],
+            app_name:    configuration.application_name,
+            host:      Socket.gethostname
+          }
+          super(tags)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require "influxdb/rails/middleware/subscriber"
+
+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)
+          ts = InfluxDB.convert_timestamp(start.utc, configuration.time_precision)
+          tags = tags(payload)
+          x_request_id = "AL_NONE"
+          al_request_id = "AL_NONE"
+          al_request_guid = "AL_NONE"
+          al_source = "AL_NONE"
+          al_request_client_id = "AL_NONE"
+
+          x_request_id = payload[:headers][:HTTP_X_REQUEST_ID] if(payload[:headers] && payload[:headers][:HTTP_X_REQUEST_ID])
+          al_request_id = payload[:headers][:HTTP_AL_REQUEST_ID] if(payload[:headers] && payload[:headers][:HTTP_AL_REQUEST_ID])
+          #al_request_id = Thread.current["al_request_id"] if(Thread.current["al_request_id"])
+          al_request_guid = payload[:headers][:HTTP_AL_REQUEST_GUID] if(payload[:headers] && payload[:headers][:HTTP_AL_REQUEST_GUID])
+          #al_request_guid = Thread.current["al_request_guid"] if(Thread.current["al_request_guid"])
+          al_source = payload[:headers][:HTTP_AL_SOURCE] if(payload[:headers] && payload[:headers][:HTTP_AL_SOURCE])
+          al_request_client_id = payload[:headers][:HTTP_AL_REQUEST_CLIENT_ID] if(payload[:headers] && payload[:headers][:HTTP_AL_REQUEST_CLIENT_ID])
+
+          al_source = Thread.current["al_source"]
+          al_request_client_id = Thread.current["al_request_client_id"]
+
+          begin
+            series(payload, start, finish).each do |series_name, value|
+              InfluxDB::Rails.client.write_point \
+                series_name,
+                values:    { value: value, x_request_id: x_request_id, al_request_id: al_request_id, al_request_guid: al_request_guid, al_request_source_id: al_source, al_request_client_id: al_request_client_id },
+                tags:      tags,
+                timestamp: ts
+            end
+          rescue StandardError => e
+            log :error, "[InfluxDB::Rails] Unable to write points: #{e.message}"
+          ensure
+            InfluxDB::Rails.current.reset
+          end
+        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]}",
+            status:      payload[:status],
+            format:      payload[:format],
+            http_method: payload[:method],
+            host:      Socket.gethostname,
+            app_name:    configuration.application_name,
+          }
+          super(tags)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require "influxdb/rails/middleware/subscriber"
+
+module InfluxDB
+  module Rails
+    module Middleware
+      # Subscriber acts as base class for different *Subscriber classes,
+      # 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)
+          return unless enabled?
+
+          begin
+            # InfluxDB::Rails.client.write_point series_name,
+            #                                    values:    values(started, finished, payload),
+            #                                    tags:      tags(payload),
+            #                                    timestamp: timestamp(finished.utc)
+            InfluxDB::Rails.client.write_point series_name,
+                                               values:    values(started, finished, payload),
+                                               tags:      tags(payload),
+                                               timestamp: timestamp(started.utc)
+          rescue StandardError => e
+            log :error, "[InfluxDB::Rails] Unable to write points: #{e.message}"
+          end
+        end
+
+        private
+
+        def values(started, finished, _payload)
+
+          x_request_id = "AL_NONE"
+          al_source = "AL_NONE"
+          al_request_id = "AL_NONE"
+          al_request_guid = "AL_NONE"
+          al_request_client_id = "AL_NONE"
+
+          x_request_id = _payload[:headers][:HTTP_X_REQUEST_ID] if(_payload[:headers] && _payload[:headers][:HTTP_X_REQUEST_ID])
+          #al_source = _payload[:headers][:HTTP_AL_SOURCE] if(_payload[:headers] && _payload[:headers][:HTTP_AL_SOURCE])
+          #al_request_id = _payload[:headers][:HTTP_AL_REQUEST_ID] if(_payload[:headers] && _payload[:headers][:HTTP_AL_REQUEST_ID])
+          #al_request_guid = _payload[:headers][:HTTP_AL_REQUEST_GUID] if(_payload[:headers] && _payload[:headers][:HTTP_AL_REQUEST_GUID])
+          #al_request_client_id = _payload[:headers][:HTTP_AL_REQUEST_CLIENT_ID] if(_payload[:headers] && _payload[:headers][:HTTP_AL_REQUEST_CLIENT_ID])
+
+          al_request_id = Thread.current["al_request_id"] if(Thread.current["al_request_id"])
+          al_request_guid = Thread.current["al_request_guid"] if(Thread.current["al_request_guid"])
+          al_source = Thread.current["al_source"]
+          al_request_client_id = Thread.current["al_request_client_id"]
+
+
+
+
+          { value: ((finished - started) * 1000).ceil , x_request_id: x_request_id, al_request_id: al_request_id, al_request_guid: al_request_guid, al_request_source_id: al_source, al_request_client_id: al_request_client_id}
+        end
+
+        def timestamp(finished)
+          InfluxDB.convert_timestamp(finished.utc, configuration.time_precision)
+        end
+
+        def enabled?
+          super && series_name.present?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require "influxdb/rails/middleware/simple_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
+
+        private
+
+        def values(started, finished, payload)
+          super.merge(sql: InfluxDB::Rails::Sql::Normalizer.new(payload[:sql]).perform)
+        end
+
+        def tags(payload)
+          query = InfluxDB::Rails::Sql::Query.new(payload)
+          tags = {
+            location:   location,
+            operation:  query.operation,
+            class_name: query.class_name,
+            name:       query.name,
+            app_name:    configuration.application_name,
+            host:      Socket.gethostname
+          }
+          super(tags)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require "influxdb/rails/logger"
+
+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
+        include InfluxDB::Rails::Logger
+
+        attr_reader :configuration
+
+        def initialize(configuration)
+          @configuration = configuration
+        end
+
+        def call(*)
+          raise NotImplementedError, "must be implemented in subclass"
+        end
+
+        private
+
+        def tags(tags)
+          merged_tags = tags.merge(InfluxDB::Rails.current.tags).reject { |_, value| value.nil? }
+          configuration.tags_middleware.call(merged_tags)
+        end
+
+        def enabled?
+          configuration.instrumentation_enabled? &&
+            !configuration.ignore_current_environment?
+        end
+
+        def location
+          current = InfluxDB::Rails.current
+          [
+            current.controller,
+            current.action,
+          ].reject(&:blank?).join("#")
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/rack.rb

@@ -0,0 +1,39 @@
+require 'securerandom'
+
+module InfluxDB
+  module Rails
+    class Rack # rubocop:disable Style/Documentation
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+         al_request_guid = env["HTTP_AL_REQUEST_GUID"] || SecureRandom.uuid
+         #al_request_id =  SecureRandom.uuid
+         al_request_id =  SecureRandom.uuid
+         al_source = "AL_NONE"
+         al_request_client_id = "AL_NONE"
+
+         Thread.current["al_request_id"] = al_request_id
+         Thread.current["al_request_guid"] = al_request_guid
+         Thread.current["al_source"] = env["HTTP_AL_SOURCE"] || al_source
+         Thread.current["al_request_client_id"] = env["HTTP_AL_REQUEST_CLIENT_ID"] || al_request_client_id
+
+         env["HTTP_AL_REQUEST_ID"] = al_request_id
+         env["HTTP_AL_REQUEST_GUID"] = al_request_guid
+        dup._call(env)
+      end
+
+      def _call(env)
+        begin
+          response = @app.call(env)
+        rescue StandardError => e
+          InfluxDB::Rails.transmit_unless_ignorable(e, env)
+          raise(e)
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/influxdb/rails/railtie.rb

@@ -0,0 +1,52 @@
+require "influxdb"
+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)
+
+        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|
+            current = InfluxDB::Rails.current
+            current.controller = payload[:controller]
+            current.action     = payload[:action]
+          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
+
+          sql = Middleware::SqlSubscriber.new(c, c.series_name_for_sql)
+          ActiveSupport::Notifications.subscribe "sql.active_record", sql
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/sql/normalizer.rb

@@ -0,0 +1,27 @@
+module InfluxDB
+  module Rails
+    module Sql
+      class Normalizer # :nodoc:
+        def initialize(query)
+          @query = query.dup
+        end
+
+        def perform
+          query.squish!
+          query.gsub!(/(\s(=|>|<|>=|<=|<>|!=)\s)('[^']+'|[\$\+\-\w\.]+)/, '\1xxx')
+          query.gsub!(/(\sIN\s)\([^\(\)]+\)/i, '\1(xxx)')
+          regex = /(\sBETWEEN\s)('[^']+'|[\+\-\w\.]+)(\sAND\s)('[^']+'|[\+\-\w\.]+)/i
+          query.gsub!(regex, '\1xxx\3xxx')
+          query.gsub!(/(\sVALUES\s)\(.+\)/i, '\1(xxx)')
+          query.gsub!(/(\s(LIKE|ILIKE|SIMILAR TO|NOT SIMILAR TO)\s)('[^']+')/i, '\1xxx')
+          query.gsub!(/(\s(LIMIT|OFFSET)\s)(\d+)/i, '\1xxx')
+          query
+        end
+
+        private
+
+        attr_reader :query
+      end
+    end
+  end
+end