atatus 1.7.0 → 2.0.0

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
 

data/lib/atatus/spies/s3.rb

@@ -0,0 +1,132 @@
+# 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.
+#
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module Spies
+    # @api private
+    class S3Spy
+      TYPE = 'storage'
+      SUBTYPE = 's3'
+      AP_REGION_REGEX = /^(?:[^:]+:){3}([^:]+).*/
+      AP_REGEX = /:accesspoint.*/
+      MUTEX = Mutex.new
+
+      @@formatted_op_names = {}
+
+      def self.without_net_http
+        return yield unless defined?(NetHTTPSpy)
+
+        # rubocop:disable Style/ExplicitBlockArgument
+        Atatus::Spies::NetHTTPSpy.disable_in do
+          yield
+        end
+        # rubocop:enable Style/ExplicitBlockArgument
+      end
+
+      def self.bucket_name(params)
+        return unless (bucket = params[:bucket]&.to_s)
+        return bucket unless (index = bucket.rindex(AP_REGEX))
+
+        bucket[index+1..-1]
+      end
+
+      def self.accesspoint_region(params)
+        if params[:bucket] && (match = AP_REGION_REGEX.match(params[:bucket]))
+          match[1]
+        end
+      end
+
+      def self.span_name(operation_name, bucket_name)
+        bucket_name ? "S3 #{formatted_op_name(operation_name)} #{bucket_name}" :
+          "S3 #{formatted_op_name(operation_name)}"
+      end
+
+      def self.formatted_op_name(operation_name)
+        if @@formatted_op_names[operation_name]
+          return @@formatted_op_names[operation_name]
+        end
+
+        MUTEX.synchronize do
+          if @@formatted_op_names[operation_name]
+            return @@formatted_op_names[operation_name]
+          end
+
+          @@formatted_op_names[operation_name] =
+            operation_name.to_s.split('_').collect(&:capitalize).join
+        end
+
+        @@formatted_op_names[operation_name]
+      end
+
+
+      # @api private
+      module Ext
+        def self.prepended(mod)
+          # Alias all available operations
+          mod.api.operation_names.each do |operation_name|
+            define_method(operation_name) do |params = {}, options = {}, &block|
+              bucket_name = Atatus::Spies::S3Spy.bucket_name(params)
+              region = Atatus::Spies::S3Spy.accesspoint_region(params) || config.region
+
+              resource = "#{SUBTYPE}/#{bucket_name || 'unknown-bucket'}"
+              context = Atatus::Span::Context.new(
+                db: {
+                  instance: config.region,
+                  type: SUBTYPE
+                },
+                destination: {
+                  address: config.endpoint.host,
+                  port: config.endpoint.port,
+                  service: {
+                    name: SUBTYPE,
+                    type: TYPE,
+                    resource: resource },
+                  cloud: { region: region }
+                }
+              )
+
+              Atatus.with_span(
+                Atatus::Spies::S3Spy.span_name(operation_name, bucket_name),
+                TYPE,
+                subtype: SUBTYPE,
+                action: Atatus::Spies::S3Spy.formatted_op_name(operation_name),
+                context: context
+              ) do
+                Atatus::Spies::S3Spy.without_net_http do
+                  super(params, options, &block)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def install
+        ::Aws::S3::Client.prepend(Ext)
+      end
+    end
+
+    register(
+      'Aws::S3::Client',
+      'aws-sdk-s3',
+      S3Spy.new
+    )
+  end
+end

data/lib/atatus/spies/sequel.rb

@@ -17,7 +17,7 @@
 
 # frozen_string_literal: true
 
-require 'atatus/sql'
+require 'atatus/sql/signature'
 
 module Atatus
   # @api private
@@ -44,8 +44,17 @@ module Atatus
           name =
             Atatus::Spies::SequelSpy.summarizer.summarize sql
 
+          db_name = ''
+          # postgresql shows current database
+          db_name = connection&.db.to_s if connection.respond_to?(:db)
+          # sqlite may expose a filename
+          db_name = connection&.filename.to_s if db_name == '' && connection.respond_to?(:filename)
+          # fall back to adapter class name
+          db_name = connection.class.to_s if db_name == ''
+
           context = Atatus::Span::Context.new(
             db: { statement: sql, type: 'sql', user: opts[:user] },
+            service: {target: {type: subtype, name: db_name }},
             destination: { service: { resource: subtype } }
           )
 
@@ -84,4 +93,4 @@ module Atatus
 
     register 'Sequel', 'sequel', SequelSpy.new
   end
-end
+end

data/lib/atatus/spies/shoryuken.rb

@@ -37,9 +37,11 @@ module Atatus
           yield
 
           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
@@ -54,12 +56,8 @@ module Atatus
       end
 
       def install
-        if defined?(::Shoryuken)
-
-          ::Shoryuken.server_middleware do |chain|
-            chain.add Middleware
-          end
-
+        ::Shoryuken.server_middleware do |chain|
+          chain.add Middleware
         end
       end
     end