metrux 1.0.0

data/lib/metrux/config_builders/yaml.rb

@@ -0,0 +1,64 @@
+module Metrux
+  module ConfigBuilders
+    class Yaml
+      FileLoadError = Class.new(ConfigurationError)
+      EnvironmentNotFoundError = Class.new(FileLoadError)
+
+      def initialize(config_path, env)
+        @config_path = config_path
+        @env = env
+      end
+
+      def build
+        file_exists? ? yaml_content : null_content
+      end
+
+      private
+
+      attr_reader :config_path, :env
+
+      def file_exists?
+        File.exist?(config_path)
+      end
+
+      def null_content
+        {}
+      end
+
+      def yaml_content
+        from_environment(load_file(config_path)).with_indifferent_access
+      end
+
+      def load_file(config_path)
+        content = File.read(config_path)
+        template = ERB.new(content)
+        YAML.load(template.result)
+      rescue => e
+        raise(FileLoadError, "#{e.class}: #{e.message}")
+      end
+
+      def from_environment(config_content)
+        config_content.fetch(env)
+      rescue KeyError => e
+        if env == default_environment
+          raise(EnvironmentNotFoundError, "#{e.class}: #{e.message}")
+        end
+
+        warn_environment_change
+        @env = default_environment
+        retry
+      end
+
+      def default_environment
+        Configuration::DEFAULT_ENVIRONMENT
+      end
+
+      def warn_environment_change
+        Kernel.warn(
+          "[WARNING] Metrux's configuration wasn't found for environment "\
+          "\"#{env}\". Switching to default: \"#{default_environment}\"."
+        )
+      end
+    end
+  end
+end

data/lib/metrux/configuration.rb

@@ -0,0 +1,52 @@
+module Metrux
+  class Configuration
+    DEFAULT_ENVIRONMENT = 'development'.freeze
+
+    def initialize(
+      config_path = File.join(File.expand_path('.'), 'config', 'metrux.yml')
+    )
+      @config_path = config_path
+    end
+
+    def env
+      @env ||= ENV['RAILS_ENV'] || ENV['RACK_ENV'] || DEFAULT_ENVIRONMENT
+    end
+
+    def app_name
+      @app_name ||= commons[:app_name]
+    end
+
+    def prefix
+      @prefix ||= commons[:prefix]
+    end
+
+    def active?
+      @active ||= commons[:active]
+    end
+
+    def influx
+      @influx ||= ConfigBuilders::Influx.new(yaml).build
+    end
+
+    def periodic_gauge_interval
+      @periodic_gauge_interval ||=
+        ConfigBuilders::PeriodicGauge.new(yaml).build
+    end
+
+    def logger
+      @logger ||= ConfigBuilders::Logger.new(yaml).build
+    end
+
+    def yaml
+      @yaml ||= ConfigBuilders::Yaml.new(config_path, env).build
+    end
+
+    def commons
+      @commons ||= ConfigBuilders::Common.new(yaml).build
+    end
+
+    private
+
+    attr_reader :config_path
+  end
+end

data/lib/metrux/connections.rb

@@ -0,0 +1,7 @@
+module Metrux
+  module Connections
+  end
+end
+
+require_relative 'connections/influx_db'
+require_relative 'connections/null'

data/lib/metrux/connections/influx_db.rb

@@ -0,0 +1,17 @@
+module Metrux
+  module Connections
+    class InfluxDb
+      extend Forwardable
+
+      def_delegator :client, :write_point
+
+      def initialize(config)
+        @client = ::InfluxDB::Client.new(config.influx)
+      end
+
+      private
+
+      attr_reader :client
+    end
+  end
+end

data/lib/metrux/connections/null.rb

@@ -0,0 +1,19 @@
+module Metrux
+  module Connections
+    class Null
+      include Metrux::Loggable
+
+      def initialize(config)
+        @logger = config.logger
+      end
+
+      (InfluxDb.public_instance_methods - public_instance_methods)
+        .each do |method|
+        define_method(method) do |*args, &block|
+          log("Calling #{method} with #{args}. Block given? #{block.present?}")
+          self
+        end
+      end
+    end
+  end
+end

data/lib/metrux/constants.rb

@@ -0,0 +1,19 @@
+module Metrux
+  HOST = Socket.gethostname.freeze
+  MAIN_PROGRAM_NAME = $PROGRAM_NAME
+                      .split('/').last
+                      .split(' ').first.gsub(/\W/, '')
+                      .freeze
+  PUMA_WORKER =
+    $PROGRAM_NAME
+    .split('/').last
+    .scan(/^puma: cluster worker (\d+): */)
+    .flatten.last
+    .freeze
+
+  PROGRAM_NAME = if PUMA_WORKER.present?
+                   "#{MAIN_PROGRAM_NAME}-#{PUMA_WORKER}"
+                 else
+                   MAIN_PROGRAM_NAME
+                 end.freeze
+end

data/lib/metrux/loggable.rb

@@ -0,0 +1,24 @@
+module Metrux
+  module Loggable
+    PREFIX_PROGRAM_NAME = 'metrux'.freeze
+    private_constant :PREFIX_PROGRAM_NAME
+
+    LOG_PROGRAM_NAME = "#{PREFIX_PROGRAM_NAME}/#{Metrux::PROGRAM_NAME}".freeze
+    private_constant :LOG_PROGRAM_NAME
+
+    private
+
+    def log(message, severity = :debug)
+      return if __logger__.blank?
+
+      __logger__.public_send(severity, LOG_PROGRAM_NAME) do
+        "[#{self.class}][thread=#{Thread.current.object_id.to_s(16)}] " \
+        "#{message}"
+      end
+    end
+
+    def __logger__
+      @logger || Metrux.logger
+    end
+  end
+end

data/lib/metrux/plugin_register.rb

@@ -0,0 +1,57 @@
+module Metrux
+  class PluginRegister
+    include Loggable
+
+    # Registered plugins
+    attr_reader :plugins
+
+    def initialize(config)
+      @config = config
+      @logger = config.logger
+      @plugins = []
+    end
+
+    # Register a plugin
+    #
+    # == Arguments
+    #
+    # * +klass+ - The plugin class
+    # * +options+ - Any option that you might use on plugin
+    # * +block+ - If you don't have a class, you can pass a block that receives
+    #   the `config` and `options` as arguments.
+    #
+    # === Examples
+    #
+    # * Passing a class as plugin
+    #
+    #     plugin_register.register(
+    #       Metrux::Plugins::MyPlugin, tags: { a: 'tag' }
+    #     ) # => true
+    #
+    # * Passing a block as plugin
+    #
+    #     plugin_register.register(tags: { a: 'tag' }) do |config, options|
+    #       # do something
+    #     end # => true
+    #
+    def register(klass = nil, **options)
+      plugin = if block_given?
+                 -> () { yield(config, options) }
+               else
+                 klass.new(config, options)
+               end
+
+      log("Registering plugin #{plugin.class}")
+
+      plugin.call
+
+      @plugins << plugin
+
+      true
+    end
+
+    private
+
+    attr_reader :config, :logger
+  end
+end

data/lib/metrux/plugins.rb

@@ -0,0 +1,10 @@
+module Metrux
+  module Plugins
+  end
+end
+
+require_relative 'plugins/periodic_gauge'
+require_relative 'plugins/gc'
+require_relative 'plugins/process'
+require_relative 'plugins/thread'
+require_relative 'plugins/yarv'

data/lib/metrux/plugins/gc.rb

@@ -0,0 +1,52 @@
+module Metrux
+  module Plugins
+    class Gc < PeriodicGauge
+      def data
+        {
+          count: count, major_count: major_count, minor_count: minor_count,
+          total_allocated_objects: total_allocated_objects,
+          heap_live: heap_live, heap_free: heap_free
+        }
+      end
+
+      def key
+        'gc'.freeze
+      end
+
+      private
+
+      def count
+        ::GC.count
+      end
+
+      def major_count
+        gc_stats[:major_gc_count]
+      end
+
+      def minor_count
+        gc_stats[:minor_gc_count]
+      end
+
+      def total_allocated_objects
+        gc_stats[:total_allocated_objects] ||
+          gc_stats[:total_allocated_object]
+      end
+
+      def heap_live
+        gc_stats[:heap_live_slots] ||
+          gc_stats[:heap_live_slot] ||
+          gc_stats[:heap_live_num]
+      end
+
+      def heap_free
+        gc_stats[:heap_free_slots] ||
+          gc_stats[:heap_free_slot] ||
+          gc_stats[:heap_free_num]
+      end
+
+      def gc_stats
+        ::GC.stat
+      end
+    end
+  end
+end

data/lib/metrux/plugins/periodic_gauge.rb

@@ -0,0 +1,32 @@
+module Metrux
+  module Plugins
+    class PeriodicGauge
+      def initialize(config, options = {})
+        @config = config
+        @options = options
+      end
+
+      def call
+        Metrux.periodic_gauge(key, options) { data }
+      end
+
+      def key
+        not_implemented
+      end
+
+      def data
+        not_implemented
+      end
+
+      protected
+
+      attr_reader :config, :options
+
+      private
+
+      def not_implemented
+        raise NotImplementedError, 'This is a base plugin'
+      end
+    end
+  end
+end

data/lib/metrux/plugins/process.rb

@@ -0,0 +1,71 @@
+module Metrux
+  module Plugins
+    class Process < PeriodicGauge
+      def initialize(*)
+        super
+        @pid = ::Process.pid
+      end
+
+      def data
+        { rss: rss }
+      end
+
+      def key
+        'process'.freeze
+      end
+
+      private
+
+      attr_reader :pid
+
+      def rss
+        case ::RbConfig::CONFIG['host_os']
+        when /darwin|mac os/
+          default_rss
+        when /linux/
+          linux_rss
+        else
+          0
+        end
+      end
+
+      def linux_rss
+        statm? ? (fetch_statm_rss * kernel_page_size) / 1_024 : default_rss
+      rescue
+        0
+      end
+
+      def default_rss
+        exec("ps -o rss= -p #{pid}").chomp.to_i
+      rescue
+        0
+      end
+
+      def kernel_page_size
+        @kernel_page_size ||= fetch_pagesize
+      end
+
+      def statm_path
+        @statm_path ||= "/proc/#{pid}/statm".freeze
+      end
+
+      def statm?
+        @statm_found ||= ::File.exist?(statm_path)
+      end
+
+      def fetch_statm_rss
+        ::File.read(statm_path).split(' ')[1].to_i
+      end
+
+      def fetch_pagesize
+        exec('getconf PAGESIZE').chomp.to_i
+      rescue
+        4_096
+      end
+
+      def exec(cmd)
+        ::Kernel.public_send(:`, cmd)
+      end
+    end
+  end
+end

data/lib/metrux/plugins/thread.rb

@@ -0,0 +1,13 @@
+module Metrux
+  module Plugins
+    class Thread < PeriodicGauge
+      def data
+        { count: ::Thread.list.count }
+      end
+
+      def key
+        'thread'.freeze
+      end
+    end
+  end
+end