atatus 1.7.0 → 2.0.0

data/lib/atatus/metadata/cloud_info.rb

@@ -0,0 +1,156 @@
+# 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
+
+require "http"
+
+module Atatus
+  class Metadata
+    # @api private
+    class CloudInfo
+      include Logging
+
+      AWS_URI = "http://169.254.169.254/latest/dynamic/instance-identity/document"
+      GCP_URI = "http://metadata.google.internal/computeMetadata/v1/?recursive=true"
+      AZURE_URI = "http://169.254.169.254/metadata/instance/compute?api-version=2019-08-15"
+
+      def initialize(config)
+        @config = config
+        @client = HTTP.timeout(connect: 0.1, read: 0.1)
+      end
+
+      attr_reader :config
+
+      attr_accessor(
+        :account_id,
+        :account_name,
+        :instance_id,
+        :instance_name,
+        :machine_type,
+        :project_id,
+        :project_name,
+        :availability_zone,
+        :provider,
+        :region
+      )
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def fetch!
+        case config.cloud_provider
+        when "aws"
+          fetch_aws
+        when "gcp"
+          fetch_gcp
+        when "azure"
+          fetch_azure || read_azure_app_services
+        when "auto"
+          fetch_aws || fetch_gcp || fetch_azure || read_azure_app_services
+        when "none"
+          nil
+        else
+          error("Unknown setting for cloud_provider '#{config.cloud_provider}'")
+        end
+
+        self
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      private
+
+      def fetch_aws
+        resp = @client.get(AWS_URI)
+
+        return unless resp.status == 200
+        return unless (metadata = JSON.parse(resp.body.to_s))
+
+        self.provider = "aws"
+        self.account_id = metadata["accountId"]
+        self.instance_id = metadata["instanceId"]
+        self.availability_zone = metadata["availabilityZone"]
+        self.machine_type = metadata["instanceType"]
+        self.region = metadata["region"]
+      rescue HTTP::TimeoutError, HTTP::ConnectionError
+        nil
+      end
+
+      def fetch_gcp
+        resp = @client.headers("Metadata-Flavor" => "Google").get(GCP_URI)
+
+        return unless resp.status == 200
+        return unless (metadata = JSON.parse(resp.body.to_s))
+
+        zone = metadata["instance"]["zone"]&.split("/")&.at(-1)
+
+        self.provider = "gcp"
+        self.instance_id = metadata["instance"]["id"].to_s
+        self.instance_name = metadata["instance"]["name"]
+        self.project_id = metadata["project"]["projectId"]
+        self.availability_zone = zone
+        self.region = zone.split("-")[0..-2].join("-")
+        self.machine_type = metadata["instance"]["machineType"].split("/")[-1]
+      rescue HTTP::TimeoutError, HTTP::ConnectionError
+        nil
+      end
+
+      def fetch_azure
+        resp = @client.headers("Metadata" => "true").get(AZURE_URI)
+
+        return unless resp.status == 200
+        return unless (metadata = JSON.parse(resp.body.to_s))
+
+        self.provider = 'azure'
+        self.account_id = metadata["subscriptionId"]
+        self.instance_id = metadata["vmId"]
+        self.instance_name = metadata["name"]
+        self.project_name = metadata["resourceGroupName"]
+        self.availability_zone = metadata["zone"]
+        self.machine_type = metadata["vmSize"]
+        self.region = metadata["location"]
+      rescue HTTP::TimeoutError, HTTP::ConnectionError
+        nil
+      end
+
+      def read_azure_app_services
+        owner_name, instance_id, site_name, resource_group =
+          ENV.values_at(
+            'WEBSITE_OWNER_NAME',
+            'WEBSITE_INSTANCE_ID',
+            'WEBSITE_SITE_NAME',
+            'WEBSITE_RESOURCE_GROUP'
+          )
+
+        return unless owner_name && instance_id && site_name && resource_group
+
+        self.provider = 'azure'
+        self.instance_id = instance_id
+        self.instance_name = site_name
+        self.project_name = resource_group
+        self.account_id, self.region = parse_azure_app_services_owner_name(owner_name)
+      end
+
+      private
+
+      def parse_azure_app_services_owner_name(owner_name)
+        id, rest = owner_name.split('+')
+        *_, region = rest.split('-')
+        region.gsub!(/webspace.*$/, '')
+        [id, region]
+      end
+    end
+  end
+end

data/lib/atatus/metadata/service_info.rb

@@ -49,11 +49,11 @@ module Atatus
         )
         @language = Language.new(name: 'ruby', version: RUBY_VERSION)
         @runtime = lookup_runtime
-        @version = @config.service_version || Util.git_sha
+        @version = @config.service_version
       end
 
-      attr_reader :name, :node_name, :environment, :agent, :framework, :language,
-        :runtime, :version
+      attr_reader :name, :node_name, :environment, :agent, :framework,
+        :language, :runtime, :version
 
       private
 

data/lib/atatus/metadata/system_info/container_info.rb

@@ -33,14 +33,15 @@ module Atatus
 
         attr_reader :cgroup_path
 
-        def read!
+        def read!(hostname)
           read_from_cgroup!
+          self.kubernetes_pod_name = hostname if kubernetes_pod_uid
           read_from_env!
           self
         end
 
-        def self.read!
-          new.read!
+        def self.read!(hostname)
+          new.read!(hostname)
         end
 
         def container
@@ -81,15 +82,23 @@ module Atatus
             ENV.fetch('KUBERNETES_POD_UID', kubernetes_pod_uid)
         end
 
+        # rubocop:disable Style/RegexpLiteral
         CONTAINER_ID_REGEXES = [
           %r{^[[:xdigit:]]{64}$},
-          %r{^[[:xdigit:]]{8}-[[:xdigit:]]{4}-[[:xdigit:]]{4}-[[:xdigit:]]{4}-[[:xdigit:]]{4,}$}
-        ]
+          %r{
+            ^[[:xdigit:]]{8}-[[:xdigit:]]{4}-[[:xdigit:]]
+            {4}-[[:xdigit:]]{4}-[[:xdigit:]]{4,}$
+          }x
+        ].freeze
         KUBEPODS_REGEXES = [
           %r{(?:^/kubepods[^\s]*/pod([^/]+)$)},
-          %r{(?:^/kubepods\.slice/kubepods-[^/]+\.slice/kubepods-[^/]+-pod([^/]+)\.slice$)}
-        ]
+          %r{
+            (?:^/kubepods\.slice/(kubepods-[^/]+\.slice/)?
+             kubepods[^/]*-pod([^/]+)\.slice$)
+          }x
+        ].freeze
         SYSTEMD_SCOPE_SUFFIX = '.scope'
+        # rubocop:enable Style/RegexpLiteral
 
         # rubocop:disable Metrics/PerceivedComplexity
         # rubocop:disable Metrics/CyclomaticComplexity
@@ -125,7 +134,10 @@ module Atatus
             end
 
             if (kubepods_match = match_kubepods(directory))
-              pod_id = kubepods_match[1] || kubepods_match[2]
+              unless (pod_id = kubepods_match[1])
+                pod_id = kubepods_match[2]
+                pod_id&.tr!('_', '-')
+              end
 
               self.container_id = container_id
               self.kubernetes_pod_uid = pod_id

data/lib/atatus/metadata/system_info.rb

@@ -24,11 +24,13 @@ module Atatus
       def initialize(config)
         @config = config
 
-        @hostname = @config.hostname || self.class.system_hostname
+        @configured_hostname = @config.hostname
+        @detected_hostname = detect_hostname
+        @hostname = @configured_hostname || @detected_hostname
         @architecture = gem_platform.cpu
         @platform = gem_platform.os
 
-        container_info = ContainerInfo.read!
+        container_info = ContainerInfo.read!(@detected_hostname)
         @container = container_info.container
         @kubernetes = container_info.kubernetes
 
@@ -36,14 +38,27 @@ module Atatus
         @osinfo = OSInfo.read!
       end
 
-      attr_reader :hostname, :architecture, :platform, :container, :kubernetes, :hwinfo, :osinfo
+      attr_reader(
+        :detected_hostname,
+        :configured_hostname,
+        :architecture,
+        :platform,
+        :container,
+        :kubernetes,
+        :hwinfo,
+        :osinfo,
+        :hostname
+      )
 
       def gem_platform
         @gem_platform ||= Gem::Platform.local
       end
 
-      def self.system_hostname
-        @system_hostname ||= `hostname`.chomp
+      private
+
+      def detect_hostname
+        Socket.gethostname.chomp
+      rescue
       end
     end
   end

data/lib/atatus/metadata.rb

@@ -25,12 +25,14 @@ module Atatus
       @process = ProcessInfo.new(config)
       @system = SystemInfo.new(config)
       @labels = config.global_labels
+      @cloud = CloudInfo.new(config).fetch!
     end
 
-    attr_reader :service, :process, :system, :labels
+    attr_reader :service, :process, :system, :cloud, :labels
   end
 end
 
 require 'atatus/metadata/service_info'
 require 'atatus/metadata/system_info'
 require 'atatus/metadata/process_info'
+require 'atatus/metadata/cloud_info'

data/lib/atatus/metrics/cpu_mem_set.rb

@@ -60,11 +60,10 @@ module Atatus
       end
 
       def initialize(config)
-        @vmset_disabled = false
         super
 
-        @sampler = sampler_for_platform(Metrics.platform)
-        read! # set @previous on boot
+        @sampler = sampler_for_os(Metrics.os)
+        read! # set initial values to calculate deltas from
       end
 
       attr_reader :config
@@ -76,19 +75,11 @@ module Atatus
 
       private
 
-      def vmset_disable!
-        @vmset_disabled = true
-      end
-
-      def vmset_disabled?
-        @vmset_disabled
-      end
-
-      def sampler_for_platform(platform)
-        case platform
-        when :linux then Linux.new
+      def sampler_for_os(os)
+        case os
+        when /^linux/ then Linux.new
         else
-          warn "Unsupported platform '#{platform}' - Disabling system metrics"
+          warn "Disabling system metrics, unsupported host OS '#{os}'"
           disable!
           nil
         end
@@ -115,29 +106,6 @@ module Atatus
           current.process_memory_rss * current.page_size
 
         @previous = current
-
-        return if vmset_disabled?
-
-        stat = GC.stat
-
-        gauge(:'ruby.gc.count').value = stat[:count]
-        gauge(:'ruby.threads').value = Thread.list.count
-        gauge(:'ruby.heap.slots.live').value = stat[:heap_live_slots]
-
-        gauge(:'ruby.heap.slots.free').value = stat[:heap_free_slots]
-        gauge(:'ruby.heap.allocations.total').value =
-          stat[:total_allocated_objects]
-
-        return unless GC::Profiler.enabled?
-        @total_time ||= 0
-        @total_time += GC::Profiler.total_time
-        GC::Profiler.clear
-        gauge(:'ruby.gc.time').value = @total_time
-      rescue TypeError => e
-        error 'VM metrics encountered error: %s', e
-        debug('Backtrace:') { e.backtrace.join("\n") }
-
-        vmset_disable!
       end
 
       def calculate_deltas(current, previous)
@@ -148,6 +116,9 @@ module Atatus
         process_cpu_usage =
           current.process_cpu_usage - previous.process_cpu_usage
 
+        # No change / avoid dividing by 0
+        return [0, 0] if system_cpu_total == 0
+
         cpu_usage_pct = system_cpu_usage.to_f / system_cpu_total
         cpu_process_pct = process_cpu_usage.to_f / system_cpu_total
 
@@ -246,6 +217,7 @@ module Atatus
         # @api private
         class Meminfo
           attr_reader :total, :available, :page_size
+
           # rubocop:disable Metrics/PerceivedComplexity
           # rubocop:disable Metrics/CyclomaticComplexity
           def read!

data/lib/atatus/metrics/jvm_set.rb

@@ -0,0 +1,88 @@
+# 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
+
+require 'java'
+
+module Atatus
+  module Metrics
+    # @api private
+    class JVMSet < Set
+      include Logging
+
+      MAX_TRIES = 3
+
+      def initialize(*args)
+        super
+
+        @error_count = 0
+      end
+
+      def collect
+        read!
+        super
+      end
+
+      def read!
+        return if disabled?
+
+        heap = platform_bean.get_heap_memory_usage
+        non_heap = platform_bean.get_non_heap_memory_usage
+
+        gauge(:"jvm.memory.heap.used").value = heap.get_used
+        gauge(:"jvm.memory.heap.committed").value = heap.get_committed
+        gauge(:"jvm.memory.heap.max").value = heap.get_max
+
+        gauge(:"jvm.memory.non_heap.used").value = non_heap.get_used
+        gauge(:"jvm.memory.non_heap.committed").value = non_heap.get_committed
+        gauge(:"jvm.memory.non_heap.max").value = non_heap.get_max
+
+        pool_beans.each do |bean|
+          next unless bean.type.name == "HEAP"
+
+          tags = { name: bean.get_name }
+
+          gauge(:"jvm.memory.heap.pool.used", tags: tags).value = bean.get_usage.get_used
+          gauge(:"jvm.memory.heap.pool.committed", tags: tags).value = bean.get_usage.get_committed
+          gauge(:"jvm.memory.heap.pool.max", tags: tags).value = bean.get_usage.get_max
+        end
+      rescue Exception => e
+        error("JVM metrics encountered error: %s", e)
+        debug("Backtrace:") { e.backtrace.join("\n") }
+
+        @error_count += 1
+        if @error_count >= MAX_TRIES
+          disable!
+          error("Disabling JVM metrics after #{MAX_TRIES} errors", e)
+        end
+      end
+
+      private
+
+      def platform_bean
+        @platform_bean ||= java.lang.management.ManagementFactory.getPlatformMXBean(
+          java.lang.management.MemoryMXBean.java_class
+        )
+      end
+
+      def pool_beans
+        @pool_beans ||= java.lang.management.ManagementFactory.getMemoryPoolMXBeans()
+      end
+    end
+  end
+end

data/lib/atatus/metrics/metric.rb

@@ -57,6 +57,8 @@ module Atatus
         @mutex.synchronize do
           collected = @value
 
+          return nil if collected.is_a?(Float) && !collected.finite?
+
           @value = initial_value if reset_on_collect?
 
           return nil if reset_on_collect? && collected == 0

data/lib/atatus/metrics.rb

@@ -28,44 +28,38 @@ module Atatus
       @platform ||= Gem::Platform.local.os.to_sym
     end
 
+    def self.os
+      @os ||= RbConfig::CONFIG.fetch('host_os', 'unknown').to_sym
+    end
+
     # @api private
     class Registry
       include Logging
 
-      TIMEOUT_INTERVAL = 5 # seconds
-
       def initialize(config, &block)
         @config = config
         @callback = block
+        @sets = nil
       end
 
       attr_reader :config, :sets, :callback
+
       def start
         unless config.collect_metrics?
           debug 'Skipping metrics'
           return
         end
 
-        debug 'Starting metrics'
+        define_sets
 
-        # Only set the @sets once, in case we stop
-        # and start again.
-        @sets ||= {
-          system: CpuMemSet,
-          # vm: VMSet,
-          breakdown: BreakdownSet,
-          transaction: TransactionSet
-        }.each_with_object({}) do |(key, kls), sets|
-          debug "Adding metrics collector '#{kls}'"
-          sets[key] = kls.new(config)
-        end
+        debug 'Starting metrics'
 
         @timer_task = Concurrent::TimerTask.execute(
           run_now: true,
-          execution_interval: config.metrics_interval,
-          timeout_interval: TIMEOUT_INTERVAL
+          execution_interval: config.metrics_interval
         ) do
           begin
+            debug 'Collecting metrics'
             collect_and_send
             true
           rescue StandardError => e
@@ -123,6 +117,28 @@ module Atatus
           arr.concat(samples)
         end
       end
+
+      def define_sets
+        # Only set the @sets once, in case we stop
+        # and start again.
+        return unless @sets.nil?
+
+        sets = {
+          system: CpuMemSet,
+          vm: VMSet,
+          breakdown: BreakdownSet,
+          transaction: TransactionSet
+        }
+        if defined?(JVMSet)
+          debug "Enabling JVM metrics collection"
+          sets[:jvm] = JVMSet
+        end
+
+        @sets = sets.each_with_object({}) do |(key, kls), _sets_|
+          debug "Adding metrics collector '#{kls}'"
+          _sets_[key] = kls.new(config)
+        end
+      end
     end
   end
 end
@@ -134,6 +150,7 @@ require 'atatus/metrics/set'
 
 require 'atatus/metrics/cpu_mem_set'
 require 'atatus/metrics/vm_set'
+require 'atatus/metrics/jvm_set' if defined?(JRUBY_VERSION)
 require 'atatus/metrics/span_scoped_set'
 require 'atatus/metrics/transaction_set'
 require 'atatus/metrics/breakdown_set'

data/lib/atatus/middleware.rb

@@ -41,9 +41,14 @@ module Atatus
         Atatus.report(e, context: context, handled: false)
         raise
       ensure
-        if resp && transaction
-          status, headers, _body = resp
-          transaction.add_response(status, headers: headers.dup)
+        if transaction
+          if resp
+            status, headers, _body = resp
+            transaction.add_response(status, headers: headers.dup)
+            transaction&.outcome = Transaction::Outcome.from_http_status(status)
+          else
+            transaction&.outcome = Transaction::Outcome::FAILURE
+          end
         end
 
         Atatus.end_transaction http_result(status)

data/lib/atatus/naively_hashable.rb

@@ -18,6 +18,7 @@
 # frozen_string_literal: true
 
 module Atatus
+  # TODO: Remove this?
   # @api private
   module NaivelyHashable
     def naively_hashable?

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

@@ -17,7 +17,7 @@
 
 # frozen_string_literal: true
 
-require 'atatus/sql'
+require 'atatus/sql/signature'
 
 module Atatus
   module Normalizers
@@ -34,7 +34,7 @@ module Atatus
         def initialize(*args)
           super
 
-          @summarizer = Sql.summarizer
+          @summarizer = Sql::Signature::Summarizer.new
 
           @adapters = {}
         end
@@ -48,7 +48,7 @@ module Atatus
           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]
@@ -57,10 +57,21 @@ module Atatus
         private
 
         def subtype_for(payload)
-          cached_adapter_name(
-            payload[:connection]&.adapter_name ||
-              ::ActiveRecord::Base.connection_config[:adapter]
-          )
+          if payload[:connection]
+            return cached_adapter_name(payload[:connection].adapter_name)
+          end
+
+          if can_attempt_connection_id_lookup?(payload)
+            begin
+              loaded_object = ObjectSpace._id2ref(payload[:connection_id])
+              if loaded_object.respond_to?(:adapter_name)
+                return cached_adapter_name(loaded_object.adapter_name)
+              end
+            rescue RangeError # if connection object has somehow been garbage collected
+            end
+          end
+
+          cached_adapter_name(::ActiveRecord::Base.connection_config[:adapter])
         end
 
         def summarize(sql)
@@ -69,11 +80,18 @@ module Atatus
 
         def cached_adapter_name(adapter_name)
           return UNKNOWN if adapter_name.nil? || adapter_name.empty?
+
           @adapters[adapter_name] ||
             (@adapters[adapter_name] = adapter_name.downcase)
         rescue StandardError
           nil
         end
+
+        def can_attempt_connection_id_lookup?(payload)
+          RUBY_ENGINE == "ruby" &&
+            payload[:connection_id] &&
+            ObjectSpace.respond_to?(:_id2ref)
+        end
       end
     end
   end

data/lib/atatus/normalizers.rb

@@ -39,8 +39,8 @@ module Atatus # :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)