experimental-influxdb-rails 1.0.0.beta5

data/Rakefile

@@ -0,0 +1,34 @@
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+RuboCop::RakeTask.new
+
+targeted_files = ARGV.drop(1)
+file_pattern = targeted_files.empty? ? "spec/**/*_spec.rb" : targeted_files
+
+require "rspec/core"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = FileList[file_pattern]
+end
+
+RSpec.configure do |config|
+  config.color = true
+  config.formatter = :documentation
+end
+
+task default: %i[spec rubocop]
+
+task "test:all" => :default do
+  Dir.glob("gemfiles/Gemfile.rails-*.x") do |gemfile|
+    if RUBY_VERSION >= "2.6.0" && gemfile == "gemfiles/Gemfile.rails-4.2.x"
+      msg = "ignore #{gemfile} on Ruby #{RUBY_VERSION}"
+      puts RSpec::Core::Formatters::ConsoleCodes.wrap(msg, :yellow)
+      next
+    end
+
+    puts RSpec::Core::Formatters::ConsoleCodes.wrap(gemfile, :cyan)
+    sh({ "BUNDLE_GEMFILE" => gemfile }, "bundle", "install", "--quiet", "--retry=2", "--jobs=2")
+    sh({ "BUNDLE_GEMFILE" => gemfile }, "bundle", "exec", "rspec")
+  end
+end

data/config.ru

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.require :default, :development
+
+Combustion.initialize!
+run Combustion::Application

data/experimental-influxdb-rails.gemspec

@@ -0,0 +1,35 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "influxdb/rails/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = "experimental-influxdb-rails"
+  spec.version     = InfluxDB::Rails::VERSION
+  spec.authors     = ["Dominik Menke", "Todd Persen"]
+  spec.email       = ["dominik.menke@gmail.com", "todd@influxdb.com"]
+  spec.homepage    = "https://influxdata.com"
+  spec.summary     = "InfluxDB bindings for Ruby on Rails."
+  spec.description = "This gem automatically instruments your Ruby on Rails" \
+                     " 4.2/5.x applications using InfluxDB for storage."
+  spec.licenses    = ["MIT"]
+
+  spec.files         = `git ls-files`.split($/) # rubocop:disable Style/SpecialGlobalVars
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features|smoke)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.3.0"
+
+  spec.add_runtime_dependency "influxdb", "~> 0.6", ">= 0.6.4"
+  spec.add_runtime_dependency "railties", ">= 4.2"
+
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "bundler", ">= 1.0.0"
+  spec.add_development_dependency "fakeweb"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rdoc"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-rails", ">= 3.0.0"
+  spec.add_development_dependency "rubocop", "~> 0.61.1"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "tzinfo"
+end

data/gemfiles/Gemfile.rails-4.2.x

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem 'actionpack', '~> 4.2.0'
+gem 'activesupport', '~> 4.2.0'
+gem 'activemodel', '~> 4.2.0'
+
+gemspec :path => '../'

data/gemfiles/Gemfile.rails-5.0.x

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem 'actionpack', '~> 5.0.0'
+gem 'activesupport', '~> 5.0.0'
+gem 'activemodel', '~> 5.0.0'
+
+gemspec :path => '../'

data/gemfiles/Gemfile.rails-5.1.x

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem 'actionpack', '~> 5.1.0'
+gem 'activesupport', '~> 5.1.0'
+gem 'activemodel', '~> 5.1.0'
+
+gemspec :path => '../'

data/gemfiles/Gemfile.rails-5.2.x

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gem 'actionpack', '~> 5.2.0'
+gem 'activesupport', '~> 5.2.0'
+gem 'activemodel', '~> 5.2.0'
+
+gemspec :path => '../'

data/lib/experimental-influxdb-rails.rb

@@ -0,0 +1,123 @@
+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"
+require "influxdb/rails/configuration"
+require "influxdb/rails/backtrace"
+require "influxdb/rails/context"
+require "influxdb/rails/rack"
+
+require "influxdb/rails/railtie" if defined?(Rails::Railtie)
+
+module InfluxDB
+  # InfluxDB::Rails contains the glue code needed to integrate with
+  # InfluxDB and Rails. This is a singleton class.
+  module Rails
+    class << self
+      include InfluxDB::Rails::Logger
+
+      attr_writer :configuration
+      attr_writer :client
+
+      def configure(_silent = false)
+        yield(configuration)
+
+        # if we change configuration, reload the client
+        self.client = nil
+
+        InfluxDB::Logging.logger = configuration.logger unless configuration.logger.nil?
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
+
+      def client
+        @client ||= InfluxDB::Client.new \
+          database:       configuration.influxdb_database,
+          username:       configuration.influxdb_username,
+          password:       configuration.influxdb_password,
+          hosts:          configuration.influxdb_hosts,
+          port:           configuration.influxdb_port,
+          async:          configuration.async,
+          use_ssl:        configuration.use_ssl,
+          retry:          configuration.retry,
+          open_timeout:   configuration.open_timeout,
+          read_timeout:   configuration.read_timeout,
+          max_delay:      configuration.max_delay,
+          time_precision: configuration.time_precision
+      end
+
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+
+      def configuration
+        @configuration ||= InfluxDB::Rails::Configuration.new
+      end
+
+      def current
+        @current ||= InfluxDB::Rails::Context.new
+      end
+
+      def report_exception_unless_ignorable(ex, env = {})
+        report_exception(ex, env) unless ignorable_exception?(ex)
+      end
+      alias transmit_unless_ignorable report_exception_unless_ignorable
+
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
+
+      def report_exception(ex, env = {})
+        timestamp = InfluxDB::Rails.current_timestamp
+        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:      tags,
+          timestamp: timestamp
+      rescue StandardError => ex
+        log :info, "[InfluxDB::Rails] Something went terribly wrong." \
+          " Exception failed to take off! #{ex.class}: #{ex.message}"
+      end
+      alias transmit report_exception
+
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+
+      def current_timestamp
+        InfluxDB.now(configuration.time_precision)
+      end
+
+      def ignorable_exception?(ex)
+        configuration.ignore_current_environment? || configuration.ignore_exception?(ex)
+      end
+
+      def rescue
+        yield
+      rescue StandardError => ex
+        raise ex if configuration.ignore_current_environment?
+
+        transmit_unless_ignorable(ex)
+      end
+
+      def rescue_and_reraise
+        yield
+      rescue StandardError => ex
+        transmit_unless_ignorable(ex)
+        raise ex
+      end
+    end
+  end
+end

data/lib/influxdb/rails/air_traffic_controller.rb

@@ -0,0 +1,41 @@
+module InfluxDB
+  module Rails
+    module AirTrafficController # :nodoc:
+      def influxdb_request_data # rubocop:disable Metrics/MethodLength
+        {
+          params:       influxdb_filtered_params,
+          session_data: influxdb_session_data,
+          controller:   params[:controller],
+          action:       params[:action],
+          request_url:  influxdb_request_url,
+          user_agent:   request.env["HTTP_USER_AGENT"],
+          remote_ip:    request.remote_ip,
+          referer:      request.referer,
+          current_user: (current_user rescue nil),
+        }
+      end
+
+      private
+
+      def influxdb_session_data
+        session.respond_to?(:to_hash) ? session.to_hash : session.data
+      end
+
+      def influxdb_request_url
+        url = "#{request.protocol}#{request.host}"
+        url << ":#{request.port}" unless [80, 443].include?(request.port)
+        url << request.fullpath
+      end
+
+      def influxdb_filtered_params
+        if respond_to?(:filter_parameters)
+          filter_parameters(unfiltered_params)
+        elsif defined?(request.filtered_parameters)
+          request.filtered_parameters
+        else
+          params.to_hash.except(:password, :password_confirmation)
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/rails/backtrace.rb

@@ -0,0 +1,44 @@
+module InfluxDB
+  module Rails
+    class Backtrace # rubocop:disable Style/Documentation
+      class Line # rubocop:disable Style/Documentation
+        FORMAT = /^((?:[a-zA-Z]:)?[^:]+):(\d+)(?::in `([^']+)')?$/.freeze
+
+        attr_reader :file
+        attr_reader :number
+        attr_reader :method
+
+        def initialize(line)
+          _, @file, @number, @method = line.match(FORMAT).to_a
+        end
+
+        def to_s
+          "#{file}:#{number} in `#{method}'"
+        end
+
+        def inspect
+          "<Line: #{to_s}>" # rubocop:disable Lint/StringConversionInInterpolation
+        end
+      end
+
+      attr_reader :lines
+
+      def initialize(backtrace)
+        @lines = Array(backtrace).each.collect do |line|
+          InfluxDB::Rails.configuration.backtrace_filters.each do |filter|
+            line = filter.call(line)
+          end
+          Line.new(line)
+        end
+      end
+
+      def to_a
+        lines.map(&:to_s)
+      end
+
+      def inspect
+        "<Backtrace: " + lines.collect(&:to_s).join(", ") + ">"
+      end
+    end
+  end
+end

data/lib/influxdb/rails/configuration.rb

@@ -0,0 +1,211 @@
+module InfluxDB
+  module Rails
+    # rubocop:disable Metrics/ClassLength
+
+    class Configuration # rubocop:disable Style/Documentation
+      attr_accessor :influxdb_hosts
+      attr_accessor :influxdb_port
+      attr_accessor :influxdb_username
+      attr_accessor :influxdb_password
+      attr_accessor :influxdb_database
+      attr_accessor :async
+      attr_accessor :use_ssl
+      attr_accessor :retry
+      attr_accessor :open_timeout
+      attr_accessor :read_timeout
+      attr_accessor :max_delay
+      attr_accessor :time_precision
+
+      attr_accessor :series_name_for_controller_runtimes
+      attr_accessor :series_name_for_view_runtimes
+      attr_accessor :series_name_for_db_runtimes
+      attr_accessor :series_name_for_exceptions
+      attr_accessor :series_name_for_instrumentation
+      attr_accessor :series_name_for_render_template
+      attr_accessor :series_name_for_render_partial
+      attr_accessor :series_name_for_render_collection
+      attr_accessor :series_name_for_sql
+
+      attr_accessor :tags_middleware
+      attr_accessor :rails_app_name
+
+      attr_accessor :application_name
+      attr_accessor :application_root
+
+      attr_accessor :logger
+      attr_accessor :environment
+      attr_accessor :framework
+      attr_accessor :framework_version
+      attr_accessor :language
+      attr_accessor :language_version
+      attr_accessor :ignored_exceptions
+      attr_accessor :ignored_exception_messages
+      attr_accessor :ignored_reports
+      attr_accessor :ignored_environments
+      attr_accessor :ignored_user_agents
+      attr_accessor :backtrace_filters
+      attr_accessor :aggregated_exception_classes
+      attr_accessor :environment_variables
+      attr_accessor :environment_variable_filters
+
+      attr_accessor :instrumentation_enabled
+      attr_accessor :debug
+
+      DEFAULTS = {
+        influxdb_hosts:                      ["localhost"].freeze,
+        influxdb_port:                       8086,
+        influxdb_username:                   "root".freeze,
+        influxdb_password:                   "root".freeze,
+        influxdb_database:                   nil,
+        async:                               true,
+        use_ssl:                             false,
+        retry:                               nil,
+        open_timeout:                        5,
+        read_timeout:                        300,
+        max_delay:                           30,
+        time_precision:                      "s".freeze,
+
+        series_name_for_controller_runtimes: "rails.controller".freeze,
+        series_name_for_view_runtimes:       "rails.view".freeze,
+        series_name_for_db_runtimes:         "rails.db".freeze,
+        series_name_for_exceptions:          "rails.exceptions".freeze,
+        series_name_for_instrumentation:     "instrumentation".freeze,
+        series_name_for_render_template:     "rails.render_template".freeze,
+        series_name_for_render_partial:      "rails.render_partial".freeze,
+        series_name_for_render_collection:   "rails.render_collection".freeze,
+        series_name_for_sql:                 nil,
+
+        tags_middleware:                     ->(tags) { tags },
+        rails_app_name:                      nil,
+
+        ignored_exceptions:                  %w[
+          ActiveRecord::RecordNotFound
+          ActionController::RoutingError
+        ].freeze,
+
+        ignored_exception_messages:          [].freeze,
+        ignored_reports:                     [].freeze,
+        ignored_environments:                %w[test cucumber selenium].freeze,
+        ignored_user_agents:                 %w[GoogleBot].freeze,
+        environment_variable_filters:        [
+          /password/i,
+          /key/i,
+          /secret/i,
+          /ps1/i,
+          /rvm_.*_clr/i,
+          /color/i,
+        ].freeze,
+
+        backtrace_filters:                   [
+          ->(line) { line.gsub(%r{^\./}, "") },
+          lambda { |line|
+            return line if InfluxDB::Rails.configuration.application_root.to_s.empty?
+
+            line.gsub(/#{InfluxDB::Rails.configuration.application_root}/, "[APP_ROOT]")
+          },
+          lambda { |line|
+            if defined?(Gem) && !Gem.path.nil? && !Gem.path.empty?
+              Gem.path.each { |path| line = line.gsub(/#{path}/, "[GEM_ROOT]") }
+            end
+            line
+          },
+        ].freeze,
+      }.freeze
+
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
+
+      def initialize
+        @influxdb_hosts     = DEFAULTS[:influxdb_hosts]
+        @influxdb_port      = DEFAULTS[:influxdb_port]
+        @influxdb_username  = DEFAULTS[:influxdb_username]
+        @influxdb_password  = DEFAULTS[:influxdb_password]
+        @influxdb_database  = DEFAULTS[:influxdb_database]
+        @async              = DEFAULTS[:async]
+        @use_ssl            = DEFAULTS[:use_ssl]
+        @retry              = DEFAULTS[:retry]
+        @open_timeout       = DEFAULTS[:open_timeout]
+        @read_timeout       = DEFAULTS[:read_timeout]
+        @max_delay          = DEFAULTS[:max_delay]
+        @time_precision     = DEFAULTS[:time_precision]
+
+        @series_name_for_controller_runtimes  = DEFAULTS[:series_name_for_controller_runtimes]
+        @series_name_for_view_runtimes        = DEFAULTS[:series_name_for_view_runtimes]
+        @series_name_for_db_runtimes          = DEFAULTS[:series_name_for_db_runtimes]
+        @series_name_for_exceptions           = DEFAULTS[:series_name_for_exceptions]
+        @series_name_for_instrumentation      = DEFAULTS[:series_name_for_instrumentation]
+        @series_name_for_render_template      = DEFAULTS[:series_name_for_render_template]
+        @series_name_for_render_partial       = DEFAULTS[:series_name_for_render_partial]
+        @series_name_for_render_collection    = DEFAULTS[:series_name_for_render_collection]
+        @series_name_for_sql                  = DEFAULTS[:series_name_for_sql]
+
+        @tags_middleware = DEFAULTS[:tags_middleware]
+        @rails_app_name = DEFAULTS[:rails_app_name]
+
+        @ignored_exceptions           = DEFAULTS[:ignored_exceptions].dup
+        @ignored_exception_messages   = DEFAULTS[:ignored_exception_messages].dup
+        @ignored_reports              = DEFAULTS[:ignored_reports].dup
+        @ignored_environments         = DEFAULTS[:ignored_environments].dup
+        @ignored_user_agents          = DEFAULTS[:ignored_user_agents].dup
+        @backtrace_filters            = DEFAULTS[:backtrace_filters].dup
+        @environment_variable_filters = DEFAULTS[:environment_variable_filters]
+        @aggregated_exception_classes = []
+
+        @debug                    = false
+        @rescue_global_exceptions = false
+        @instrumentation_enabled  = true
+      end
+
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+
+      def debug?
+        !!@debug # rubocop:disable Style/DoubleNegation
+      end
+
+      def instrumentation_enabled?
+        !!@instrumentation_enabled # rubocop:disable Style/DoubleNegation
+      end
+
+      def ignore_user_agent?(incoming_user_agent)
+        return false if ignored_user_agents.nil?
+
+        ignored_user_agents.any? { |agent| incoming_user_agent =~ /#{agent}/ }
+      end
+
+      def ignore_current_environment?
+        ignored_environments.include?(environment)
+      end
+
+      def ignore_exception?(ex)
+        !ignored_exception_messages.find { |msg| /.*#{msg}.*/ =~ ex.message }.nil? ||
+          ignored_exceptions.include?(ex.class.to_s)
+      end
+
+      def define_custom_exception_data(&block)
+        @custom_exception_data_handler = block
+      end
+
+      def add_custom_exception_data(exception_presenter)
+        @custom_exception_data_handler&.call(exception_presenter)
+      end
+
+      def load_rails_defaults
+        @logger           ||= ::Rails.logger
+        @environment      ||= ::Rails.env
+        @application_root ||= ::Rails.root
+        @application_name ||= ::Rails.application.class.parent_name
+        @framework          = "Rails"
+        @framework_version  = ::Rails.version
+      end
+
+      private
+
+      def initialize_http_connection
+        Net::HTTP.new(@app_host, "80")
+      end
+    end
+
+    # rubocop:enable Metrics/ClassLength
+  end
+end