elastic-apm 3.15.1 → 4.2.0

data/lib/elastic_apm/metadata/system_info.rb

@@ -24,7 +24,8 @@ module ElasticAPM
       def initialize(config)
         @config = config
 
-        @hostname = @config.hostname || self.class.system_hostname
+        @configured_hostname = @config.hostname
+        @detected_hostname = detect_hostname
         @architecture = gem_platform.cpu
         @platform = gem_platform.os
 
@@ -33,14 +34,23 @@ module ElasticAPM
         @kubernetes = container_info.kubernetes
       end
 
-      attr_reader :hostname, :architecture, :platform, :container, :kubernetes
+      attr_reader(
+        :detected_hostname,
+        :configured_hostname,
+        :architecture,
+        :platform,
+        :container,
+        :kubernetes
+      )
 
       def gem_platform
         @gem_platform ||= Gem::Platform.local
       end
 
-      def self.system_hostname
-        @system_hostname ||= `hostname`.chomp
+      private
+
+      def detect_hostname
+        `hostname`.chomp
       end
     end
   end

data/lib/elastic_apm/metrics/cpu_mem_set.rb

@@ -79,7 +79,7 @@ module ElasticAPM
         case platform
         when :linux then Linux.new
         else
-          warn "Unsupported platform '#{platform}' - Disabling system metrics"
+          warn "Disabling system metrics, unsupported platform '#{platform}'"
           disable!
           nil
         end

data/lib/elastic_apm/normalizers.rb

@@ -39,8 +39,8 @@ module ElasticAPM # :nodoc:
     end
 
     def self.build(config)
-      normalizers = @registered.each_with_object({}) do |(name, klass), built|
-        built[name] = klass.new(config)
+      normalizers = @registered.transform_values do |klass|
+        klass.new(config)
       end
 
       Collection.new(normalizers)

data/lib/elastic_apm/normalizers/rails/active_record.rb

@@ -17,7 +17,7 @@
 
 # frozen_string_literal: true
 
-require 'elastic_apm/sql'
+require 'elastic_apm/sql/signature'
 
 module ElasticAPM
   module Normalizers
@@ -34,7 +34,7 @@ module ElasticAPM
         def initialize(*args)
           super
 
-          @summarizer = Sql.summarizer
+          @summarizer = Sql::Signature::Summarizer.new
 
           @adapters = {}
         end
@@ -48,7 +48,7 @@ module ElasticAPM
           context =
             Span::Context.new(
               db: { statement: payload[:sql], type: 'sql' },
-              destination: { name: subtype, resource: subtype, type: TYPE }
+              destination: { service: { name: subtype, resource: subtype, type: TYPE } }
             )
 
           [name, TYPE, subtype, ACTION, context]

data/lib/elastic_apm/opentracing.rb

@@ -129,8 +129,9 @@ module ElasticAPM
       def self.from_header(header)
         return unless header
 
-        trace_context = ElasticAPM::TraceContext.parse(header)
-        return unless trace_context
+        trace_context = TraceContext.new(
+          traceparent: TraceContext::Traceparent.parse(header)
+        )
 
         trace_context.traceparent.id = trace_context.parent_id
         trace_context.traceparent.parent_id = nil

data/lib/elastic_apm/span.rb

@@ -106,6 +106,18 @@ module ElasticAPM
       @duration ||= (clock_end - @clock_start)
       @parent.child_stopped
       @self_time = @duration - child_durations.duration
+
+      if exit_span?
+        context.destination ||= Context::Destination.new
+        context.destination.service ||= Context::Destination::Service.new
+        context.destination.service.resource ||= (subtype || type)
+
+        # Deprecated fields but required by some versions of APM Server, so
+        # we auto-infer them from existing fields
+        context.destination.service.name ||= (subtype || type)
+        context.destination.service.type ||= type
+      end
+
       self
     end
 
@@ -131,12 +143,21 @@ module ElasticAPM
       started? && !stopped?
     end
 
-    # relations
+    def set_destination(address: nil, port: nil, service: nil, cloud: nil)
+      context.destination = Span::Context::Destination.new(
+        address: address,
+        port: port,
+        service: service,
+        cloud: cloud
+      )
+    end
 
     def inspect
       "<ElasticAPM::Span id:#{trace_context&.id}" \
         " name:#{name.inspect}" \
         " type:#{type.inspect}" \
+        " subtype:#{subtype.inspect}" \
+        " action:#{action.inspect}" \
         '>'
     end
 
@@ -159,5 +180,9 @@ module ElasticAPM
 
       duration >= min_duration
     end
+
+    def exit_span?
+      context.destination || context.db || context.message || context.http
+    end
   end
 end

data/lib/elastic_apm/span/context.rb

@@ -47,12 +47,13 @@ module ElasticAPM
 
       attr_reader(
         :db,
-        :destination,
         :http,
         :labels,
         :sync,
         :message
       )
+
+      attr_accessor :destination
     end
   end
 end

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

@@ -14,7 +14,7 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-
+#
 # frozen_string_literal: true
 
 module ElasticAPM
@@ -22,60 +22,53 @@ module ElasticAPM
     class Context
       # @api private
       class Destination
+        include Fields
+
+        field :address
+        field :port
+        field :service
+        field :cloud
 
         # @api private
-        class Cloud
-          def initialize(region: nil)
-            @region = region
-          end
+        class Service
+          include Fields
 
-          attr_accessor :region
+          field :name
+          field :type
+          field :resource
         end
 
-        def initialize(
-          name: nil,
-          resource: nil,
-          type: nil,
-          address: nil,
-          port: nil,
-          cloud: nil
-        )
-          @name = name
-          @resource = resource
-          @type = type
-          @address = address
-          @port = port
-          @cloud = cloud
+        # @api private
+        class Cloud
+          include Fields
+
+          field :region
         end
 
-        attr_reader(
-          :name,
-          :resource,
-          :type,
-          :address,
-          :port,
-          :cloud
-        )
+        def initialize(service: nil, cloud: nil, **attrs)
+          super(**attrs)
+
+          self.service = build_service(service)
+          self.cloud = build_cloud(cloud)
+        end
 
-        def self.from_uri(uri_or_str, type: 'external', port: nil)
+        def self.from_uri(uri_or_str, type: nil, **attrs)
           uri = normalize(uri_or_str)
 
+          service =
+            case type
+            when 'http' then http_service(uri)
+            else nil
+            end
+
           new(
-            name: only_scheme_and_host(uri),
-            resource: "#{uri.host}:#{uri.port}",
-            type: type,
             address: uri.hostname,
-            port: port || uri.port
+            port: uri.port,
+            service: service,
+            **attrs
           )
         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
 
@@ -83,6 +76,26 @@ module ElasticAPM
             return uri_or_str.dup if uri_or_str.is_a?(URI)
             URI(uri_or_str)
           end
+
+          def http_service(uri)
+            Service.new(resource: "#{uri.host}:#{uri.port}")
+          end
+        end
+
+        private
+
+        def build_cloud(cloud = nil)
+          return Cloud.new unless cloud
+          return cloud if cloud.is_a?(Cloud)
+
+          Cloud.new(**cloud)
+        end
+
+        def build_service(service = nil)
+          return Service.new unless service
+          return service if service.is_a?(Service)
+
+          Service.new(**service)
         end
       end
     end

data/lib/elastic_apm/span_helpers.rb

@@ -36,19 +36,17 @@ module ElasticAPM
         name ||= method.to_s
         type ||= Span::DEFAULT_TYPE
 
-        klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          alias :"__without_apm_#{method}" :"#{method}"
-
-          def #{method}(*args, &block)
+        klass.prepend(Module.new do
+          define_method(method) do |*args, &block|
             unless ElasticAPM.current_transaction
-              return __without_apm_#{method}(*args, &block)
+              return super(*args, &block)
             end
 
-            ElasticAPM.with_span "#{name}", "#{type}" do
-              __without_apm_#{method}(*args, &block)
+            ElasticAPM.with_span name.to_s, type.to_s do
+              super(*args, &block)
             end
           end
-        RUBY
+        end)
       end
     end
 

data/lib/elastic_apm/spies.rb

@@ -56,6 +56,26 @@ module ElasticAPM
       end
     end
 
+    def self.without_faraday
+      return yield unless defined?(FaradaySpy)
+
+      # rubocop:disable Style/ExplicitBlockArgument
+      ElasticAPM::Spies::FaradaySpy.disable_in do
+        yield
+      end
+      # rubocop:enable Style/ExplicitBlockArgument
+    end
+
+    def self.without_net_http
+      return yield unless defined?(NetHTTPSpy)
+
+      # rubocop:disable Style/ExplicitBlockArgument
+      ElasticAPM::Spies::NetHTTPSpy.disable_in do
+        yield
+      end
+      # rubocop:enable Style/ExplicitBlockArgument
+    end
+
     def self.register_require_hook(registration)
       registration.require_paths.each do |path|
         require_hooks[path] = registration

data/lib/elastic_apm/spies/action_dispatch.rb

@@ -22,18 +22,19 @@ module ElasticAPM
   module Spies
     # @api private
     class ActionDispatchSpy
-      def install
-        ::ActionDispatch::ShowExceptions.class_eval do
-          alias render_exception_without_apm render_exception
-
-          def render_exception(env, exception)
-            context = ElasticAPM.build_context(rack_env: env, for_type: :error)
-            ElasticAPM.report(exception, context: context, handled: false)
+      # @api private
+      module Ext
+        def render_exception(env, exception)
+          context = ElasticAPM.build_context(rack_env: env, for_type: :error)
+          ElasticAPM.report(exception, context: context, handled: false)
 
-            render_exception_without_apm env, exception
-          end
+          super(env, exception)
         end
       end
+
+      def install
+        ::ActionDispatch::ShowExceptions.prepend(Ext)
+      end
     end
 
     register(

data/lib/elastic_apm/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 ElasticAPM
+  # @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 = ElasticAPM::Span::Context::Destination.from_uri(service.storage_service_host[:primary])
+            destination.service.resource = "#{SUBTYPE}/#{account_name}"
+
+            context = ElasticAPM::Span::Context.new(destination: destination)
+
+            ElasticAPM.with_span(span_name, TYPE, subtype: SUBTYPE, action: action, context: context) do
+              ElasticAPM::Spies.without_faraday do
+                ElasticAPM::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 = ElasticAPM.current_transaction)
+              return super(table_name, *args)
+            end
+
+            ElasticAPM::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 = ElasticAPM.current_transaction)
+            return super(*args)
+          end
+
+          ElasticAPM::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