mnemonic 0.1.0

data/lib/mnemonic/logger_proxy.rb

@@ -0,0 +1,91 @@
+require 'logger'
+require 'monitor'
+require 'forwardable'
+
+class Mnemonic
+  class LoggerProxy
+    extend Forwardable
+
+    def initialize(logger, mnemonic = Mnemonic.new(&proc))
+      super()
+      @monitor = Monitor.new
+      @logger = logger
+      @mnemonic = mnemonic
+      enable_mnemonic!
+    end
+
+    def enable_mnemonic!
+      @monitor.synchronize do
+        @sink = @mnemonic.attach_pretty(@logger)
+      end
+    end
+
+    def disable_mnemonic!
+      @monitor.synchronize do
+        @mnemonic.detach(@sink)
+        @sink = nil
+      end
+    end
+
+    def mnemonic_enabled?
+      @monitor.synchronize { !!@sink }
+    end
+
+    def_delegators :@logger,
+      :level,
+      :level=,
+      :formatter,
+      :formatter=,
+      :datetime_format,
+      :datetime_format=
+
+    [
+      :debug,
+      :info,
+      :warn,
+      :error,
+      :fatal,
+      :unknown
+    ].each do |name|
+      severity = Logger.const_get(name.to_s.upcase)
+      define_method(name) do |progname = nil, &block|
+        add(severity, nil, progname, &block)
+      end
+      def_delegator :@logger, "#{name}?"
+    end
+
+    def add(severity, message = nil, progname = nil, &block)
+      @monitor.synchronize do
+        @logger.add(severity, message, progname, &block).tap do |result|
+          @mnemonic.trigger! if result && @sink && severity >= @logger.level
+        end
+      end
+    end
+    alias_method :log, :add
+
+    def <<(msg)
+      @monitor.synchronize do
+        @logger << msg
+      end
+    end
+
+    def close
+      @monitor.synchronize do
+        disable_mnemonic!
+        @logger.close
+      end
+    end
+
+    def method_missing(method_name, *args, &block)
+      if @logger.respond_to? method_name
+        @logger.send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to?(method_name, include_private = false)
+      @logger.respond_to?(method_name) || super
+    end
+  end
+end

data/lib/mnemonic/metric.rb

@@ -0,0 +1,14 @@
+class Mnemonic
+  module Metric
+    require 'mnemonic/metric/base'
+    require 'mnemonic/metric/hash_metric'
+    require 'mnemonic/metric/rss'
+    require 'mnemonic/metric/time'
+    require 'mnemonic/metric/time_milliseconds'
+    require 'mnemonic/metric/gc_stat'
+    require 'mnemonic/metric/objects_count'
+    require 'mnemonic/metric/objects_size'
+    require 'mnemonic/metric/instances_count'
+    require 'mnemonic/metric/instances_size'
+  end
+end

data/lib/mnemonic/metric/base.rb

@@ -0,0 +1,30 @@
+class Mnemonic
+  module Metric
+    class Base
+      attr_reader :name
+      attr_reader :start_value, :prev_value, :value
+      attr_reader :diff, :diff_from_start
+
+      def start!
+        @start_value = @value = current_value
+      end
+
+      def refresh!
+        @prev_value = @value
+        @value = current_value
+        @diff = @value - @prev_value
+        @diff_from_start = @value - @start_value
+      end
+
+      def each_submetric
+        yield self
+      end
+
+      private
+
+      def current_value
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/mnemonic/metric/gc_stat.rb

@@ -0,0 +1,50 @@
+class Mnemonic
+  module Metric
+    class GCStat < HashMetric
+      def initialize(*keys)
+        keys = DEFAULT_KEYS if keys.empty?
+        super
+      end
+
+      def name
+        'GCStat'.freeze
+      end
+
+      private
+
+      def refresh_hash!
+        GC.stat(@current_hash_value)
+      end
+
+      KIND_TABLE = {
+        :count => :number,
+        :heap_allocated_pages => :number,
+        :heap_sorted_length => :number,
+        :heap_allocatable_pages => :number,
+        :heap_available_slots => :number,
+        :heap_live_slots => :number,
+        :heap_free_slots => :number,
+        :heap_final_slots => :number,
+        :heap_marked_slots => :number,
+        :heap_swept_slots => :number,
+        :heap_eden_pages => :number,
+        :heap_tomb_pages => :number,
+        :total_allocated_pages => :number,
+        :total_freed_pages => :number,
+        :total_allocated_objects => :number,
+        :total_freed_objects => :number,
+        :malloc_increase_bytes => :bytes,
+        :malloc_increase_bytes_limit => :bytes,
+        :minor_gc_count => :number,
+        :major_gc_count => :number,
+        :remembered_wb_unprotected_objects => :number,
+        :remembered_wb_unprotected_objects_limit => :number,
+        :old_objects => :bytes,
+        :old_objects_limit => :bytes,
+        :oldmalloc_increase_bytes => :number,
+        :oldmalloc_increase_bytes_limit => :number
+      }
+      DEFAULT_KEYS = KIND_TABLE.keys
+    end
+  end
+end

data/lib/mnemonic/metric/hash_metric.rb

@@ -0,0 +1,54 @@
+class Mnemonic
+  module Metric
+    class HashMetric
+      class Submetric < Base
+        attr_reader :kind
+
+        def initialize(parent, key, kind)
+          @parent = parent
+          @key = key
+          @name = "#{parent.name}(#{key.inspect})"
+          @kind = kind
+        end
+
+        private
+
+        def current_value
+          @parent[@key]
+        end
+      end
+
+      def initialize(*keys)
+        @current_hash_value = {}
+        kind_table = self.class.const_get(:KIND_TABLE)
+        @submetrics = keys.map do |key|
+          Submetric.new(self, key, kind_table[key])
+        end
+      end
+
+      def start!
+        refresh_hash!
+        @submetrics.each(&:start!)
+      end
+
+      def refresh!
+        refresh_hash!
+        @submetrics.each(&:refresh!)
+      end
+
+      def each_submetric(&block)
+        @submetrics.each(&block)
+      end
+
+      def [](key)
+        @current_hash_value[key]
+      end
+
+      private
+
+      def refresh_hash!
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/mnemonic/metric/instances_count.rb

@@ -0,0 +1,20 @@
+class Mnemonic
+  module Metric
+    class InstancesCount < Base
+      def initialize(klass)
+        @enum = ObjectSpace.each_object(klass)
+        @name = "Count(#{klass.name || klass.inspect})"
+      end
+
+      def kind
+        :number
+      end
+
+      private
+
+      def current_value
+        @enum.count
+      end
+    end
+  end
+end

data/lib/mnemonic/metric/instances_size.rb

@@ -0,0 +1,20 @@
+class Mnemonic
+  module Metric
+    class InstancesSize < Base
+      def initialize(klass)
+        @klass = klass
+        @name = "Size(#{klass.name || klass.inspect})"
+      end
+
+      def kind
+        :bytes
+      end
+
+      private
+
+      def current_value
+        ObjectSpace.memsize_of_all(@klass)
+      end
+    end
+  end
+end

data/lib/mnemonic/metric/objects_count.rb

@@ -0,0 +1,48 @@
+class Mnemonic
+  module Metric
+    class ObjectsCount < HashMetric
+      def initialize(*keys)
+        keys = DEFAULT_KEYS if keys.empty?
+        super
+      end
+
+      def name
+        'Count'.freeze
+      end
+
+      def kind
+        :number
+      end
+
+      private
+
+      def refresh_hash!
+        ObjectSpace.count_objects(@current_hash_value)
+      end
+
+      KIND_TABLE = {
+        :TOTAL => :number,
+        :FREE => :number,
+        :T_OBJECT => :number,
+        :T_CLASS => :number,
+        :T_MODULE => :number,
+        :T_FLOAT => :number,
+        :T_STRING => :number,
+        :T_REGEXP => :number,
+        :T_ARRAY => :number,
+        :T_HASH => :number,
+        :T_STRUCT => :number,
+        :T_BIGNUM => :number,
+        :T_FILE => :number,
+        :T_DATA => :number,
+        :T_MATCH => :number,
+        :T_COMPLEX => :number,
+        :T_RATIONAL => :number,
+        :T_SYMBOL => :number,
+        :T_NODE => :number,
+        :T_ICLASS => :number
+      }
+      DEFAULT_KEYS = KIND_TABLE.keys
+    end
+  end
+end

data/lib/mnemonic/metric/objects_size.rb

@@ -0,0 +1,47 @@
+class Mnemonic
+  module Metric
+    class ObjectsSize < HashMetric
+      def initialize(*keys)
+        keys = DEFAULT_KEYS if keys.empty?
+        super
+      end
+
+      def name
+        'Size'.freeze
+      end
+
+      def kind
+        :bytes
+      end
+
+      private
+
+      def refresh_hash!
+        ObjectSpace.count_objects_size(@current_hash_value)
+      end
+
+      KIND_TABLE = {
+        :T_OBJECT => :bytes,
+        :T_CLASS => :bytes,
+        :T_MODULE => :bytes,
+        :T_FLOAT => :bytes,
+        :T_STRING => :bytes,
+        :T_REGEXP => :bytes,
+        :T_ARRAY => :bytes,
+        :T_HASH => :bytes,
+        :T_STRUCT => :bytes,
+        :T_BIGNUM => :bytes,
+        :T_FILE => :bytes,
+        :T_DATA => :bytes,
+        :T_MATCH => :bytes,
+        :T_COMPLEX => :bytes,
+        :T_RATIONAL => :bytes,
+        :T_SYMBOL => :bytes,
+        :T_NODE => :bytes,
+        :T_ICLASS => :bytes,
+        :TOTAL => :bytes
+      }
+      DEFAULT_KEYS = KIND_TABLE.keys
+    end
+  end
+end

data/lib/mnemonic/metric/rss.rb

@@ -0,0 +1,16 @@
+class Mnemonic
+  module Metric
+    class RSS < Base
+      require 'mnemonic/metric/rss/ps'
+      require 'mnemonic/metric/rss/proc_fs'
+
+      def name
+        'RSS'.freeze
+      end
+
+      def kind
+        :bytes
+      end
+    end
+  end
+end

data/lib/mnemonic/metric/rss/proc_fs.rb

@@ -0,0 +1,14 @@
+class Mnemonic
+  class Metric::RSS::ProcFS < Metric::RSS
+    def initialize
+      @io = File.open("/proc/#{$$}/statm", 'r')
+    end
+
+    private
+
+    def current_value
+      @io.seek(0)
+      @io.gets.split(/\s/)[1].to_i * Util::PageSize.value
+    end
+  end
+end

data/lib/mnemonic/metric/rss/ps.rb

@@ -0,0 +1,9 @@
+class Mnemonic
+  class Metric::RSS::PS < Metric::RSS
+    private
+
+    def current_value
+      `ps -o rss -p #{$$}`.strip.split.last.to_i * 1024
+    end
+  end
+end

data/lib/mnemonic/metric/time.rb

@@ -0,0 +1,19 @@
+class Mnemonic
+  module Metric
+    class Time < Base
+      def name
+        'Time'.freeze
+      end
+
+      def kind
+        :time
+      end
+
+      private
+
+      def current_value
+        ::Time.now
+      end
+    end
+  end
+end