atatus 1.0.0

data/lib/atatus/spies/elasticsearch.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class ElasticsearchSpy
+      NAME_FORMAT = '%s %s'
+      TYPE = 'db.elasticsearch'
+
+      # rubocop:disable Metrics/MethodLength
+      def install
+        ::Elasticsearch::Transport::Client.class_eval do
+          alias perform_request_without_apm perform_request
+
+          def perform_request(method, path, *args, &block)
+            name = format(NAME_FORMAT, method, path)
+            statement = args[0].is_a?(String) ? args[0] : args[0].to_json
+            context = Span::Context.new(db: { statement: statement })
+
+            Atatus.with_span name, TYPE, context: context do
+              perform_request_without_apm(method, path, *args, &block)
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+
+    register(
+      'Elasticsearch::Transport::Client',
+      'elasticsearch-transport',
+      ElasticsearchSpy.new
+    )
+  end
+end

data/lib/atatus/spies/faraday.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class FaradaySpy
+      TYPE = 'ext'
+      SUBTYPE = 'faraday'
+
+      def self.without_net_http
+        return yield unless defined?(NetHTTPSpy)
+
+        Atatus::Spies::NetHTTPSpy.disable_in do
+          yield
+        end
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      # rubocop:disable Metrics/BlockLength, Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def install
+        ::Faraday::Connection.class_eval do
+          alias run_request_without_apm run_request
+
+          def run_request(method, url, body, headers, &block)
+            unless (transaction = Atatus.current_transaction)
+              return run_request_without_apm(method, url, body, headers, &block)
+            end
+
+            host = if url_prefix.is_a?(URI) && url_prefix.host
+                     url_prefix.host
+                   elsif url.nil?
+                     tmp_request = build_request(method) do |req|
+                       yield(req) if block_given?
+                     end
+                     URI(tmp_request.path).host
+                   else
+                     URI(url).host
+                   end
+
+            name = "#{method.upcase} #{host}"
+
+            Atatus.with_span(
+              name,
+              TYPE,
+              subtype: SUBTYPE,
+              action: method.to_s
+            ) do |span|
+              Atatus::Spies::FaradaySpy.without_net_http do
+                trace_context = span&.trace_context || transaction.trace_context
+
+                run_request_without_apm(method, url, body, headers) do |req|
+                  req['Atatus-Apm-Traceparent'] = trace_context.to_header
+
+                  yield req if block_given?
+                end
+              end
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/BlockLength, Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+    end
+
+    register 'Faraday', 'faraday', FaradaySpy.new
+  end
+end

data/lib/atatus/spies/http.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class HTTPSpy
+      TYPE = 'ext'
+      SUBTYPE = 'http_rb'
+
+      # rubocop:disable Metrics/MethodLength
+      def install
+        ::HTTP::Client.class_eval do
+          alias perform_without_apm perform
+
+          def perform(req, options)
+            unless (transaction = Atatus.current_transaction)
+              return perform_without_apm(req, options)
+            end
+
+            method = req.verb.to_s.upcase
+            host = req.uri.host
+
+            name = "#{method} #{host}"
+
+            Atatus.with_span(
+              name,
+              TYPE,
+              subtype: SUBTYPE,
+              action: method
+            ) do |span|
+              trace_context = span&.trace_context || transaction.trace_context
+              req['Atatus-Apm-Traceparent'] = trace_context.to_header
+              perform_without_apm(req, options)
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+
+    register 'HTTP', 'http', HTTPSpy.new
+  end
+end

data/lib/atatus/spies/json.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'atatus/span_helpers'
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class JSONSpy
+      def install
+        ::JSON.class_eval do
+          include SpanHelpers
+          span_class_method :parse, 'JSON#parse', 'json.parse'
+          span_class_method :parse!, 'JSON#parse!', 'json.parse'
+          span_class_method :generate, 'JSON#generate', 'json.generate'
+        end
+      end
+    end
+
+    register 'JSON', 'json', JSONSpy.new
+  end
+end

data/lib/atatus/spies/mongo.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class MongoSpy
+      def install
+        ::Mongo::Monitoring::Global.subscribe(
+          ::Mongo::Monitoring::COMMAND,
+          Subscriber.new
+        )
+      end
+
+      # @api private
+      class Subscriber
+        TYPE = 'db'
+        SUBTYPE = 'mongodb'
+        ACTION = 'query'
+
+        def initialize
+          @events = {}
+        end
+
+        def started(event)
+          push_event(event)
+        end
+
+        def failed(event)
+          pop_event(event)
+        end
+
+        def succeeded(event)
+          pop_event(event)
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def push_event(event)
+          return unless Atatus.current_transaction
+          # Some MongoDB commands are not on collections but rather are db
+          # admin commands. For these commands, the value at the `command_name`
+          # key is the integer 1.
+          unless event.command[event.command_name] == 1
+            collection = event.command[event.command_name]
+          end
+          name = [event.database_name,
+                  collection,
+                  event.command_name].compact.join('.')
+
+          span =
+            Atatus.start_span(
+              name,
+              TYPE,
+              subtype: SUBTYPE,
+              action: ACTION,
+              context: build_context(event)
+            )
+
+          @events[event.operation_id] = span
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def pop_event(event)
+          return unless (curr = Atatus.current_span)
+          span = @events.delete(event.operation_id)
+
+          curr == span && Atatus.end_span
+        end
+
+        def build_context(event)
+          Span::Context.new(
+            db: {
+              instance: event.database_name,
+              statement: event.command.to_s,
+              type: 'mongodb',
+              user: nil
+            }
+          )
+        end
+      end
+    end
+
+    register 'Mongo', 'mongo', MongoSpy.new
+  end
+end

data/lib/atatus/spies/net_http.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class NetHTTPSpy
+      KEY = :__atatus_net_http_disabled
+      TYPE = 'ext'
+      SUBTYPE = 'net_http'
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      class << self
+        def disabled=(disabled)
+          Thread.current[KEY] = disabled
+        end
+
+        def disabled?
+          Thread.current[KEY] ||= false
+        end
+
+        def disable_in
+          self.disabled = true
+
+          begin
+            yield
+          ensure
+            self.disabled = false
+          end
+        end
+      end
+
+      def install
+        Net::HTTP.class_eval do
+          alias request_without_apm request
+
+          def request(req, body = nil, &block)
+            unless (transaction = Atatus.current_transaction)
+              return request_without_apm(req, body, &block)
+            end
+            if Atatus::Spies::NetHTTPSpy.disabled?
+              return request_without_apm(req, body, &block)
+            end
+
+            host, = req['host'] && req['host'].split(':')
+            method = req.method
+
+            host ||= address
+
+            name = "#{method} #{host}"
+
+            Atatus.with_span(
+              name,
+              TYPE,
+              subtype: SUBTYPE,
+              action: method.to_s
+            ) do |span|
+              trace_context = span&.trace_context || transaction.trace_context
+              req['Atatus-Apm-Traceparent'] = trace_context.to_header
+              request_without_apm(req, body, &block)
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+    end
+
+    register 'Net::HTTP', 'net/http', NetHTTPSpy.new
+  end
+end

data/lib/atatus/spies/rake.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class RakeSpy
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def install
+        ::Rake::Task.class_eval do
+          alias execute_without_apm execute
+
+          def execute(*args)
+            agent = Atatus.start
+
+            unless agent && agent.config.instrumented_rake_tasks.include?(name)
+              return execute_without_apm(*args)
+            end
+
+            transaction =
+              Atatus.start_transaction("Rake::Task[#{name}]", 'Rake')
+
+            begin
+              result = execute_without_apm(*args)
+
+              transaction.result = 'success' if transaction
+            rescue StandardError => e
+              transaction.result = 'error' if transaction
+              Atatus.report(e)
+
+              raise
+            ensure
+              Atatus.end_transaction
+              Atatus.stop
+            end
+
+            result
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    end
+    register 'Rake::Task', 'rake', RakeSpy.new
+  end
+end

data/lib/atatus/spies/redis.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class RedisSpy
+      def install
+        ::Redis::Client.class_eval do
+          alias call_without_apm call
+
+          def call(command, &block)
+            name = command[0].upcase
+
+            return call_without_apm(command, &block) if command[0] == :auth
+
+            Atatus.with_span(name.to_s, 'db.redis') do
+              call_without_apm(command, &block)
+            end
+          end
+        end
+      end
+    end
+
+    register 'Redis', 'redis', RedisSpy.new
+  end
+end

data/lib/atatus/spies/sequel.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'atatus/sql_summarizer'
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class SequelSpy
+      TYPE = 'db.sequel.sql'
+
+      def self.summarizer
+        @summarizer ||= SqlSummarizer.new
+      end
+
+      def self.build_context(sql, opts)
+        Span::Context.new(
+          db: { statement: sql, type: 'sql', user: opts[:user] }
+        )
+      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 Atatus.current_transaction
+              return log_connection_yield_without_apm(sql, *args, &block)
+            end
+
+            summarizer = Atatus::Spies::SequelSpy.summarizer
+            name = summarizer.summarize sql
+            context = Atatus::Spies::SequelSpy.build_context(sql, opts)
+
+            Atatus.with_span(name, TYPE, context: context, &block)
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+
+    register 'Sequel', 'sequel', SequelSpy.new
+  end
+end