elastic-apm 3.3.0 → 3.4.0

data/lib/elastic_apm/span/context.rb

@@ -4,53 +4,35 @@ module ElasticAPM
   class Span
     # @api private
     class Context
-      def initialize(db: nil, http: nil, labels: {})
-        @sync = true
-        @db = db && Db.new(db)
-        @http = http && Http.new(http)
+      def initialize(
+        db: nil,
+        destination: nil,
+        http: nil,
+        labels: {},
+        sync: nil
+      )
+        @sync = sync
+        @db = db && Db.new(**db)
+        @http = http && Http.new(**http)
+        @destination =
+          case destination
+          when Destination then destination
+          when Hash then Destination.new(**destination)
+          end
         @labels = labels
       end
 
-      attr_accessor :sync, :db, :http, :labels
-
-      # @api private
-      class Db
-        def initialize(instance: nil, statement: nil, type: nil, user: nil)
-          @instance = instance
-          @statement = statement
-          @type = type
-          @user = user
-        end
-
-        attr_accessor :instance, :statement, :type, :user
-      end
-
-      # @api private
-      class Http
-        def initialize(url: nil, status_code: nil, method: nil)
-          @url = sanitize_url(url)
-          @status_code = status_code
-          @method = method
-        end
-
-        attr_accessor :url, :status_code, :method
-
-        private
-
-        def sanitize_url(url)
-          uri = URI(url)
-
-          return url unless uri.userinfo
-
-          format(
-            '%s://%s@%s%s',
-            uri.scheme,
-            uri.user,
-            uri.hostname,
-            uri.path
-          )
-        end
-      end
+      attr_reader(
+        :db,
+        :destination,
+        :http,
+        :labels,
+        :sync
+      )
     end
   end
 end
+
+require 'elastic_apm/span/context/db'
+require 'elastic_apm/span/context/http'
+require 'elastic_apm/span/context/destination'

data/lib/elastic_apm/span/context/db.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Span
+    class Context
+      # @api private
+      class Db
+        def initialize(instance: nil, statement: nil, type: nil, user: nil)
+          @instance = instance
+          @statement = statement
+          @type = type
+          @user = user
+        end
+
+        attr_accessor :instance, :statement, :type, :user
+      end
+    end
+  end
+end

data/lib/elastic_apm/span/context/destination.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Span
+    class Context
+      # @api private
+      class Destination
+        def initialize(name: nil, resource: nil, type: nil)
+          @name = name
+          @resource = resource
+          @type = type
+        end
+
+        attr_reader :name, :resource, :type
+
+        def self.from_uri(uri_or_str, type: 'external')
+          uri = normalize(uri_or_str)
+
+          new(
+            name: only_scheme_and_host(uri),
+            resource: "#{uri.host}:#{uri.port}",
+            type: type
+          )
+        end
+
+        def self.only_scheme_and_host(uri_or_str)
+          uri = normalize(uri_or_str)
+          uri.path = ''
+          uri.password = uri.query = uri.fragment = nil
+          uri.to_s
+        end
+
+        class << self
+          private
+
+          def normalize(uri_or_str)
+            return uri_or_str.dup if uri_or_str.is_a?(URI)
+            URI(uri_or_str)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/elastic_apm/span/context/http.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ElasticAPM
+  class Span
+    class Context
+      # @api private
+      class Http
+        def initialize(url: nil, status_code: nil, method: nil)
+          @url = sanitize_url(url)
+          @status_code = status_code
+          @method = method
+        end
+
+        attr_accessor :url, :status_code, :method
+
+        private
+
+        def sanitize_url(uri_or_str)
+          uri = uri_or_str.is_a?(URI) ? uri_or_str.dup : URI(uri_or_str)
+          uri.password = nil
+          uri.to_s
+        end
+      end
+    end
+  end
+end

data/lib/elastic_apm/spies/elasticsearch.rb

@@ -6,7 +6,9 @@ module ElasticAPM
     # @api private
     class ElasticsearchSpy
       NAME_FORMAT = '%s %s'
-      TYPE = 'db.elasticsearch'
+      TYPE = 'db'
+      SUBTYPE = 'elasticsearch'
+
       def install
         ::Elasticsearch::Transport::Client.class_eval do
           alias perform_request_without_apm perform_request
@@ -14,11 +16,22 @@ module ElasticAPM
           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 })
 
-            ElasticAPM.with_span name, TYPE, context: context do
-              perform_request_without_apm(method, path, *args, &block)
-            end
+            context = Span::Context.new(
+              db: { statement: statement },
+              destination: {
+                name: SUBTYPE,
+                resource: SUBTYPE,
+                type: TYPE
+              }
+            )
+
+            ElasticAPM.with_span(
+              name,
+              TYPE,
+              subtype: SUBTYPE,
+              context: context
+            ) { perform_request_without_apm(method, path, *args, &block) }
           end
         end
       end

data/lib/elastic_apm/spies/faraday.rb

@@ -16,7 +16,6 @@ module ElasticAPM
         end
       end
 
-      # rubocop:disable Metrics/PerceivedComplexity
       # rubocop:disable Metrics/CyclomaticComplexity
       def install
         ::Faraday::Connection.class_eval do
@@ -27,40 +26,59 @@ module ElasticAPM
               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
+            uri = URI(build_url(url))
 
-            name = "#{method.upcase} #{host}"
+            # 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
+
+            host = uri.host
+
+            upcased_method = method.to_s.upcase
+
+            destination = ElasticAPM::Span::Context::Destination.from_uri(uri)
+
+            context =
+              ElasticAPM::Span::Context.new(
+                http: { url: uri, method: upcased_method },
+                destination: destination
+              )
 
             ElasticAPM.with_span(
-              name,
+              "#{upcased_method} #{host}",
               TYPE,
               subtype: SUBTYPE,
-              action: method.to_s
+              action: upcased_method,
+              context: context
             ) do |span|
               ElasticAPM::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['Elastic-Apm-Traceparent'] = trace_context.to_header
+                result =
+                  run_request_without_apm(method, url, body, headers) do |req|
+                    req['Elastic-Apm-Traceparent'] = trace_context.to_header
 
-                  yield req if block_given?
+                    yield req if block_given?
+                  end
+
+                if (http = span&.context&.http)
+                  http.status_code = result.status.to_s
                 end
+
+                result
               end
             end
           end
         end
       end
       # rubocop:enable Metrics/CyclomaticComplexity
-      # rubocop:enable Metrics/PerceivedComplexity
     end
 
     register 'Faraday', 'faraday', FaradaySpy.new

data/lib/elastic_apm/spies/http.rb

@@ -19,17 +19,31 @@ module ElasticAPM
             method = req.verb.to_s.upcase
             host = req.uri.host
 
+            destination =
+              ElasticAPM::Span::Context::Destination.from_uri(req.uri)
+            context = ElasticAPM::Span::Context.new(
+              http: { url: req.uri, method: method },
+              destination: destination
+            )
+
             name = "#{method} #{host}"
 
             ElasticAPM.with_span(
               name,
               TYPE,
               subtype: SUBTYPE,
-              action: method
+              action: method,
+              context: context
             ) do |span|
               trace_context = span&.trace_context || transaction.trace_context
               req['Elastic-Apm-Traceparent'] = trace_context.to_header
-              perform_without_apm(req, options)
+              result = perform_without_apm(req, options)
+
+              if (http = span&.context&.http)
+                http.status_code = result.status.to_s
+              end
+
+              result
             end
           end
         end

data/lib/elastic_apm/spies/mongo.rb

@@ -81,6 +81,11 @@ module ElasticAPM
               statement: event.command.to_s,
               type: 'mongodb',
               user: nil
+            },
+            destination: {
+              name: SUBTYPE,
+              resource: SUBTYPE,
+              type: TYPE
             }
           )
         end

data/lib/elastic_apm/spies/net_http.rb

@@ -8,6 +8,7 @@ module ElasticAPM
       KEY = :__elastic_apm_net_http_disabled
       TYPE = 'ext'
       SUBTYPE = 'net_http'
+
       class << self
         def disabled=(disabled)
           Thread.current[KEY] = disabled
@@ -28,6 +29,7 @@ module ElasticAPM
         end
       end
 
+      # rubocop:disable Metrics/CyclomaticComplexity
       def install
         Net::HTTP.class_eval do
           alias request_without_apm request
@@ -36,30 +38,48 @@ module ElasticAPM
             unless (transaction = ElasticAPM.current_transaction)
               return request_without_apm(req, body, &block)
             end
+
             if ElasticAPM::Spies::NetHTTPSpy.disabled?
               return request_without_apm(req, body, &block)
             end
 
-            host, = req['host']&.split(':')
-            method = req.method
+            host = req['host']&.split(':')&.first || address
+            method = req.method.to_s.upcase
+            path, query = req.path.split('?')
+
+            cls = use_ssl? ? URI::HTTPS : URI::HTTP
+            uri = cls.build([nil, host, port, path, query, nil])
 
-            host ||= address
+            destination =
+              ElasticAPM::Span::Context::Destination.from_uri(uri)
 
-            name = "#{method} #{host}"
+            context =
+              ElasticAPM::Span::Context.new(
+                http: { url: uri, method: method },
+                destination: destination
+              )
 
             ElasticAPM.with_span(
-              name,
+              "#{method} #{host}",
               TYPE,
               subtype: SUBTYPE,
-              action: method.to_s
+              action: method,
+              context: context
             ) do |span|
               trace_context = span&.trace_context || transaction.trace_context
               req['Elastic-Apm-Traceparent'] = trace_context.to_header
-              request_without_apm(req, body, &block)
+              result = request_without_apm(req, body, &block)
+
+              if (http = span&.context&.http)
+                http.status_code = result.code
+              end
+
+              result
             end
           end
         end
       end
+      # rubocop:enable Metrics/CyclomaticComplexity
     end
 
     register 'Net::HTTP', 'net/http', NetHTTPSpy.new

data/lib/elastic_apm/spies/sequel.rb

@@ -1,22 +1,17 @@
 # frozen_string_literal: true
 
-require 'elastic_apm/sql_summarizer'
+require 'elastic_apm/sql'
 
 module ElasticAPM
   # @api private
   module Spies
     # @api private
     class SequelSpy
-      TYPE = 'db.sequel.sql'
+      TYPE = 'db'
+      ACTION = 'query'
 
       def self.summarizer
-        @summarizer ||= SqlSummarizer.new
-      end
-
-      def self.build_context(sql, opts)
-        Span::Context.new(
-          db: { statement: sql, type: 'sql', user: opts[:user] }
-        )
+        @summarizer = Sql.summarizer
       end
 
       def install
@@ -25,16 +20,31 @@ module ElasticAPM
         ::Sequel::Database.class_eval do
           alias log_connection_yield_without_apm log_connection_yield
 
-          def log_connection_yield(sql, *args, &block)
+          def log_connection_yield(sql, connection, args = nil, &block)
             unless ElasticAPM.current_transaction
-              return log_connection_yield_without_apm(sql, *args, &block)
+              return log_connection_yield_without_apm(
+                sql, connection, args, &block
+              )
             end
 
-            summarizer = ElasticAPM::Spies::SequelSpy.summarizer
-            name = summarizer.summarize sql
-            context = ElasticAPM::Spies::SequelSpy.build_context(sql, opts)
+            subtype = database_type.to_s
+
+            name =
+              ElasticAPM::Spies::SequelSpy.summarizer.summarize sql
+
+            context = ElasticAPM::Span::Context.new(
+              db: { statement: sql, type: 'sql', user: opts[:user] },
+              destination: { name: subtype, resource: subtype, type: TYPE }
+            )
 
-            ElasticAPM.with_span(name, TYPE, context: context, &block)
+            ElasticAPM.with_span(
+              name,
+              TYPE,
+              subtype: subtype,
+              action: ACTION,
+              context: context,
+              &block
+            )
           end
         end
       end