influx_reporter 1.0.0

data/lib/influx_reporter/injections/json.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  module Injections
+    module JSON
+      class Injector
+        def install
+          ::JSON.class_eval do
+            include TraceHelpers
+
+            trace_class_method :parse, 'JSON#parse', 'json.parse'
+            trace_class_method :parse!, 'JSON#parse!', 'json.parse'
+            trace_class_method :generate, 'JSON#generate', 'json.generate'
+          end
+        end
+      end
+    end
+
+    register 'JSON', 'json', JSON::Injector.new
+  end
+end

data/lib/influx_reporter/injections/net_http.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  module Injections
+    module NetHTTP
+      class Injector
+        def install
+          Net::HTTP.class_eval do
+            alias_method :request_without_opb, :request
+
+            def request(req, body = nil, &block)
+              unless InfluxReporter.started?
+                return request_without_opb req, body, &block
+              end
+
+              host, port = req['host']&.split(':')
+              method = req.method
+              path = req.path
+              scheme = use_ssl? ? 'https' : 'http'
+
+              # inside a session
+              host ||= address
+              port ||= use_ssl? ? 443 : 80
+
+              extra = {
+                  tags: {
+                      scheme: scheme,
+                      port: port,
+                      method: method
+                  },
+                  values: {
+                      path: path
+                  }
+              }
+
+              signature = host
+              kind = 'ext.net_http'
+
+              InfluxReporter.trace signature, kind, extra do
+                request_without_opb(req, body, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register 'Net::HTTP', 'net/http', NetHTTP::Injector.new
+  end
+end

data/lib/influx_reporter/injections/redis.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  module Injections
+    module Redis
+      class Injector
+        def install
+          ::Redis::Client.class_eval do
+            alias_method :call_without_influx_reporter, :call
+
+            def call(command, &block)
+              signature = command[0]
+
+              InfluxReporter.trace signature.to_s, 'cache.redis' do
+                call_without_influx_reporter(command, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register 'Redis', 'redis', Redis::Injector.new
+  end
+end

data/lib/influx_reporter/injections/sequel.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  module Injections
+    module Sequel
+      class Injector
+        KIND = 'db.sequel.sql'
+
+        def self.sql_parser
+          @sql_parser ||= SqlSummarizer.new(nil)
+        end
+
+        def install
+          require 'sequel/database/logging'
+
+          log_method = ::Sequel::Database.method_defined?(:log_connection_yield) ?
+            'log_connection_yield' : 'log_yield'
+
+          ::Sequel::Database.class_eval <<-end_eval
+            alias #{log_method}_without_opb #{log_method}
+
+            def #{log_method} sql, *args, &block
+              #{log_method}_without_opb(sql, *args) do
+                sig = InfluxReporter::Injections::Sequel::Injector.sql_parser.signature_for(sql)
+                InfluxReporter.trace(sig, KIND, sql: sql) do
+                  block.call
+                end
+              end
+            end
+          end_eval
+        end
+      end
+    end
+
+    register 'Sequel', 'sequel', Sequel::Injector.new
+  end
+end

data/lib/influx_reporter/injections/sinatra.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  module Injections
+    module Sinatra
+      class Injector
+        def install
+          ::Sinatra::Base.class_eval do
+            alias_method :dispatch_without_opb!, :dispatch!
+            alias_method :compile_template_with_opb, :compile_template
+
+            def dispatch!(*args, &block)
+              dispatch_without_opb!(*args, &block).tap do
+                transaction = InfluxReporter.transaction(nil)
+                if (route = env['sinatra.route']) && transaction
+                  transaction.endpoint = route
+                end
+              end
+            end
+
+            def compile_template(engine, data, opts, *args, &block)
+              opts[:__influx_reporter_template_sig] = case data
+                                                        when Symbol
+                                                          data.to_s
+                                                        else
+                                                          "Inline #{engine}"
+                                                      end
+
+              compile_template_with_opb(engine, data, opts, *args, &block)
+            end
+          end
+        end
+      end
+    end
+
+    module Tilt
+      class Injector
+        KIND = 'template.view'
+
+        def install
+          ::Tilt::Template.class_eval do
+            alias_method :render_without_opb, :render
+
+            def render(*args, &block)
+              sig = options[:__influx_reporter_template_sig] || 'Unknown template'
+
+              InfluxReporter.trace sig, KIND do
+                render_without_opb(*args, &block)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    register 'Sinatra::Base', 'sinatra/base', Sinatra::Injector.new
+    register 'Tilt::Template', 'tilt/template', Tilt::Injector.new
+  end
+end

data/lib/influx_reporter/integration/delayed_job.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+begin
+  require 'active_support'
+  require 'delayed_job'
+rescue LoadError
+end
+
+if defined?(Delayed)
+  module Delayed
+    module Plugins
+      class InfluxReporter < Delayed::Plugin
+        callbacks do |lifecycle|
+          lifecycle.around(:invoke_job) do |job, *args, &block|
+            begin
+              block.call(job, *args)
+            rescue ::InfluxReporter::Error
+              raise # don't report InfluxReporter errors
+            rescue Exception => exception
+              ::InfluxReporter.report exception
+              raise
+            end
+          end
+        end
+      end
+    end
+  end
+
+  Delayed::Worker.plugins << Delayed::Plugins::InfluxReporter
+end

data/lib/influx_reporter/integration/rails/inject_exceptions_catcher.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module InfluxReporter
+  module Integration
+    module Rails
+      module InjectExceptionsCatcher
+        def self.included(cls)
+          cls.send(:alias_method, :render_exception_without_influx_reporter, :render_exception)
+          cls.send(:alias_method, :render_exception, :render_exception_with_influx_reporter)
+        end
+
+        def render_exception_with_influx_reporter(env, exception)
+          begin
+            InfluxReporter.report(exception, tags: { rack_env: env }) if InfluxReporter.started?
+          rescue
+            ::Rails.logger.error "** [InfluxReporter] Error capturing or sending exception #{$ERROR_INFO}"
+            ::Rails.logger.debug $ERROR_INFO.backtrace.join("\n")
+          end
+
+          render_exception_without_influx_reporter(env, exception)
+        end
+      end
+    end
+  end
+end

data/lib/influx_reporter/integration/railtie.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'influx_reporter'
+require 'rails'
+
+module InfluxReporter
+  class Railtie < Rails::Railtie
+    config.influx_reporter = ActiveSupport::OrderedOptions.new
+    # bootstrap options with the defaults
+    Configuration::DEFAULTS.each { |k, v| config.influx_reporter[k] = v }
+
+    initializer 'influx_reporter.configure' do |app|
+      config = Configuration.new app.config.influx_reporter do |conf|
+        conf.logger = Rails.logger
+        conf.view_paths = app.config.paths['app/views'].existent
+        conf.tags[:environment] = Rails.env
+      end
+
+      if config.enabled_environments.include?(Rails.env)
+        if InfluxReporter.start!(config)
+          app.config.middleware.insert 0, Middleware
+          Rails.logger.info '** [InfluxReporter] Client running'
+        else
+          # :nocov:
+          Rails.logger.info '** [InfluxReporter] Failed to start'
+          # :nocov:
+        end
+      else
+        # :nocov:
+        Rails.logger.info "** [InfluxReporter] Disabled in #{Rails.env} environment"
+        # :nocov:
+      end
+    end
+
+    config.after_initialize do
+      # :nocov:
+      require 'influx_reporter/integration/rails/inject_exceptions_catcher'
+      if defined?(ActionDispatch::DebugExceptions)
+        ActionDispatch::DebugExceptions.send(
+            :include, InfluxReporter::Integration::Rails::InjectExceptionsCatcher
+        )
+      elsif defined?(::ActionDispatch::ShowExceptions)
+        ::ActionDispatch::ShowExceptions.send(
+            :include, InfluxReporter::Integration::Rails::InjectExceptionsCatcher
+        )
+      end
+      # :nocov:
+    end
+
+    rake_tasks do
+      # :nocov:
+      require 'influx_reporter/tasks'
+      # :nocov:
+    end
+  end
+end

data/lib/influx_reporter/integration/resque.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+begin
+  require 'resque'
+rescue LoadError
+end
+
+if defined? Resque
+  module InfluxReporter
+    module Integration
+      class Resque < Resque::Failure::Base
+        def save
+          InfluxReporter.report exception
+        end
+      end
+    end
+  end
+end

data/lib/influx_reporter/integration/sidekiq.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+begin
+  require 'sidekiq'
+rescue LoadError
+end
+
+if defined? Sidekiq
+  module InfluxReporter
+    module Integration
+      class SidekiqException
+
+        def call(worker, item, queue)
+          InfluxReporter.set_context tags: { sidekiq_queue: queue }
+          yield
+        rescue Exception => exception
+          if [Interrupt, SystemExit, SignalException].include? exception.class
+            raise exception
+          end
+
+          InfluxReporter.report exception
+
+          raise
+        end
+      end
+
+      class Sidekiq
+        KIND = 'worker.sidekiq'.freeze
+        PART_KIND = 'worker.sidekiq.part'
+        PERFORM_TRACE = 'perform'.freeze
+        PERFORM_KIND = 'app.worker.perform'.freeze
+
+
+        def call(worker, item, queue)
+          performance_trace(worker, item, queue) do
+            yield
+          end
+        end
+
+        private
+
+        def performance_trace(worker, item, queue)
+          return yield unless worker.class.performance_trace?
+
+          transaction = InfluxReporter.transaction get_worker_name(worker, item), KIND
+          transaction.extra_tags do |extra|
+            extra[:sidekiq_queue] = queue
+          end
+          response_code = 500
+          trace = transaction&.trace PERFORM_TRACE, PERFORM_KIND
+
+          begin
+            yield
+            response_code = 200
+          ensure
+            InfluxReporter::Client.inst.current_transaction = nil
+            trace&.done
+            transaction&.submit(response_code)
+          end
+          InfluxReporter.flush_transactions_if_needed
+        end
+
+        def get_worker_name(worker, item)
+          item['wrapped'.freeze] || worker.class.to_s
+        end
+      end
+    end
+  end
+
+  module Sidekiq::Worker
+    def with_performance_trace
+      unless InfluxReporter::Client.inst
+        return yield
+      end
+      caller = caller_locations(1,1)[0].label
+      parent_transaction = InfluxReporter::Client.inst.current_transaction
+      InfluxReporter::Client.inst.current_transaction = nil
+      transaction = InfluxReporter::Client.inst.transaction "#{self.class}##{caller}", InfluxReporter::Integration::Sidekiq::PART_KIND
+      InfluxReporter::Client.inst.current_transaction = transaction
+      begin
+        result = yield
+      ensure
+        transaction.submit if transaction
+        InfluxReporter::Client.inst.current_transaction = parent_transaction
+      end
+      InfluxReporter.flush_transactions_if_needed
+      result
+    end
+
+    def without_performance_trace
+      unless InfluxReporter::Client.inst
+        return yield
+      end
+      parent_transaction = InfluxReporter::Client.inst&.current_transaction
+      InfluxReporter::Client.inst.current_transaction = nil
+      begin
+        result = yield
+      ensure
+        InfluxReporter::Client.inst.current_transaction = parent_transaction
+      end
+      result
+    end
+
+    module ClassMethods
+      def skip_performance_trace!
+        @skip_performance_trace = true
+      end
+
+      def performance_trace?
+        !@skip_performance_trace
+      end
+    end
+  end
+
+  Sidekiq.configure_server do |config|
+    if Sidekiq::VERSION.to_i < 3
+      config.server_middleware do |chain|
+        chain.add InfluxReporter::Integration::SidekiqException
+        chain.add InfluxReporter::Integration::Sidekiq
+      end
+    else
+      config.error_handlers << lambda do |exception, *|
+        InfluxReporter.report exception
+      end
+      config.server_middleware do |chain|
+        chain.add InfluxReporter::Integration::Sidekiq
+      end
+    end
+  end
+end