atatus 1.7.0 → 2.0.0

data/lib/atatus/spies/azure_storage_table.rb

@@ -0,0 +1,148 @@
+# 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 AzureStorageTableSpy
+      TYPE = "storage"
+      SUBTYPE = "azuretable"
+
+      module Helpers
+        class << self
+          def instrument(operation_name, table_name = nil, service:)
+            span_name = span_name(operation_name, table_name)
+            action = formatted_op_name(operation_name)
+            account_name = account_name_from_storage_table_host(service.storage_service_host[:primary])
+
+            destination = Atatus::Span::Context::Destination.from_uri(service.storage_service_host[:primary])
+            destination.service.resource = "#{SUBTYPE}/#{account_name}"
+
+            context = Atatus::Span::Context.new(destination: destination)
+
+            Atatus.with_span(span_name, TYPE, subtype: SUBTYPE, action: action, context: context) do
+              Atatus::Spies.without_faraday do
+                Atatus::Spies.without_net_http do
+                  yield
+                end
+              end
+            end
+          end
+
+          private
+
+          DEFAULT_OP_NAMES = {
+            "create_table" => "Create",
+            "delete_table" => "Delete",
+            "get_table_acl" => "GetAcl",
+            "set_table_acl" => "SetAcl",
+            "insert_entity" => "Insert",
+            "query_entities" => "Query",
+            "update_entity" => "Update",
+            "merge_entity" => "Merge",
+            "delete_entity" => "Delete"
+          }.freeze
+
+          def formatted_op_names
+            @formatted_op_names ||= Concurrent::Map.new
+          end
+
+          def account_names
+            @account_names ||= Concurrent::Map.new
+          end
+
+          def span_name(operation_name, table_name = nil)
+            base = "AzureTable #{formatted_op_name(operation_name)}"
+
+            return base unless table_name
+
+            "#{base} #{table_name}"
+          end
+
+          def formatted_op_name(operation_name)
+            formatted_op_names.compute_if_absent(operation_name) do
+              DEFAULT_OP_NAMES.fetch(operation_name) do
+                operation_name.to_s.split("_").collect(&:capitalize).join
+              end
+            end
+          end
+
+          def account_name_from_storage_table_host(host)
+            account_names.compute_if_absent(host) do
+              URI(host).host.split(".").first || "unknown"
+            end
+          rescue Exception
+            "unknown"
+          end
+        end
+      end
+
+      # @api private
+      module Ext
+        # Methods with table_name as first parameter
+        %i[
+          create_table
+          delete_table
+          get_table
+          get_table_acl
+          set_table_acl
+          insert_entity
+          query_entities
+          update_entity
+          merge_entity
+          delete_entity
+        ].each do |method_name|
+          define_method(method_name) do |table_name, *args|
+            unless (transaction = Atatus.current_transaction)
+              return super(table_name, *args)
+            end
+
+            Atatus::Spies::AzureStorageTableSpy::Helpers.instrument(
+              method_name.to_s, table_name, service: self
+            ) do
+              super(table_name, *args)
+            end
+          end
+        end
+
+        # Methods WITHOUT table_name as first parameter
+        def query_tables(*args)
+          unless (transaction = Atatus.current_transaction)
+            return super(*args)
+          end
+
+          Atatus::Spies::AzureStorageTableSpy::Helpers.instrument("query_tables", service: self) do
+            super(*args)
+          end
+        end
+      end
+
+      def install
+        ::Azure::Storage::Table::TableService.prepend(Ext)
+      end
+    end
+
+    register(
+      "Azure::Storage::Table::TableService",
+      "azure/storage/table",
+      AzureStorageTableSpy.new
+    )
+  end
+end

data/lib/atatus/spies/delayed_job.rb

@@ -27,39 +27,45 @@ module Atatus
       TYPE = 'Delayed::Job'
 
       def install
-        if defined?(::Delayed) && defined?(::Delayed::Backend) && defined?(::Delayed::Backend::Base)
+        ::Delayed::Backend::Base.class_eval do
+          alias invoke_job_without_apm invoke_job
 
-          ::Delayed::Backend::Base.class_eval do
-            alias invoke_job_without_apm invoke_job
-
-            def invoke_job(*args, &block)
-              ::Atatus::Spies::DelayedJobSpy
-                .invoke_job(self, *args, &block)
-            end
+          def invoke_job(*args, &block)
+            ::Atatus::Spies::DelayedJobSpy
+              .invoke_job(self, *args, &block)
           end
-
         end
       end
 
       def self.invoke_job(job, *args, &block)
-        job_name = name_from_payload(job.payload_object)
+        job_name = job_name(job)
         transaction = Atatus.start_transaction(job_name, TYPE)
         job.invoke_job_without_apm(*args, &block)
-        transaction.done 'success'
+        transaction&.done 'success'
+        transaction&.outcome = Transaction::Outcome::SUCCESS
       rescue ::Exception => e
         Atatus.report(e, handled: false)
-        transaction.done 'error'
+        transaction&.done 'error'
+        transaction&.outcome = Transaction::Outcome::FAILURE
         raise
       ensure
         Atatus.end_transaction
       end
 
-      def self.name_from_payload(payload_object)
+      def self.job_name(job)
+        payload_object = job.payload_object
+
         if payload_object.is_a?(::Delayed::PerformableMethod)
           performable_method_name(payload_object)
+        elsif payload_object.instance_of?(
+          ActiveJob::QueueAdapters::DelayedJobAdapter::JobWrapper
+        )
+          payload_object.job_data['job_class']
         else
           payload_object.class.name
         end
+      rescue
+        job.name
       end
 
       def self.performable_method_name(payload_object)

data/lib/atatus/spies/dynamo_db.rb

@@ -22,35 +22,76 @@ module Atatus
   module Spies
     # @api private
     class DynamoDBSpy
+      TYPE = 'db'
+      SUBTYPE = 'dynamodb'
+      ACTION = 'query'
+
+      @@formatted_op_names = Concurrent::Map.new
+
       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 install
-        if defined?(::Aws) && defined?(::Aws::DynamoDB) && defined?(::Aws::DynamoDB::Client)
-
-          ::Aws::DynamoDB::Client.class_eval do
-            # Alias all available operations
-            api.operation_names.each do |operation_name|
-              alias :"#{operation_name}_without_apm" :"#{operation_name}"
-
-              define_method(operation_name) do |params = {}, options = {}|
-                Atatus.with_span(operation_name, 'db', subtype: 'dynamodb', action: operation_name) do
-                  Atatus::Spies::DynamoDBSpy.without_net_http do
-                    original_method = method("#{operation_name}_without_apm")
-                    original_method.call(params, options)
-                  end
+      def self.span_name(operation_name, params)
+        params[:table_name] ?
+          "DynamoDB #{formatted_op_name(operation_name)} #{params[:table_name]}" :
+          "DynamoDB #{formatted_op_name(operation_name)}"
+      end
+
+      def self.formatted_op_name(operation_name)
+        @@formatted_op_names.compute_if_absent(operation_name) do
+          operation_name.to_s.split('_').collect(&:capitalize).join
+        end
+      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 = {}|
+              context = Atatus::Span::Context.new(
+                db: {
+                  instance: config.region,
+                  type: SUBTYPE,
+                  statement: params[:key_condition_expression]
+                },
+                destination: {
+                  address: config.endpoint.host,
+                  port: config.endpoint.port,
+                  service: {
+                      name: SUBTYPE,
+                      type: TYPE,
+                      resource: SUBTYPE },
+                  cloud: { region: config.region }
+                }
+              )
+
+              Atatus.with_span(
+                Atatus::Spies::DynamoDBSpy.span_name(operation_name, params),
+                TYPE,
+                subtype: SUBTYPE,
+                action: ACTION,
+                context: context
+              ) do
+                Atatus::Spies::DynamoDBSpy.without_net_http do
+                  super(params, options)
                 end
               end
             end
           end
-
         end
       end
+
+      def install
+        ::Aws::DynamoDB::Client.prepend(Ext)
+      end
     end
 
     register(

data/lib/atatus/spies/elasticsearch.rb

@@ -27,53 +27,62 @@ module Atatus
       SUBTYPE = 'elasticsearch'
 
       def self.sanitizer
-        @sanitizer ||= Atatus::Transport::Filters::HashSanitizer.new
+        @sanitizer ||=
+          begin
+            config = Atatus.agent.config
+            Atatus::Transport::Filters::HashSanitizer.new(
+              key_patterns: config.custom_key_filters +
+                            config.sanitize_field_names
+            )
+          end
       end
 
-      def install
-        if defined?(::Elasticsearch) &&
-            defined?(::Elasticsearch::Transport) &&
-            defined?(::Elasticsearch::Transport::Client)
-
-          ::Elasticsearch::Transport::Client.class_eval do
-            alias perform_request_without_apm perform_request
-
-            def perform_request(method, path, *args, &block)
-              unless Atatus.current_transaction
-                return perform_request_without_apm(method, path, *args, &block)
-              end
-
-              name = format(NAME_FORMAT, method, path)
-              statement = []
-
-              statement << { params: args&.[](0) }
+      # @api private
+      module Ext
+        def perform_request(method, path, *args, &block)
+          unless Atatus.current_transaction
+            return super(method, path, *args, &block)
+          end
 
-              if Atatus.agent.config.capture_elasticsearch_queries
-                unless args[1].nil? || args[1].empty?
-                  statement << {
-                    body: Atatus::Spies::ElasticsearchSpy.sanitizer.strip_from!(args[1])
-                  }
-                end
-              end
+          name = format(NAME_FORMAT, method, path)
+          statement = []
 
-              context = Span::Context.new(
-                db: { statement: statement.reduce({}, :merge).to_json },
-                destination: {
-                  name: SUBTYPE,
-                  resource: SUBTYPE,
-                  type: TYPE
-                }
-              )
+          statement << { params: args&.[](0) }
 
-              Atatus.with_span(
-                name,
-                TYPE,
-                subtype: SUBTYPE,
-                context: context
-              ) { perform_request_without_apm(method, path, *args, &block) }
+          if Atatus.agent.config.capture_elasticsearch_queries
+            unless args[1].nil? || args[1].empty?
+              body =
+                Atatus::Spies::ElasticsearchSpy
+                .sanitizer.strip_from(args[1])
+              statement << { body: body }
             end
           end
 
+          context = Span::Context.new(
+            db: { statement: statement.reduce({}, :merge).to_json },
+            destination: {
+              service: {
+                name: SUBTYPE,
+                resource: SUBTYPE,
+                type: TYPE
+              }
+            }
+          )
+
+          Atatus.with_span(
+            name,
+            TYPE,
+            subtype: SUBTYPE,
+            context: context
+          ) { super(method, path, *args, &block) }
+        end
+      end
+
+      def install
+        if defined?(::Elastic::Transport::Client)
+          ::Elastic::Transport::Client.prepend(Ext)
+        elsif defined?(::Elasticsearch::Transport::Client)
+          ::Elasticsearch::Transport::Client.prepend(Ext)
         end
       end
     end
@@ -83,5 +92,11 @@ module Atatus
       'elasticsearch-transport',
       ElasticsearchSpy.new
     )
+
+    register(
+      'Elastic::Transport::Client',
+      'elastic-transport',
+      ElasticsearchSpy.new
+    )
   end
 end

data/lib/atatus/spies/faraday.rb

@@ -22,84 +22,118 @@ module Atatus
   module Spies
     # @api private
     class FaradaySpy
-      TYPE = 'ext'
-      SUBTYPE = 'faraday'
+      DISABLE_KEY = :__atatus_faraday_disabled
+      TYPE = 'external'
+      SUBTYPE = 'http'
 
-      def self.without_net_http
-        return yield unless defined?(NetHTTPSpy)
-
-        Atatus::Spies::NetHTTPSpy.disable_in do
-          yield
+      class << self
+        def disabled=(disabled)
+          Thread.current[DISABLE_KEY] = disabled
         end
-      end
-
-      # rubocop:disable Metrics/CyclomaticComplexity
-      def install
-        if defined?(::Faraday) && defined?(::Faraday::Connection)
 
-          ::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
+        def disabled?
+          Thread.current[DISABLE_KEY] ||= false
+        end
 
-              uri = URI(build_url(url))
+        def disable_in
+          self.disabled = true
 
-              # If url is set inside block it isn't available until yield,
-              # so we temporarily build the request to yield. This could be a
-              # problem if the block has side effects as it will be yielded twice
-              # ~mikker
-              unless uri.host
-                tmp_request = build_request(method) do |req|
-                  yield(req) if block_given?
-                end
-                uri = URI(tmp_request.path)
-              end
+          begin
+            yield
+          ensure
+            self.disabled = false
+          end
+        end
+      end
 
-              host = uri.host
+      # @api private
+      module Ext
+        # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+        def run_request(method, url, body, headers, &block)
+          unless (transaction = Atatus.current_transaction)
+            return super(method, url, body, headers, &block)
+          end
 
-              upcased_method = method.to_s.upcase
+          if Atatus::Spies::FaradaySpy.disabled?
+            return super(method, url, body, headers, &block)
+          end
 
-              destination = Atatus::Span::Context::Destination.from_uri(uri)
+          uri = URI(build_url(url))
 
-              context =
-                Atatus::Span::Context.new(
-                  http: { url: uri, method: upcased_method },
-                  destination: destination
-                )
+          # If url is set inside block it isn't available until yield,
+          # so we temporarily build the request to yield. This could be a
+          # problem if the block has side effects as it will be yielded twice
+          # ~mikker
+          unless uri.host
+            tmp_request = build_request(method) do |req|
+              yield(req) if block_given?
+            end
+            uri = tmp_request.path && URI(tmp_request.path)
+          end
 
-              Atatus.with_span(
-                "#{upcased_method} #{host}",
-                TYPE,
-                subtype: SUBTYPE,
-                action: upcased_method,
-                context: context
-              ) do |span|
-                Atatus::Spies::FaradaySpy.without_net_http do
-                  trace_context = span&.trace_context || transaction.trace_context
+          host = uri&.host || 'localhost'
 
-                  result =
-                    run_request_without_apm(method, url, body, headers) do |req|
-                      trace_context.apply_headers { |k, v| req[k] = v }
+          upcased_method = method.to_s.upcase
 
-                      yield req if block_given?
-                    end
+          if uri
+            destination = Atatus::Span::Context::Destination.from_uri(uri, type: SUBTYPE)
 
-                  if (http = span&.context&.http)
-                    http.status_code = result.status.to_s
-                  end
+            context =
+              Atatus::Span::Context.new(
+                http: { url: uri, method: upcased_method },
+                destination: destination
+              )
+          else
+            context =
+              Atatus::Span::Context.new(http: { url: uri, method: upcased_method })
+          end
 
-                  result
+          context =
+            Atatus::Span::Context.new(
+              http: { url: uri, method: upcased_method },
+              destination: destination
+            )
+
+          Atatus.with_span(
+            "#{upcased_method} #{host}",
+            TYPE,
+            subtype: SUBTYPE,
+            context: context
+          ) do |span|
+            Atatus::Spies.without_net_http do
+              trace_context = span&.trace_context || transaction.trace_context
+
+              begin
+                result = super(method, url, body, headers) do |req|
+                  trace_context.apply_headers { |k, v| req[k] = v }
+                  yield req if block
+                end
+              rescue Faraday::ClientError, Faraday::ServerError => e # Faraday::Response::RaiseError
+                status = e.response_status if e.respond_to?(:response_status)
+                status ||= e.response&.fetch(:status)
+                http = span&.context&.http
+                if http && status
+                  http.status_code = status.to_s
+                  span.outcome = Span::Outcome.from_http_status(status)
                 end
+                raise e
+              end
+
+              if (http = span&.context&.http)
+                http.status_code = result.status.to_s
               end
+
+              span&.outcome = Span::Outcome.from_http_status(result.status)
+              result
             end
           end
-
         end
       end
-      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+      def install
+        ::Faraday::Connection.prepend(Ext)
+      end
     end
 
     register 'Faraday', 'faraday', FaradaySpy.new

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