atatus 1.0.0

data/lib/atatus/metrics/cpu_mem.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Atatus
+  module Metrics
+    # @api private
+    class CpuMem
+      include Logging
+
+      # @api private
+      class Sample
+        # rubocop:disable Metrics/ParameterLists
+        def initialize(
+          system_cpu_total:,
+          system_cpu_usage:,
+          system_memory_total:,
+          system_memory_free:,
+          process_cpu_usage:,
+          process_memory_size:,
+          process_memory_rss:,
+          page_size:
+        )
+          @system_cpu_total = system_cpu_total
+          @system_cpu_usage = system_cpu_usage
+          @system_memory_total = system_memory_total
+          @system_memory_free = system_memory_free
+          @process_cpu_usage = process_cpu_usage
+          @process_memory_size = process_memory_size
+          @process_memory_rss = process_memory_rss
+          @page_size = page_size
+        end
+        # rubocop:enable Metrics/ParameterLists
+
+        attr_accessor :system_cpu_total, :system_cpu_usage,
+          :system_memory_total, :system_memory_free, :process_cpu_usage,
+          :process_memory_size, :process_memory_rss, :page_size
+
+        def delta(previous)
+          dup.tap do |sample|
+            sample.system_cpu_total =
+              system_cpu_total - previous.system_cpu_total
+            sample.system_cpu_usage =
+              system_cpu_usage - previous.system_cpu_usage
+            sample.process_cpu_usage =
+              process_cpu_usage - previous.process_cpu_usage
+          end
+        end
+      end
+
+      def initialize(config)
+        @config = config
+        @sampler = sampler_for_platform(Metrics.platform)
+      end
+
+      attr_reader :config, :sampler
+
+      def sample
+        @sampler.sample
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def collect
+        return unless sampler
+
+        current = sample
+
+        unless @previous
+          @previous = current
+          return
+        end
+
+        delta = current.delta(@previous)
+
+        cpu_usage_pct = delta.system_cpu_usage.to_f / delta.system_cpu_total
+        cpu_process_pct = delta.process_cpu_usage.to_f / delta.system_cpu_total
+
+        @previous = current
+
+        {
+          'system.cpu.total.norm.pct': cpu_usage_pct,
+          'system.memory.actual.free': current.system_memory_free,
+          'system.memory.total': current.system_memory_total,
+          'system.process.cpu.total.norm.pct': cpu_process_pct,
+          'system.process.memory.size': current.process_memory_size,
+          'system.process.memory.rss.bytes':
+            current.process_memory_rss * current.page_size
+        }
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+      private
+
+      def sampler_for_platform(platform)
+        case platform
+        when :linux then Linux.new
+        else
+          warn "Unsupported platform '#{platform}' - Disabling metrics"
+          @disabled = true
+          nil
+        end
+      end
+
+      # @api private
+      class Linux
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def sample
+          proc_stat = ProcStat.new.read!
+          proc_self_stat = ProcSelfStat.new.read!
+          meminfo = Meminfo.new.read!
+
+          Sample.new(
+            system_cpu_total: proc_stat.total,
+            system_cpu_usage: proc_stat.usage,
+            system_memory_total: meminfo.total,
+            system_memory_free: meminfo.available,
+            process_cpu_usage: proc_self_stat.total,
+            process_memory_size: proc_self_stat.vsize,
+            process_memory_rss: proc_self_stat.rss,
+            page_size: meminfo.page_size
+          )
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+        # @api private
+        class ProcStat
+          attr_reader :total, :usage
+
+          CPU_FIELDS = %i[
+            user
+            nice
+            system
+            idle
+            iowait
+            irq
+            softirq
+            steal
+            guest
+            guest_nice
+          ].freeze
+
+          # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          def read!
+            stat =
+              IO.readlines('/proc/stat')
+                .lazy
+                .find { |sp| sp.start_with?('cpu ') }
+                .split
+                .map(&:to_i)[1..-1]
+
+            values =
+              CPU_FIELDS.each_with_index.each_with_object({}) do |(key, i), v|
+                v[key] = stat[i] || 0
+              end
+
+            @total =
+              values[:user] +
+              values[:nice] +
+              values[:system] +
+              values[:idle] +
+              values[:iowait] +
+              values[:irq] +
+              values[:softirq] +
+              values[:steal]
+
+            @usage = @total - (values[:idle] + values[:iowait])
+
+            self
+          end
+          # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+        end
+
+        UTIME_POS = 13
+        STIME_POS = 14
+        VSIZE_POS = 22
+        RSS_POS = 23
+
+        # @api private
+        class ProcSelfStat
+          attr_reader :total, :vsize, :rss
+
+          def read!
+            stat =
+              IO.readlines('/proc/self/stat')
+                .lazy
+                .first
+                .split
+                .map(&:to_i)
+
+            @total = stat[UTIME_POS] + stat[STIME_POS]
+            @vsize = stat[VSIZE_POS]
+            @rss = stat[RSS_POS]
+
+            self
+          end
+        end
+
+        # @api private
+        class Meminfo
+          attr_reader :total, :available, :page_size
+
+          # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          # rubocop:disable Metrics/PerceivedComplexity
+          # rubocop:disable Metrics/CyclomaticComplexity
+          def read!
+            # rubocop:disable Style/RescueModifier
+            @page_size = `getconf PAGESIZE`.chomp.to_i rescue 4096
+            # rubocop:enable Style/RescueModifier
+
+            info =
+              IO.readlines('/proc/meminfo')
+                .lazy
+                .each_with_object({}) do |line, hsh|
+                  if line.start_with?('MemTotal:')
+                    hsh[:total] = line.split[1].to_i * 1024
+                  elsif line.start_with?('MemAvailable:')
+                    hsh[:available] = line.split[1].to_i * 1024
+                  elsif line.start_with?('MemFree:')
+                    hsh[:free] = line.split[1].to_i * 1024
+                  elsif line.start_with?('Buffers:')
+                    hsh[:buffers] = line.split[1].to_i * 1024
+                  elsif line.start_with?('Cached:')
+                    hsh[:cached] = line.split[1].to_i * 1024
+                  end
+
+                  break hsh if hsh[:total] && hsh[:available]
+                end
+
+            @total = info[:total]
+            @available =
+              info[:available] || info[:free] + info[:buffers] + info[:cached]
+
+            self
+          end
+          # rubocop:enable Metrics/CyclomaticComplexity
+          # rubocop:enable Metrics/PerceivedComplexity
+          # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+        end
+      end
+    end
+  end
+end

data/lib/atatus/metrics/vm.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Atatus
+  module Metrics
+    # @api private
+    class VM
+      include Logging
+
+      def initialize(config)
+        @config = config
+        @total_time = 0
+        @disabled = false
+      end
+
+      attr_reader :config
+      attr_writer :disabled
+
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def collect
+        return if disabled?
+
+        stat = GC.stat
+        thread_count = Thread.list.count
+
+        sample = {
+          'ruby.gc.count': stat[:count],
+          'ruby.threads': thread_count
+        }
+
+        (live_slots = stat[:heap_live_slots]) &&
+          sample[:'ruby.heap.slots.live'] = live_slots
+        (heap_slots = stat[:heap_free_slots]) &&
+          sample[:'ruby.heap.slots.free'] = heap_slots
+        (allocated = stat[:total_allocated_objects]) &&
+          sample[:'ruby.heap.allocations.total'] = allocated
+
+        return sample unless GC::Profiler.enabled?
+
+        @total_time += GC::Profiler.total_time
+        GC::Profiler.clear
+        sample[:'ruby.gc.time'] = @total_time
+
+        sample
+      rescue TypeError => e
+        error 'VM metrics encountered error: %s', e
+        debug('Backtrace:') { e.backtrace.join("\n") }
+
+        @disabled = true
+        nil
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+      def disabled?
+        @disabled
+      end
+    end
+  end
+end

data/lib/atatus/metricset.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  class Metricset
+    def initialize(timestamp: Util.micros, labels: nil, **samples)
+      @timestamp = timestamp
+      @labels = labels
+      @samples = samples
+    end
+
+    attr_accessor :timestamp
+    attr_reader :samples, :labels
+
+    def empty?
+      samples.empty?
+    end
+  end
+end

data/lib/atatus/middleware.rb

@@ -0,0 +1,76 @@
+#
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  class Middleware
+    include Logging
+
+    def initialize(app)
+      @app = app
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def call(env)
+      begin
+        if running? && !path_ignored?(env)
+          transaction = start_transaction(env)
+        end
+
+        resp = @app.call env
+      rescue InternalError
+        raise # Don't report Atatus errors
+      rescue ::Exception => e
+        context = Atatus.build_context(rack_env: env, for_type: :error)
+        Atatus.report(e, context: context, handled: false)
+        raise
+      ensure
+        if resp && transaction
+          status, headers, _body = resp
+          transaction.add_response(status, headers: headers.dup)
+        end
+
+        Atatus.end_transaction http_result(status)
+      end
+
+      resp
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    private
+
+    def http_result(status)
+      status && "HTTP #{status.to_s[0]}xx"
+    end
+
+    def path_ignored?(env)
+      config.ignore_url_patterns.any? do |r|
+        env['PATH_INFO'].match r
+      end
+    end
+
+    def start_transaction(env)
+      context = Atatus.build_context(rack_env: env, for_type: :transaction)
+
+      Atatus.start_transaction 'Rack', 'request',
+        context: context,
+        trace_context: trace_context(env)
+    end
+
+    def trace_context(env)
+      return unless (header = env['HTTP_ATATUS_APM_TRACEPARENT'])
+      TraceContext.parse(header)
+    rescue TraceContext::InvalidTraceparentHeader
+      warn "Couldn't parse invalid traceparent header: #{header.inspect}"
+      nil
+    end
+
+    def running?
+      Atatus.running?
+    end
+
+    def config
+      @config ||= Atatus.agent.config
+    end
+  end
+end

data/lib/atatus/naively_hashable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  module NaivelyHashable
+    def naively_hashable?
+      true
+    end
+
+    def to_h
+      instance_variables.each_with_object({}) do |name, h|
+        key = name.to_s.delete('@').to_sym
+        value = instance_variable_get(name)
+        is_hashable =
+          value.respond_to?(:naively_hashable?) && value.naively_hashable?
+
+        h[key] = is_hashable ? value.to_h : value
+      end
+    end
+  end
+end

data/lib/atatus/normalizers.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Atatus # :nodoc:
+  # @api private
+  module Normalizers
+    # @api privagte
+    class Normalizer
+      def initialize(config)
+        @config = config
+      end
+
+      def self.register(name)
+        Normalizers.register(name, self)
+      end
+    end
+
+    def self.register(name, klass)
+      @registered ||= {}
+      @registered[name] = klass
+    end
+
+    def self.build(config)
+      normalizers = @registered.each_with_object({}) do |(name, klass), built|
+        built[name] = klass.new(config)
+      end
+
+      Collection.new(normalizers)
+    end
+
+    # @api private
+    class Collection
+      # @api private
+      class SkipNormalizer
+        def initialize; end
+
+        def normalize(*_args)
+          :skip
+        end
+      end
+
+      def initialize(normalizers)
+        @normalizers = normalizers
+        @default = SkipNormalizer.new
+      end
+
+      def for(name)
+        @normalizers.fetch(name) { @default }
+      end
+
+      def keys
+        @normalizers.keys
+      end
+
+      def normalize(transaction, name, payload)
+        self.for(name).normalize(transaction, name, payload)
+      end
+    end
+  end
+
+  %w[
+    action_controller
+    action_mailer
+    action_view
+    active_record
+  ].each do |lib|
+    require "atatus/normalizers/#{lib}"
+  end
+end