atatus 1.0.0

data/lib/atatus/metadata.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Atatus
+  # @api private
+  class Metadata
+    def initialize(config)
+      @service = ServiceInfo.new(config)
+      @process = ProcessInfo.new(config)
+      @system = SystemInfo.new(config)
+      @labels = config.global_labels
+    end
+
+    attr_reader :service, :process, :system, :labels
+  end
+end
+
+require 'atatus/metadata/service_info'
+require 'atatus/metadata/system_info'
+require 'atatus/metadata/process_info'

data/lib/atatus/metadata/process_info.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Atatus
+  class Metadata
+    # @api private
+    class ProcessInfo
+      def initialize(config)
+        @config = config
+
+        @argv = ARGV
+        @pid = $PID || Process.pid
+        @title = $PROGRAM_NAME
+      end
+
+      attr_reader :argv, :pid, :title
+    end
+  end
+end

data/lib/atatus/metadata/service_info.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Atatus
+  class Metadata
+    # @api private
+    class ServiceInfo
+      # @api private
+      class Versioned
+        def initialize(name: nil, version: nil)
+          @name = name
+          @version = version
+        end
+
+        attr_reader :name, :version
+      end
+      class Agent < Versioned; end
+      class Framework < Versioned; end
+      class Language < Versioned; end
+      class Runtime < Versioned; end
+
+      # rubocop:disable Metrics/MethodLength
+      def initialize(config)
+        @config = config
+
+        @name = @config.service_name
+        @environment = @config.environment
+        @agent = Agent.new(name: 'ruby', version: VERSION)
+        @framework = Framework.new(
+          name: @config.framework_name,
+          version: @config.framework_version
+        )
+        @language = Language.new(name: 'ruby', version: RUBY_VERSION)
+        @runtime = lookup_runtime
+        @version = @config.service_version || Util.git_sha
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      attr_reader :name, :environment, :agent, :framework, :language, :runtime,
+        :version
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def lookup_runtime
+        case RUBY_ENGINE
+        when 'ruby'
+          Runtime.new(
+            name: RUBY_ENGINE,
+            version: RUBY_VERSION || RUBY_ENGINE_VERSION
+          )
+        when 'jruby'
+          Runtime.new(
+            name: RUBY_ENGINE,
+            version: JRUBY_VERSION || RUBY_ENGINE_VERSION
+          )
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/atatus/metadata/system_info.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Atatus
+  class Metadata
+    # @api private
+    class SystemInfo
+      def initialize(config)
+        @config = config
+
+        @hostname = @config.hostname || `hostname`.chomp
+        @architecture = gem_platform.cpu
+        @platform = gem_platform.os
+
+        container_info = ContainerInfo.read!
+        @container = container_info.container
+        @kubernetes = container_info.kubernetes
+
+        @hwinfo = HWInfo.read!
+        @osinfo = OSInfo.read!
+      end
+
+      attr_reader :hostname, :architecture, :platform, :container, :kubernetes, :hwinfo, :osinfo
+
+      private
+
+      def gem_platform
+        @gem_platform ||= Gem::Platform.local
+      end
+    end
+  end
+end
+
+require 'atatus/metadata/system_info/container_info'
+require 'atatus/metadata/system_info/hw_info'
+require 'atatus/metadata/system_info/os_info'

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Atatus
+  class Metadata
+    class SystemInfo
+      # @api private
+      class ContainerInfo
+        CGROUP_PATH = '/proc/self/cgroup'
+
+        attr_accessor :container_id, :kubernetes_namespace,
+          :kubernetes_node_name, :kubernetes_pod_name, :kubernetes_pod_uid
+
+        def initialize(cgroup_path: CGROUP_PATH)
+          @cgroup_path = cgroup_path
+        end
+
+        attr_reader :cgroup_path
+
+        def read!
+          read_from_cgroup!
+          read_from_env!
+          self
+        end
+
+        def self.read!
+          new.read!
+        end
+
+        def container
+          @container ||=
+            begin
+              return unless container_id
+              { id: container_id }
+            end
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def kubernetes
+          @kubernetes =
+            begin
+              kubernetes = {
+                namespace: kubernetes_namespace,
+                node: { name: kubernetes_node_name },
+                pod: {
+                  name: kubernetes_pod_name,
+                  uid: kubernetes_pod_uid
+                }
+              }
+              return nil if kubernetes.values.all?(&:nil?)
+
+              kubernetes
+            end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        private
+
+        def read_from_env!
+          self.kubernetes_namespace =
+            ENV.fetch('KUBERNETES_NAMESPACE', kubernetes_namespace)
+          self.kubernetes_node_name =
+            ENV.fetch('KUBERNETES_NODE_NAME', kubernetes_node_name)
+          self.kubernetes_pod_name =
+            ENV.fetch('KUBERNETES_POD_NAME', kubernetes_pod_name)
+          self.kubernetes_pod_uid =
+            ENV.fetch('KUBERNETES_POD_UID', kubernetes_pod_uid)
+        end
+
+        CONTAINER_ID_REGEX = /^[0-9A-Fa-f]{64}$/.freeze
+        KUBEPODS_REGEX = %r{(?:^/kubepods/[^/]+/pod([^/]+)$)|(?:^/kubepods\.slice/kubepods-[^/]+\.slice/kubepods-[^/]+-pod([^/]+)\.slice$)}.freeze # rubocop:disable Metrics/LineLength
+        SYSTEMD_SCOPE_SUFFIX = '.scope'
+
+        # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize
+        def read_from_cgroup!
+          return unless File.exist?(cgroup_path)
+          IO.readlines(cgroup_path).each do |line|
+            parts = line.strip.split(':')
+            next if parts.length != 3
+
+            cgroup_path = parts[2]
+
+            # Depending on the filesystem driver used for cgroup
+            # management, the paths in /proc/pid/cgroup will have
+            # one of the following formats in a Docker container:
+            #
+            #   systemd: /system.slice/docker-<container-ID>.scope
+            #   cgroupfs: /docker/<container-ID>
+            #
+            # In a Kubernetes pod, the cgroup path will look like:
+            #
+            #   systemd:
+            #      /kubepods.slice/kubepods-<QoS-class>.slice/kubepods-\
+            #        <QoS-class>-pod<pod-UID>.slice/<container-iD>.scope
+            #   cgroupfs:
+            #      /kubepods/<QoS-class>/pod<pod-UID>/<container-iD>
+            directory, container_id = File.split(cgroup_path)
+
+            if container_id.end_with?(SYSTEMD_SCOPE_SUFFIX)
+              container_id = container_id[0...-SYSTEMD_SCOPE_SUFFIX.length]
+              if container_id.include?('-')
+                container_id = container_id.split('-', 2)[1]
+              end
+            end
+
+            if (kubepods_match = KUBEPODS_REGEX.match(directory))
+              pod_id = kubepods_match[1] || kubepods_match[2]
+
+              self.container_id = container_id
+              self.kubernetes_pod_uid = pod_id
+            elsif CONTAINER_ID_REGEX.match(container_id)
+              self.container_id = container_id
+            end
+          end
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+require 'rbconfig'
+require 'socket'
+
+module Atatus
+  class Metadata
+    class SystemInfo
+      # @api private
+      class HWInfo
+        attr_accessor :cpuinfo_cores, :cpuinfo_model, :cpuinfo_mhz,
+        :meminfo_total, :host_bootid
+
+        def initialize
+          @os = RbConfig::CONFIG['target_os']
+        end
+
+        def read!
+          if @os =~ /(linux)/i
+            read_from_cpuinfo!
+            read_from_meminfo!
+            read_from_bootid!
+          elsif @os =~ /(darwin)/i
+            read_cpuinfo_from_sysctl!
+            read_meminfo_from_sysctl!
+          end
+          self
+        end
+
+        def self.read!
+          new.read!
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def cpuinfo
+          @cpuinfo ||=
+            begin
+              cpuinfo = {
+                cores: @cpuinfo_cores,
+                model: @cpuinfo_model
+              }
+              cpuinfo[:mhz] = @cpuinfo_mhz unless @cpuinfo_mhz.nil?
+
+              cpuinfo
+            end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        def meminfo
+          @meminfo ||= @meminfo_total
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def hostid
+          @hostid ||=
+            begin
+              return Socket.gethostname if @host_bootid.nil?
+              @host_bootid
+            end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        private
+
+        def get_sysctl_value(key)
+          `sysctl -n #{key} 2>/dev/null`
+        end
+
+        LINUX_CPUINFO_PATH = '/proc/cpuinfo'.freeze
+        PROCESSOR_COUNT_REGEX = /^processor\s*:/.freeze
+        MODEL_NAME_REGEX = /model name.+:(.+)/.freeze
+        CPU_MHZ_REGEX = /cpu MHz\s+:\s+([0-9.]+)/.freeze
+
+        LINUX_MEMINFO_PATH = '/proc/meminfo'.freeze
+        TOTAL_MEMORY_REGEX = /^MemTotal:\s+(\d+)\skB$/.freeze
+
+        LINUX_BOOTID_PATH = '/proc/sys/kernel/random/boot_id'.freeze
+
+        # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize
+        def read_from_cpuinfo!
+          return unless File.exist?(LINUX_CPUINFO_PATH)
+          cpuinfo = File.read(LINUX_CPUINFO_PATH)
+          self.cpuinfo_cores = cpuinfo.scan(PROCESSOR_COUNT_REGEX).size
+          self.cpuinfo_model = cpuinfo.scan(MODEL_NAME_REGEX).flatten.first.strip
+          self.cpuinfo_mhz = cpuinfo.scan(CPU_MHZ_REGEX).flatten.first
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize
+
+        # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize
+        def read_from_meminfo!
+          return unless File.exist?(LINUX_MEMINFO_PATH)
+          meminfo = File.read(LINUX_MEMINFO_PATH)
+          self.meminfo_total = meminfo.scan(TOTAL_MEMORY_REGEX).flatten.first.to_i
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize
+
+        def read_from_bootid!
+          return unless File.exist?(LINUX_BOOTID_PATH)
+          self.host_bootid = File.read(LINUX_BOOTID_PATH)
+          self.host_bootid.strip!
+        end
+
+        def read_cpuinfo_from_sysctl!
+          self.cpuinfo_cores = get_sysctl_value('hw.logicalcpu_max').to_i
+          self.cpuinfo_model = get_sysctl_value('machdep.cpu.brand_string').strip
+        end
+
+        def read_meminfo_from_sysctl!
+          self.meminfo_total = get_sysctl_value('hw.memsize').to_i
+          self.meminfo_total
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Atatus
+  class Metadata
+    class SystemInfo
+      # @api private
+      class OSInfo
+        attr_accessor :os, :kernel
+
+        def initialize
+        end
+
+        def read!
+          read_from_uname!
+          self
+        end
+
+        def self.read!
+          new.read!
+        end
+
+        private
+
+        def read_from_uname!
+          self.os = `uname -s`.strip.downcase!
+          self.kernel = `uname -r`.strip
+        end
+      end
+    end
+  end
+end

data/lib/atatus/metrics.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'atatus/metricset'
+
+module Atatus
+  # @api private
+  module Metrics
+    MUTEX = Mutex.new
+
+    def self.new(config, &block)
+      Collector.new(config, &block)
+    end
+
+    def self.platform
+      @platform ||= Gem::Platform.local.os.to_sym
+    end
+
+    # @api private
+    class Collector
+      include Logging
+
+      TIMEOUT_INTERVAL = 5 # seconds
+
+      def initialize(config, labels: nil, &block)
+        @config = config
+        @labels = labels
+        @samplers = [CpuMem, VM].map do |kls|
+          debug "Adding metrics collector '#{kls}'"
+          kls.new(config)
+        end
+        @callback = block
+      end
+
+      attr_reader :config, :samplers, :callback, :labels
+
+      # rubocop:disable Metrics/MethodLength
+      def start
+        unless config.collect_metrics?
+          debug 'Skipping metrics'
+          return
+        end
+
+        debug 'Starting metrics'
+
+        @timer_task = Concurrent::TimerTask.execute(
+          run_now: true,
+          execution_interval: config.metrics_interval,
+          timeout_interval: TIMEOUT_INTERVAL
+        ) do
+          begin
+            debug 'Collecting metrics'
+            collect_and_send
+            true
+          rescue StandardError => e
+            error 'Error while collecting metrics: %e', e.inspect
+            debug { e.backtrace.join("\n") }
+            false
+          end
+        end
+
+        @running = true
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def stop
+        return unless running?
+
+        debug 'Stopping metrics'
+
+        @timer_task.shutdown
+        @running = false
+      end
+
+      def running?
+        !!@running
+      end
+
+      def collect_and_send
+        metricset = Metricset.new(labels: labels, **collect)
+        return if metricset.empty?
+
+        callback.call(metricset)
+      end
+
+      def collect
+        MUTEX.synchronize do
+          samplers.each_with_object({}) do |sampler, samples|
+            next unless (sample = sampler.collect)
+            samples.merge!(sample)
+          end
+        end
+      end
+    end
+  end
+end
+
+require 'atatus/metrics/cpu_mem'
+require 'atatus/metrics/vm'