atatus 1.6.2 → 2.0.0

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
@@ -28,56 +28,66 @@ module Atatus
       ACTION = 'query'
 
       def self.summarizer
-        @summarizer ||= Sql.summarizer
+        @summarizer ||= Sql::Signature::Summarizer.new
       end
 
-      def install
-        require 'sequel/database/logging'
-
-        if defined?(::Sequel) && defined?(::Sequel::Database)
-
-          ::Sequel::Database.class_eval do
-            alias log_connection_yield_without_apm log_connection_yield
+      # @api private
+      module Ext
+        # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+        def log_connection_yield(sql, connection, args = nil, &block)
+          unless Atatus.current_transaction
+            return super(sql, connection, args, &block)
+          end
 
-            def log_connection_yield(sql, connection, args = nil, &block)
-              unless Atatus.current_transaction
-                return log_connection_yield_without_apm(
-                  sql, connection, args, &block
-                )
-              end
+          subtype = database_type.to_s
 
-              subtype = database_type.to_s
+          name =
+            Atatus::Spies::SequelSpy.summarizer.summarize sql
 
-              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] },
-                destination: { name: subtype, resource: subtype, type: TYPE }
-              )
+          context = Atatus::Span::Context.new(
+            db: { statement: sql, type: 'sql', user: opts[:user] },
+            service: {target: {type: subtype, name: db_name }},
+            destination: { service: { resource: subtype } }
+          )
 
-              span = Atatus.start_span(
-                name,
-                TYPE,
-                subtype: subtype,
-                action: ACTION,
-                context: context
-              )
-              yield.tap do |result|
-                if name =~ /^(UPDATE|DELETE)/
-                  if connection.respond_to?(:changes)
-                    span.context.db.rows_affected = connection.changes
-                  elsif result.is_a?(Integer)
-                    span.context.db.rows_affected = result
-                  end
-                end
+          span = Atatus.start_span(
+            name,
+            TYPE,
+            subtype: subtype,
+            action: ACTION,
+            context: context
+          )
+          super(sql, connection, args, &block).tap do |result|
+            if /^(UPDATE|DELETE)/.match?(name)
+              if connection.respond_to?(:changes)
+                span.context.db.rows_affected = connection.changes
+              elsif result.is_a?(Integer)
+                span.context.db.rows_affected = result
               end
-            ensure
-              Atatus.end_span
             end
           end
-
+        rescue
+          span&.outcome = Span::Outcome::FAILURE
+          raise
+        ensure
+          span&.outcome ||= Span::Outcome::SUCCESS
+          Atatus.end_span
         end
+        # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      end
+
+      def install
+        require 'sequel/database/logging'
+
+        ::Sequel::Database.prepend(Ext)
       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

data/lib/atatus/spies/sidekiq.rb

@@ -35,9 +35,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
@@ -56,47 +58,37 @@ module Atatus
       end
 
       def install_middleware
-        if defined?(::Sidekiq)
+        Sidekiq.configure_server do |config|
+          config.server_middleware do |chain|
+            chain.add Middleware
+          end
+        end
+      end
 
-          Sidekiq.configure_server do |config|
-            config.server_middleware do |chain|
-              chain.add Middleware
+      # @api private
+      module Ext
+        def start
+          super.tap do
+            # Already running from Railtie if Rails
+            if Atatus.running?
+              Atatus.agent.config.logger = Sidekiq.logger
+            else
+              Atatus.start
             end
           end
+        end
 
+        def terminate
+          super.tap do
+            Atatus.stop
+          end
         end
       end
 
       def install_processor
         require 'sidekiq/processor'
 
-        if defined?(::Sidekiq) && defined?(::Sidekiq::Processor)
-
-          Sidekiq::Processor.class_eval do
-            alias start_without_apm start
-            alias terminate_without_apm terminate
-
-            def start
-              result = start_without_apm
-
-              # Already running from Railtie if Rails
-              if Atatus.running?
-                Atatus.agent.config.logger = Sidekiq.logger
-              else
-                Atatus.start
-              end
-
-              result
-            end
-
-            def terminate
-              terminate_without_apm
-
-              Atatus.stop
-            end
-          end
-
-        end
+        Sidekiq::Processor.prepend(Ext)
       end
 
       def install

data/lib/atatus/spies/sinatra.rb

@@ -22,42 +22,34 @@ module Atatus
   module Spies
     # @api private
     class SinatraSpy
-      def install
-        if defined?(::Sinatra) &&
-            defined?(::Sinatra::Base) &&
-            ::Sinatra::Base.private_method_defined?(:dispatch!) &&
-            ::Sinatra::Base.private_method_defined?(:compile_template)
-
-          ::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 = Atatus.current_transaction)
-                next unless (route = env['sinatra.route'])
-
-                transaction.name = route
-              end
-            end
-
-            def compile_template(engine, data, opts, *args, &block)
-              opts[:__atatus_template_name] =
-                case data
-                when Symbol then data.to_s
-                else format('Inline %s', engine)
-                end
+      # @api private
+      module Ext
+        def dispatch!(*args, &block)
+          super(*args, &block).tap do
+            next unless (transaction = Atatus.current_transaction)
+            next unless (route = env['sinatra.route'])
+
+            transaction.name = route
+          end
+        end
 
-              compile_template_without_apm(engine, data, opts, *args, &block)
+        def compile_template(engine, data, opts, *args, &block)
+          opts[:__atatus_template_name] =
+            case data
+            when Symbol then data.to_s
+            else format('Inline %s', engine)
             end
-          end
 
+          super(engine, data, opts, *args, &block)
         end
       end
+
+      def install
+        ::Sinatra::Base.prepend(Ext)
+      end
     end
 
     register 'Sinatra::Base', 'sinatra/base', SinatraSpy.new
-
     require 'atatus/spies/tilt'
   end
 end

data/lib/atatus/spies/sneakers.rb

@@ -57,11 +57,13 @@ module Atatus
 
           res = @app.call(deserialized_msg, delivery_info, metadata, handler)
           transaction&.done(:success)
+          transaction&.outcome = Transaction::Outcome::SUCCESS
 
           res
         rescue ::Exception => e
           Atatus.report(e, handled: false)
           transaction&.done(:error)
+          transaction&.outcome = Transaction::Outcome::FAILURE
           raise
         ensure
           Atatus.end_transaction

data/lib/atatus/spies/sns.rb

@@ -0,0 +1,126 @@
+# 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 SNSSpy
+      TYPE = 'messaging'
+      SUBTYPE = 'sns'
+      AP_REGEX = /:accesspoint[\/:].*/
+      AP_REGION_REGEX = /^(?:[^:]+:){3}([^:]+).*/
+
+      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.get_topic(params)
+        return '[PHONENUMBER]' if params[:phone_number]
+
+        last_after_slash_or_colon(
+          params[:topic_arn] || params[:target_arn]
+        )
+      end
+
+      def self.last_after_slash_or_colon(arn)
+        if index = arn.rindex(AP_REGEX)
+          return arn[index+1..-1]
+        end
+
+        if arn.include?('/')
+          arn.split('/')[-1]
+        else
+          arn.split(':')[-1]
+        end
+      end
+
+      def self.arn_region(arn)
+        if arn && (match = AP_REGION_REGEX.match(arn))
+          match[1]
+        end
+      end
+
+      def self.span_context(topic, region)
+        Atatus::Span::Context.new(
+          message: { queue_name: topic },
+          destination: {
+            service: { resource: "#{SUBTYPE}/#{topic}" },
+            cloud: { region: region }
+          }
+        )
+      end
+
+      # @api private
+      module Ext
+        def publish(params = {}, options = {})
+          unless (transaction = Atatus.current_transaction)
+            return super(params, options)
+          end
+
+          topic = Atatus::Spies::SNSSpy.get_topic(params)
+          span_name = topic ? "SNS PUBLISH to #{topic}" : 'SNS PUBLISH'
+          region = Atatus::Spies::SNSSpy.arn_region(
+            params[:topic_arn] || params[:target_arn]
+          )
+          context = Atatus::Spies::SNSSpy.span_context(
+            topic,
+            region || config.region
+          )
+
+          Atatus.with_span(
+            span_name,
+            TYPE,
+            subtype: SUBTYPE,
+            action: 'publish',
+            context: context
+          ) do |span|
+            trace_context = span&.trace_context || transaction.trace_context
+            trace_context.apply_headers do |key, value|
+              params[:message_attributes] ||= {}
+              params[:message_attributes][key] ||= {}
+              params[:message_attributes][key][:string_value] = value
+              params[:message_attributes][key][:data_type] = 'String'
+            end
+
+            Atatus::Spies::SNSSpy.without_net_http do
+              super(params, options)
+            end
+          end
+        end
+      end
+
+      def install
+        ::Aws::SNS::Client.prepend(Ext)
+      end
+    end
+
+    register(
+      'Aws::SNS::Client',
+      'aws-sdk-sns',
+      SNSSpy.new
+    )
+  end
+end