influx_reporter 1.0.0

data/influx_reporter.gemspec

@@ -0,0 +1,26 @@
+
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'influx_reporter/version'
+
+Gem::Specification.new do |gem|
+  gem.name             = 'influx_reporter'
+  gem.version          = InfluxReporter::VERSION
+  gem.authors          = ['Kacper Kawecki']
+  gem.email            = 'kacper@geniebelt.com'
+  gem.summary          = 'Metrics collector for rails and InfluxDB based on Opbeat Ruby client library'
+  gem.homepage         = 'https://github.com/GenieBelt/influx-reporter'
+  gem.license          = 'BSD-3-Clause'
+
+  gem.files            = `git ls-files -z`.split("\x0")
+  gem.require_paths    = ['lib']
+  gem.extra_rdoc_files = %w[README.md LICENSE]
+
+  gem.required_ruby_version = '>= 2.3.0'
+  gem.add_dependency('activesupport', '>= 3.0.0')
+  gem.add_dependency('influxdb', '>= 0.5.3')
+
+  gem.add_development_dependency('rubocop')
+end

data/lib/influx_reporter.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'influx_reporter/version'
+require 'influx_reporter/configuration'
+
+require 'influx_reporter/logging'
+require 'influx_reporter/client'
+require 'influx_reporter/error'
+require 'influx_reporter/trace_helpers'
+
+require 'influx_reporter/middleware'
+
+require 'influx_reporter/integration/railtie' if defined?(Rails)
+
+require 'influx_reporter/injections'
+require 'influx_reporter/injections/net_http'
+require 'influx_reporter/injections/redis'
+require 'influx_reporter/injections/sinatra'
+require 'influx_reporter/injections/sequel'
+
+require 'influx_reporter/integration/delayed_job'
+require 'influx_reporter/integration/sidekiq'
+require 'influx_reporter/integration/resque'
+
+module InfluxReporter
+  # Start the InfluxReporter client
+  #
+  # @param conf [Configuration] An Configuration object
+  def self.start!(conf)
+    Client.start! conf
+  end
+
+  # Stop the InfluxReporter client
+  def self.stop!
+    Client.stop!
+  end
+
+  def self.started?
+    !!Client.inst
+  end
+
+  # Start a new transaction or return the currently running
+  #
+  # @param endpoint [String] A description of the transaction, eg `ExamplesController#index`
+  # @param kind [String] The kind of the transaction, eg `app.request.get` or `db.mysql2.query`
+  # @param result [Object] Result of the transaction, eq `200` for a HTTP server
+  # @yield [InfluxReporter::Transaction] Optional block encapsulating transaction
+  # @return [InfluxReporter::Transaction] Unless block given
+  def self.transaction(endpoint, kind = nil, result = nil, &block)
+    unless client
+      return yield if block_given?
+      return nil
+    end
+
+    client.transaction endpoint, kind, result, &block
+  end
+
+  # Starts a new trace under the current Transaction
+  #
+  # @param signature [String] A description of the trace, eq `SELECT FROM "users"`
+  # @param kind [String] The kind of trace, eq `db.mysql2.query`
+  # @param extra [Hash] Extra information about the trace
+  # @yield [Trace] Optional block encapsulating trace
+  # @return [Trace] Unless block given
+  def self.trace(signature, kind = nil, extra = nil, &block)
+    unless client
+      return yield if block_given?
+      return nil
+    end
+
+    client.trace signature, kind, extra, &block
+  end
+
+  def self.flush_transactions
+    client&.flush_transactions
+  end
+
+  def self.flush_transactions_if_needed
+    client&.flush_transactions_if_needed
+  end
+
+  # Sets context for future errors
+  #
+  # @param context [Hash]
+  def self.set_context(context)
+    client&.set_context context
+  end
+
+  # Updates context for errors within the block
+  #
+  # @param context [Hash]
+  # @yield [Trace] Block in which the context is used
+  def self.with_context(context, &block)
+    unless client
+      return yield if block_given?
+      return nil
+    end
+
+    client.with_context context, &block
+  end
+
+  # Send an exception to InfluxReporter
+  #
+  # @param exception [Exception]
+  # @param opts [Hash]
+  # @option opts [Hash] :rack_env A rack env object
+  # @return [Net::HTTPResponse]
+  def self.report(exception, opts = {})
+    unless client
+      return yield if block_given?
+      return nil
+    end
+
+    client.report exception, opts
+  end
+
+  # Send an exception to InfluxReporter
+  #
+  # @param message [String]
+  # @param opts [Hash]
+  # @return [Net::HTTPResponse]
+  def self.report_message(message, opts = {})
+    client&.report_message message, opts
+  end
+
+  # Captures any exceptions raised inside the block
+  #
+  def self.capture(&block)
+    unless client
+      return yield if block_given?
+      return nil
+    end
+
+    client.capture(&block)
+  end
+
+  private
+
+  def self.client
+    Client.inst
+  end
+end

data/lib/influx_reporter/client.rb

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+require 'thread'
+require 'influx_reporter/subscriber'
+require 'influx_reporter/influx_db_client'
+require 'influx_reporter/worker'
+require 'influx_reporter/transaction'
+require 'influx_reporter/trace'
+require 'influx_reporter/error_message'
+require 'influx_reporter/data_builders'
+
+module InfluxReporter
+  # @api private
+  class Client
+    include Logging
+
+    KEY = :__influx_reporter_transaction_key
+    LOCK = Mutex.new
+
+    class TransactionInfo
+      def current
+        Thread.current[KEY]
+      end
+
+      def current=(transaction)
+        Thread.current[KEY] = transaction
+      end
+    end
+
+    # life cycle
+
+    def self.inst
+      @instance
+    end
+
+    def self.start!(config = nil)
+      return @instance if @instance
+
+      LOCK.synchronize do
+        return @instance if @instance
+        @instance = new(config).start!
+      end
+    end
+
+    def self.stop!
+      LOCK.synchronize do
+        return unless @instance
+
+        @instance.stop!
+        @instance = nil
+      end
+    end
+
+    def initialize(config)
+      @config = config
+
+      @influx_client = InfluxDBClient.new config
+      @queue = Queue.new
+
+      @data_builders = Struct.new(:transactions, :error_message).new(
+          DataBuilders::Transactions.new(config),
+          DataBuilders::Error.new(config)
+      )
+
+      unless config.disable_performance
+        @transaction_info = TransactionInfo.new
+        @subscriber = Subscriber.new config, self
+      end
+
+      @pending_transactions = []
+      @last_sent_transactions = Time.now.utc
+    end
+
+    # @!attribute [r] config
+    #   InfluxReporter configuration
+    #   @return [InfluxReporter::Configuration]
+    # @!attribute [r] queue
+    #   Worker data queue
+    #   @return [Thread::Queue]
+    # @!attribute [r] pending_transactions
+    #   Transaction to be submitted
+    #   @return [Thread::Queue]
+    attr_reader :config, :queue, :pending_transactions
+
+    # Start client
+    # @return [InfluxReporter::Client]
+    def start!
+      info 'Starting client'
+
+      @subscriber&.register!
+
+      self
+    end
+
+    def stop!
+      flush_transactions
+      kill_worker
+      unregister! if @subscriber
+    end
+
+    at_exit do
+      stop!
+    end
+
+    # metrics
+
+    def current_transaction
+      @transaction_info.current
+    end
+
+    def current_transaction=(transaction)
+      @transaction_info.current = transaction
+    end
+
+    def transaction(endpoint, kind = nil, result = nil)
+      if config.disable_performance
+        return yield if block_given?
+        return nil
+      end
+
+      if current_transaction
+        transaction = current_transaction
+        yield transaction if block_given?
+        return transaction
+      end
+
+      transaction = Transaction.new self, endpoint, kind, result
+
+      self.current_transaction = transaction
+      return transaction unless block_given?
+
+      begin
+        yield transaction
+      ensure
+        self.current_transaction = nil
+        transaction.done
+      end
+
+      transaction
+    end
+
+    def trace(*args, &block)
+      if config.disable_performance
+        return yield if block_given?
+        return nil
+      end
+
+      unless transaction = current_transaction
+        return yield if block_given?
+        return
+      end
+
+      transaction.trace(*args, &block)
+    end
+
+    def submit_transaction(transaction)
+      ensure_worker_running
+
+      if config.debug_traces
+        unless transaction.endpoint == 'Rack'
+          debug { Util::Inspector.new.transaction transaction, include_parents: true }
+        end
+      end
+
+      @pending_transactions << transaction
+
+      flush_transactions if should_send_transactions?
+    end
+
+    def flush_transactions
+      return if @pending_transactions.empty?
+
+      data = @data_builders.transactions.build(@pending_transactions)
+      enqueue Worker::PostRequest.new('/transactions/', data)
+
+      @last_sent_transactions = Time.now.utc
+      @pending_transactions = []
+
+      true
+    end
+
+    def flush_transactions_if_needed
+      if should_send_transactions?
+        flush_transactions
+      end
+    end
+
+    # errors
+
+    def set_context(context)
+      @context = context
+    end
+
+    def with_context(context)
+      current = @context
+
+      set_context((current || {}).deep_merge(context))
+
+      yield if block_given?
+    ensure
+      set_context(current)
+    end
+
+    def report(exception, opts = {})
+      return if config.disable_errors
+      return unless exception
+
+      ensure_worker_running
+
+      exception.set_backtrace caller unless exception.backtrace
+
+      if error_message = ErrorMessage.from_exception(config, exception, opts)
+        error_message.add_extra(@context) if @context
+        data = @data_builders.error_message.build error_message
+        enqueue Worker::PostRequest.new('/errors/', data)
+      end
+    end
+
+    def report_message(message, opts = {})
+      return if config.disable_errors
+
+      ensure_worker_running
+
+      error_message = ErrorMessage.new(config, message, opts)
+      error_message.add_extra(@context) if @context
+      data = @data_builders.error_message.build error_message
+      enqueue Worker::PostRequest.new('/errors/', data)
+    end
+
+    def capture
+      unless block_given?
+        return Kernel.at_exit do
+          if $ERROR_INFO
+            debug $ERROR_INFO.inspect
+            report $ERROR_INFO
+          end
+        end
+      end
+
+      begin
+        yield
+      rescue Error => e
+        raise # Don't capture InfluxReporter errors
+      rescue Exception => e
+        report e
+        raise
+      end
+    end
+
+    private
+
+    def enqueue(request)
+      @queue << request
+    end
+
+    def start_worker
+      return if worker_running?
+
+      return if config.disable_worker
+
+      info 'Starting worker in thread'
+
+      @worker_thread = Thread.new do
+        begin
+          Worker.new(config, @queue, @influx_client).run
+        rescue => e
+          fatal "Failed booting worker:\n#{e.inspect}"
+          debug e.backtrace.join("\n")
+          raise
+        end
+      end
+    end
+
+    def kill_worker
+      return unless worker_running?
+      @queue << Worker::StopMessage.new
+      unless @worker_thread.join(config.worker_quit_timeout)
+        error 'Failed to wait for worker, not all messages sent'
+      end
+      @worker_thread = nil
+    end
+
+    def ensure_worker_running
+      return if worker_running?
+
+      LOCK.synchronize do
+        return if worker_running?
+        start_worker
+      end
+    end
+
+    def worker_running?
+      @worker_thread&.alive?
+    end
+
+    def unregister!
+      @subscriber.unregister!
+    end
+
+    def should_send_transactions?
+      return true if config.transaction_post_interval.nil?
+
+      Time.now.utc - @last_sent_transactions > config.transaction_post_interval
+    end
+  end
+end