atatus 1.6.2 → 2.0.0

data/lib/atatus/spies/http.rb

@@ -22,54 +22,50 @@ module Atatus
   module Spies
     # @api private
     class HTTPSpy
-      TYPE = 'ext'
-      SUBTYPE = 'http_rb'
-      def install
-        if defined?(::HTTP) && defined?(::HTTP::Client)
-
-          ::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
+      TYPE = 'external'
+      SUBTYPE = 'http'
 
-              method = req.verb.to_s.upcase
-              host = req.uri.host
+      # @api private
+      module Ext
+        def perform(req, options)
+          unless (transaction = Atatus.current_transaction)
+            return super(req, options)
+          end
 
-              destination =
-                Atatus::Span::Context::Destination.from_uri(req.uri)
-              context = Atatus::Span::Context.new(
-                http: { url: req.uri, method: method },
-                destination: destination
-              )
+          method = req.verb.to_s.upcase
+          host = req.uri.host
 
-              name = "#{method} #{host}"
+          context = Atatus::Span::Context.new(
+            http: { url: req.uri, method: method },
+            destination: Atatus::Span::Context::Destination.from_uri(req.uri, type: SUBTYPE)
+          )
 
-              Atatus.with_span(
-                name,
-                TYPE,
-                subtype: SUBTYPE,
-                action: method,
-                context: context
-              ) do |span|
-                trace_context = span&.trace_context || transaction.trace_context
-                trace_context.apply_headers { |key, value| req[key] = value }
+          name = "#{method} #{host}"
 
-                result = perform_without_apm(req, options)
+          Atatus.with_span(
+            name,
+            TYPE,
+            subtype: SUBTYPE,
+            context: context
+          ) do |span|
+            trace_context = span&.trace_context || transaction.trace_context
+            trace_context.apply_headers { |key, value| req[key] = value }
 
-                if (http = span&.context&.http)
-                  http.status_code = result.status.to_s
-                end
+            result = super(req, options)
 
-                result
-              end
+            if (http = span&.context&.http)
+              http.status_code = result.status.to_s
             end
-          end
 
+            span&.outcome = Span::Outcome.from_http_status(result.status)
+            result
+          end
         end
       end
+
+      def install
+        ::HTTP::Client.prepend(Ext)
+      end
     end
 
     register 'HTTP', 'http', HTTPSpy.new

data/lib/atatus/spies/json.rb

@@ -25,15 +25,11 @@ module Atatus
     # @api private
     class JSONSpy
       def install
-        if defined?(::JSON)
-
-          ::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
-
+        ::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

data/lib/atatus/spies/mongo.rb

@@ -23,14 +23,10 @@ module Atatus
     # @api private
     class MongoSpy
       def install
-        if defined?(::Mongo) && defined?(::Mongo::Monitoring) && defined?(::Mongo::Monitoring::Global)
-
-          ::Mongo::Monitoring::Global.subscribe(
-            ::Mongo::Monitoring::COMMAND,
-            Subscriber.new
-          )
-
-        end
+        ::Mongo::Monitoring::Global.subscribe(
+          ::Mongo::Monitoring::COMMAND,
+          Subscriber.new
+        )
       end
 
       # @api private
@@ -39,8 +35,10 @@ module Atatus
         SUBTYPE = 'mongodb'
         ACTION = 'query'
 
-        def initialize
-          @events = {}
+        EVENT_KEY = :__atatus_instrumenter_mongo_events_key
+
+        def events
+          Thread.current[EVENT_KEY] ||= []
         end
 
         def started(event)
@@ -48,11 +46,19 @@ module Atatus
         end
 
         def failed(event)
-          pop_event(event)
+          if (span = pop_event(event))
+            span.outcome = Span::Outcome::FAILURE
+          end
+
+          span
         end
 
         def succeeded(event)
-          pop_event(event)
+          if span = pop_event(event)
+            span.outcome = Span::Outcome::SUCCESS
+          end
+
+          span
         end
 
         private
@@ -66,7 +72,7 @@ module Atatus
           # and the collection name is at the key `collection`
           collection =
             if event.command[event.command_name] == 1 ||
-               event.command[event.command_name].is_a?(BSON::Int64)
+              event.command[event.command_name].is_a?(BSON::Int64)
               event.command[:collection]
             else
               event.command[event.command_name]
@@ -85,14 +91,13 @@ module Atatus
               context: build_context(event)
             )
 
-          @events[event.operation_id] = span
+          events << span
         end
 
         def pop_event(event)
-          span = @events.delete(event.operation_id)
           return unless (curr = Atatus.current_span)
 
-          curr == span && Atatus.end_span
+          curr == events[-1] && Atatus.end_span(events.pop)
         end
 
         def build_context(event)
@@ -104,9 +109,11 @@ module Atatus
               user: nil
             },
             destination: {
-              name: SUBTYPE,
-              resource: SUBTYPE,
-              type: TYPE
+              service: {
+                name: SUBTYPE,
+                resource: SUBTYPE,
+                type: TYPE
+              }
             }
           )
         end

data/lib/atatus/spies/net_http.rb

@@ -22,17 +22,17 @@ module Atatus
   module Spies
     # @api private
     class NetHTTPSpy
-      KEY = :__atatus_net_http_disabled
-      TYPE = 'ext'
-      SUBTYPE = 'net_http'
+      DISABLE_KEY = :__atatus_net_http_disabled
+      TYPE = 'external'
+      SUBTYPE = 'http'
 
       class << self
         def disabled=(disabled)
-          Thread.current[KEY] = disabled
+          Thread.current[DISABLE_KEY] = disabled
         end
 
         def disabled?
-          Thread.current[KEY] ||= false
+          Thread.current[DISABLE_KEY] ||= false
         end
 
         def disable_in
@@ -46,66 +46,68 @@ module Atatus
         end
       end
 
-      # rubocop:disable Metrics/CyclomaticComplexity
-      def install
-        if defined?(::Net) && defined?(::Net::HTTP)
+      # @api private
+      module Ext
+        # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+        def request(req, body = nil, &block)
+          unless (transaction = Atatus.current_transaction)
+            return super(req, body, &block)
+          end
 
-          Net::HTTP.class_eval do
-            alias request_without_apm request
+          if Atatus::Spies::NetHTTPSpy.disabled?
+            return super(req, body, &block)
+          end
 
-            def request(req, body = nil, &block)
-              unless (transaction = Atatus.current_transaction)
-                return request_without_apm(req, body, &block)
-              end
+          host = req['host']&.split(':')&.first || address || 'localhost'
+          method = req.method.to_s.upcase
 
-              if Atatus::Spies::NetHTTPSpy.disabled?
-                return request_without_apm(req, body, &block)
-              end
+          uri_or_path = URI(req.path)
 
-              host = req['host']&.split(':')&.first || address
-              method = req.method.to_s.upcase
+          # Support the case where a whole url is passed as a path to a nil host
+          uri =
+            if uri_or_path.host
+              uri_or_path
+            else
               path, query = req.path.split('?')
-
               url = use_ssl? ? +'https://' : +'http://'
               url << host
               url << ":#{port}" if port
               url << path
               url << "?#{query}" if query
-              uri = URI(url)
-
-              destination =
-                Atatus::Span::Context::Destination.from_uri(uri)
-
-              context =
-                Atatus::Span::Context.new(
-                  http: { url: uri, method: method },
-                  destination: destination
-                )
-
-              Atatus.with_span(
-                "#{method} #{host}",
-                TYPE,
-                subtype: SUBTYPE,
-                action: method,
-                context: context
-              ) do |span|
-                trace_context = span&.trace_context || transaction.trace_context
-                trace_context.apply_headers { |key, value| req[key] = value }
-
-                result = request_without_apm(req, body, &block)
-
-                if (http = span&.context&.http)
-                  http.status_code = result.code
-                end
-
-                result
-              end
+              URI(url)
             end
-          end
 
+          context =
+            Atatus::Span::Context.new(
+              http: { url: uri, method: method },
+              destination: Atatus::Span::Context::Destination.from_uri(uri, type: SUBTYPE)
+            )
+
+          Atatus.with_span(
+            "#{method} #{host}",
+            TYPE,
+            subtype: SUBTYPE,
+            context: context
+          ) do |span|
+            trace_context = span&.trace_context || transaction.trace_context
+            trace_context.apply_headers { |key, value| req[key] = value }
+
+            result = super(req, body, &block)
+
+            if (http = span&.context&.http)
+              http.status_code = result.code
+            end
+
+            span&.outcome = Span::Outcome.from_http_status(result.code)
+            result
+          end
         end
+        # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      end
+
+      def install
+        Net::HTTP.prepend(Ext)
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
     end
 
     register 'Net::HTTP', 'net/http', NetHTTPSpy.new

data/lib/atatus/spies/racecar.rb

@@ -0,0 +1,77 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+begin
+require 'active_support/notifications'
+require 'active_support/subscriber'
+
+  # frozen_string_literal: true
+  module Atatus
+    # @api private
+    module Spies
+      # @api private
+      class RacecarSpy
+        TYPE = 'kafka'
+        SUBTYPE = 'racecar'
+
+        # @api private
+        class ConsumerSubscriber < ActiveSupport::Subscriber
+          def start_process_message(event)
+            start_process_transaction(event: event, kind: 'process_message')
+          end
+          def process_message(_event)
+            Atatus.end_transaction
+          end
+
+          def start_process_batch(event)
+            start_process_transaction(event: event, kind: 'process_batch')
+          end
+          def process_batch(_event)
+            Atatus.end_transaction
+          end
+
+          private # only public methods will be subscribed
+
+          def start_process_transaction(event:, kind:)
+            Atatus.start_transaction(kind, TYPE)
+            Atatus.current_transaction.context.set_service(framework_name: 'racecar', framework_version: Racecar::VERSION)
+          end
+        end
+
+        class ProducerSubscriber < ActiveSupport::Subscriber
+          def start_deliver_message(event)
+            Atatus.start_transaction('deliver_message',TYPE)
+            Atatus.current_transaction.context.set_service(framework_name: 'racecar', framework_version: Racecar::VERSION)
+          end
+
+          def deliver_message(_event)
+            Atatus.end_transaction
+          end
+        end
+
+        def install
+          ConsumerSubscriber.attach_to(:racecar)
+          ProducerSubscriber.attach_to(:racecar)
+        end
+      end
+      register 'Racecar', 'racecar', RacecarSpy.new
+    end
+  end
+
+rescue LoadError
+  # no active support available
+end

data/lib/atatus/spies/rake.rb

@@ -22,43 +22,43 @@ module Atatus
   module Spies
     # @api private
     class RakeSpy
-      def install
-        if defined?(::Rake) && defined?(::Rake::Task)
-
-          ::Rake::Task.class_eval do
-            alias execute_without_apm execute
-
-            def execute(*args)
-              agent = Atatus.start
+      # @api private
+      module Ext
+        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')
+          unless agent && agent.config.instrumented_rake_tasks.include?(name)
+            return super(*args)
+          end
 
-              begin
-                result = execute_without_apm(*args)
+          transaction =
+            Atatus.start_transaction("Rake::Task[#{name}]", 'Rake')
 
-                transaction.result = 'success' if transaction
-              rescue StandardError => e
-                transaction.result = 'error' if transaction
-                Atatus.report(e)
+          begin
+            result = super(*args)
 
-                raise
-              ensure
-                Atatus.end_transaction
-                Atatus.stop
-              end
+            transaction&.result = 'success'
+            transaction&.outcome = Transaction::Outcome::SUCCESS
+          rescue StandardError => e
+            transaction&.result = 'error'
+            transaction&.outcome = Transaction::Outcome::FAILURE
+            Atatus.report(e)
 
-              result
-            end
+            raise
+          ensure
+            Atatus.end_transaction
+            Atatus.stop
           end
 
+          result
         end
       end
+
+      def install
+        ::Rake::Task.prepend(Ext)
+      end
     end
+
     register 'Rake::Task', 'rake', RakeSpy.new
   end
 end

data/lib/atatus/spies/redis.rb

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

data/lib/atatus/spies/resque.rb

@@ -24,31 +24,26 @@ module Atatus
     class ResqueSpy
       TYPE = 'Resque'
 
-      def install
-        install_perform_spy
+      # @api private
+      module Ext
+        def perform
+          name = @payload && @payload['class']&.to_s
+          transaction = Atatus.start_transaction(name, TYPE)
+          super
+          transaction&.done 'success'
+          transaction&.outcome = Transaction::Outcome::SUCCESS
+        rescue ::Exception => e
+          Atatus.report(e, handled: false)
+          transaction&.done 'error'
+          transaction&.outcome = Transaction::Outcome::FAILURE
+          raise
+        ensure
+          Atatus.end_transaction
+        end
       end
 
-      def install_perform_spy
-        if defined?(::Resque) && defined?(::Resque::Job)
-
-          ::Resque::Job.class_eval do
-            alias :perform_without_atatus :perform
-
-            def perform
-              name = @payload && @payload['class']&.to_s
-              transaction = Atatus.start_transaction(name, TYPE)
-              perform_without_atatus
-              transaction.done 'success'
-            rescue ::Exception => e
-              Atatus.report(e, handled: false)
-              transaction.done 'error' if transaction
-              raise
-            ensure
-              Atatus.end_transaction
-            end
-          end
-
-        end
+      def install
+        ::Resque::Job.prepend(Ext)
       end
     end