elastic-apm 0.1.0

data/lib/elastic_apm/injectors/net_http.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module ElasticAPM
+  # @api private
+  module Injectors
+    # @api private
+    class NetHTTPInjector
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def install
+        Net::HTTP.class_eval do
+          alias request_without_apm request
+
+          def request(req, body = nil, &block)
+            unless ElasticAPM.current_transaction
+              return request_without_apm(req, body, &block)
+            end
+
+            host, port = req['host'] && req['host'].split(':')
+            method = req.method
+            path = req.path
+            scheme = use_ssl? ? 'https' : 'http'
+
+            # inside a session
+            host ||= address
+            port ||= 80
+
+            # TODO: investigate
+            _extra = {
+              scheme: scheme,
+              port: port,
+              path: path
+            }
+
+            name = "#{method} #{host}"
+            type = "ext.net_http.#{method}"
+
+            ElasticAPM.span name, type do
+              request_without_apm(req, body, &block)
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    end
+
+    register 'Net::HTTP', 'net/http', NetHTTPInjector.new
+  end
+end

data/lib/elastic_apm/injectors/redis.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module Injectors
+    # @api private
+    class RedisInjector
+      # rubocop:disable Metrics/MethodLength
+      def install
+        ::Redis::Client.class_eval do
+          alias call_without_apm call
+
+          def call(command, &block)
+            name = command[0].upcase
+            statement =
+              format('%s %s', name, command[1..command.length].join(' '))
+            context = Span::Context.new(
+              statement: statement,
+              type: 'redis'
+            )
+
+            ElasticAPM.span(name.to_s, 'db.redis', context: context) do
+              call_without_apm(command, &block)
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+
+    register 'Redis', 'redis', RedisInjector.new
+  end
+end

data/lib/elastic_apm/injectors/sequel.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'elastic_apm/sql_summarizer'
+
+module ElasticAPM
+  # @api private
+  module Injectors
+    # @api private
+    class SequelInjector
+      TYPE = 'db.sequel.sql'.freeze
+
+      def self.summarizer
+        @summarizer ||= SqlSummarizer.new
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def install
+        require 'sequel/database/logging'
+
+        ::Sequel::Database.class_eval do
+          alias log_connection_yield_without_apm log_connection_yield
+
+          def log_connection_yield(sql, *args, &block)
+            unless ElasticAPM.current_transaction
+              return log_connection_yield_without_apm(sql, *args, &block)
+            end
+
+            summarizer = ElasticAPM::Injectors::SequelInjector.summarizer
+            name = summarizer.summarize sql
+            context = Span::Context.new(
+              statement: sql,
+              type: 'sql',
+              user: opts[:user]
+            )
+
+            ElasticAPM.span(name, TYPE, context: context, &block)
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+
+    register 'Sequel', 'sequel', SequelInjector.new
+  end
+end

data/lib/elastic_apm/injectors/sinatra.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module Injectors
+    # @api private
+    class SinatraInjector
+      # rubocop:disable Metrics/MethodLength
+      def install
+        ::Sinatra::Base.class_eval do
+          alias dispatch_without_apm! dispatch!
+          alias compile_template_without_apm compile_template
+
+          def dispatch!(*args, &block)
+            dispatch_without_apm!(*args, &block).tap do
+              next unless (transaction = ElasticAPM.current_transaction)
+              next unless (route = env['sinatra.route'])
+
+              transaction.name = route
+            end
+          end
+
+          def compile_template(engine, data, opts, *args, &block)
+            opts[:__elastic_apm_template_name] =
+              case data
+              when Symbol then data.to_s
+              else format('Inline %s', engine)
+              end
+
+            compile_template_without_apm(engine, data, opts, *args, &block)
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+
+    register 'Sinatra::Base', 'sinatra/base', SinatraInjector.new
+
+    require 'elastic_apm/injectors/tilt'
+  end
+end

data/lib/elastic_apm/injectors/tilt.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module Injectors
+    # @api private
+    class TiltInjector
+      TYPE = 'template.tilt'.freeze
+
+      def install
+        ::Tilt::Template.class_eval do
+          alias render_without_apm render
+
+          def render(*args, &block)
+            name = options[:__elastic_apm_template_name] || 'Unknown template'
+
+            ElasticAPM.span name, TYPE do
+              render_without_apm(*args, &block)
+            end
+          end
+        end
+      end
+    end
+
+    register 'Tilt::Template', 'tilt/template', TiltInjector.new
+  end
+end

data/lib/elastic_apm/instrumenter.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'elastic_apm/subscriber'
+require 'elastic_apm/span'
+require 'elastic_apm/transaction'
+
+module ElasticAPM
+  # @api private
+  class Instrumenter
+    include Log
+
+    KEY = :__elastic_transaction_key
+
+    # @api private
+    class TransactionInfo
+      def current
+        Thread.current[KEY]
+      end
+
+      def current=(transaction)
+        Thread.current[KEY] = transaction
+      end
+    end
+
+    def initialize(config, agent, subscriber_class: Subscriber)
+      @config = config
+      @agent = agent
+
+      @transaction_info = TransactionInfo.new
+
+      @subscriber = subscriber_class.new(self)
+
+      @pending_transactions = []
+      @last_sent_transactions = Time.now.utc
+    end
+
+    attr_reader :config, :pending_transactions
+
+    def start
+      @subscriber.register!
+    end
+
+    def stop
+      current_transaction.release if current_transaction
+      @subscriber.unregister!
+    end
+
+    def current_transaction
+      @transaction_info.current
+    end
+
+    def current_transaction=(transaction)
+      @transaction_info.current = transaction
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def transaction(*args)
+      if (transaction = current_transaction)
+        yield transaction if block_given?
+        return transaction
+      end
+
+      transaction = Transaction.new self, *args
+
+      self.current_transaction = transaction
+      return transaction unless block_given?
+
+      begin
+        yield transaction
+      ensure
+        self.current_transaction = nil
+        transaction.done
+      end
+
+      transaction
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def span(*args, &block)
+      transaction.span(*args, &block)
+    end
+
+    def submit_transaction(transaction)
+      @pending_transactions << transaction
+
+      if config.debug_transactions
+        debug('Submitted transaction:') { Util.inspect_transaction transaction }
+      end
+
+      return unless should_flush_transactions?
+      flush_transactions
+    end
+
+    def should_flush_transactions?
+      return true unless (interval = config.transaction_send_interval)
+      Time.now.utc - @last_sent_transactions >= interval
+    end
+
+    def flush_transactions
+      return if @pending_transactions.empty?
+
+      debug 'Flushing transactions'
+
+      @agent.enqueue_transactions @pending_transactions
+
+      @last_sent_transactions = Time.now.utc
+      @pending_transactions = []
+
+      true
+    end
+  end
+end

data/lib/elastic_apm/internal_error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class InternalError < StandardError; end
+end

data/lib/elastic_apm/log.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  module Log
+    PREFIX = '** [ElasticAPM] '.freeze
+
+    def debug(msg, *args, &block)
+      log(:debug, msg, *args, &block)
+    end
+
+    def info(msg, *args, &block)
+      log(:info, msg, *args, &block)
+    end
+
+    def warn(msg, *args, &block)
+      log(:warn, msg, *args, &block)
+    end
+
+    def error(msg, *args, &block)
+      log(:error, msg, *args, &block)
+    end
+
+    def fatal(msg, *args, &block)
+      log(:fatal, msg, *args, &block)
+    end
+
+    def log(lvl, msg, *args)
+      formatted_msg = prepend_prefix(format(msg.to_s, *args))
+
+      return config.logger.send(lvl, formatted_msg) unless block_given?
+
+      # TODO: dont evaluate block if level is higher
+      config.logger.send(lvl, "#{formatted_msg}\n#{yield}")
+    end
+
+    private
+
+    def prepend_prefix(str)
+      "#{PREFIX}#{str}"
+    end
+
+    def has_logger?
+      respond_to?(:config) && config.logger
+    end
+  end
+end

data/lib/elastic_apm/middleware.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  # @api private
+  class Middleware
+    def initialize(app)
+      @app = app
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def call(env)
+      begin
+        transaction = ElasticAPM.transaction 'Rack', 'request'
+        resp = @app.call env
+        transaction.submit(resp[0]) if transaction
+      rescue InternalError
+        raise # Don't report ElasticAPM errors
+      rescue ::Exception => e
+        ElasticAPM.report(e, rack_env: env, handled: false)
+        transaction.submit(500) if transaction
+        raise
+      ensure
+        transaction.release if transaction
+      end
+
+      resp
+    end
+    # rubocop:enable Metrics/MethodLength
+  end
+end

data/lib/elastic_apm/normalizers.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ElasticAPM # :nodoc:
+  # @api private
+  module Normalizers
+    # @api privagte
+    class Normalizer
+      def initialize(config)
+        @config = config
+      end
+
+      def self.register(name)
+        Normalizers.register(name, self)
+      end
+    end
+
+    def self.register(name, klass)
+      @registered ||= {}
+      @registered[name] = klass
+    end
+
+    def self.build(config)
+      normalizers = @registered.each_with_object({}) do |(name, klass), built|
+        built[name] = klass.new(config)
+      end
+
+      Collection.new(normalizers)
+    end
+
+    # @api private
+    class Collection
+      # @api private
+      class SkipNormalizer
+        def initialize; end
+
+        def normalize(*_args)
+          :skip
+        end
+      end
+
+      def initialize(normalizers)
+        @normalizers = normalizers
+        @default = SkipNormalizer.new
+      end
+
+      def for(name)
+        @normalizers.fetch(name, @default)
+      end
+
+      def keys
+        @normalizers.keys
+      end
+
+      def normalize(transaction, name, payload)
+        self.for(name).normalize(transaction, name, payload)
+      end
+    end
+  end
+
+  %w[action_controller action_view active_record].each do |lib|
+    require "elastic_apm/normalizers/#{lib}"
+  end
+end