multimeter 1.1.8-java → 2.0.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb6a3c1ab6dc3342aa4579ffaf36c536fa3676df
-  data.tar.gz: 0e33034c21fe3225318c8ef8d681c987339b224f
+  metadata.gz: 6705c90a356382fa03d5b9a49d564a0229f62f07
+  data.tar.gz: e8ad55447af09f9347653b75b9d205ce6c2473b1
 SHA512:
-  metadata.gz: 6fecf5491add5f28fcd3c49de25ed830ee7e41726b595ca6773151953b3b60e06d948d253677de00d06874f6ef4ba9ad511b14e076a939b99e9679eef30a8460
-  data.tar.gz: 82e5c0eb873d918eda97972ed5801cb3f78198eb19629d7851b9a0385a9be918efe0fb8ef9020072b44c6081baa6ae2ad6792f1004420b48f3385b8322f4f1c8
+  metadata.gz: 2af9a88eebd3bd5736d4223e8f7513c263896b6e0d3e7eece848aab69e53bef83cb6c1ec0453ab604c8c5bdfb3127d0306171dda0e8c12f09e142e6eefeeef3a
+  data.tar.gz: 35e00dcba6a7eb0c6294f568bca506e5af7258e16610671418f6cd3fd394e1e3029ee3f2e7fa007ed49b365c6d1d4530d2b1b9711ddab80346727cf99a7398cb

data/lib/multimeter.rb

@@ -1,340 +1,119 @@
 # encoding: utf-8
 
 require 'metrics-core-jars'
+require 'multimeter_metrics'
 require 'json'
 
-
-module Yammer
-  module Metrics
-    java_import 'com.yammer.metrics.core.MetricsRegistry'
-    java_import 'com.yammer.metrics.core.MetricName'
-    java_import 'com.yammer.metrics.core.Meter'
-    java_import 'com.yammer.metrics.core.Counter'
-    java_import 'com.yammer.metrics.core.Histogram'
-    java_import 'com.yammer.metrics.core.Gauge'
-    java_import 'com.yammer.metrics.core.Timer'
-    java_import 'com.yammer.metrics.stats.Snapshot'
-    java_import 'com.yammer.metrics.reporting.JmxReporter'
-
-    class Meter
-      def type
-        :meter
-      end
-
-      def to_h
-        {
-          :type => :meter,
-          :event_type => event_type,
-          :count => count,
-          :mean_rate => mean_rate,
-          :one_minute_rate => one_minute_rate,
-          :five_minute_rate => five_minute_rate,
-          :fifteen_minute_rate => fifteen_minute_rate
-        }
-      end
-    end
-
-    class Counter
-      def type
-        :counter
-      end
-
-      def to_h
-        {
-          :type => :counter,
-          :count => count
-        }
-      end
-    end
-
-    class Histogram
-      def type
-        :histogram
-      end
-
-      def to_h
-        {
-          :type => :histogram,
-          :count => count,
-          :max => max,
-          :min => min,
-          :mean => mean,
-          :std_dev => std_dev,
-          :sum => sum
-        }.merge(snapshot.to_h)
-      end
-    end
-
-    class Gauge
-      def type
-        :gauge
-      end
-
-      def to_h
-        {
-          :type => :gauge,
-          :value => value
-        }
-      end
-    end
-
-    class Timer
-      def type
-        :timer
-      end
-
-      def to_h
-        {
-          :type => :timer,
-          :event_type => event_type,
-          :count => count,
-          :mean_rate => mean_rate,
-          :one_minute_rate => one_minute_rate,
-          :five_minute_rate => five_minute_rate,
-          :fifteen_minute_rate => fifteen_minute_rate,
-          :max => max,
-          :min => min,
-          :mean => mean,
-          :std_dev => std_dev,
-          :sum => sum
-        }.merge(snapshot.to_h)
-      end
-
-      def measure
-        ctx = self.time
-        begin
-          yield
-        ensure
-          ctx.stop
-        end
-      end
-    end
-
-    class Snapshot
-      def to_h
-        {
-          :median => median,
-          :percentiles => {
-            '75'   => get75thPercentile,
-            '95'   => get95thPercentile,
-            '98'   => get98thPercentile,
-            '99'   => get99thPercentile,
-            '99.9' => get999thPercentile
-          }
-        }
-      end
-    end
-  end
-end
-
-module JavaConcurrency
-  java_import 'java.util.concurrent.TimeUnit'
-  java_import 'java.util.concurrent.ConcurrentHashMap'
-  java_import 'java.util.concurrent.atomic.AtomicReference'
-  java_import 'java.lang.Thread'
+module Metrics
+  include_package 'com.codahale.metrics'
 end
 
 module Multimeter
-  def self.global_registry
-    GLOBAL_REGISTRY
-  end
-
-  def self.registry(group, scope, instance_id=nil)
-    Registry.new(group, scope, instance_id)
-  end
-
-  def self.metrics(group, scope, &block)
-    Class.new do
-      include(Metrics)
-      group(group)
-      scope(scope)
-      instance_eval(&block)
-    end.new
+  class MetricRegistry
+    def to_h
+      h = {}
+      metrics.each do |metric_name, metric|
+        h[metric_name] = metric.to_h
+      end
+      h
+    end
   end
 
-  module Metrics
-    def self.included(m)
-      m.extend(Dsl)
+  class Meter
+    def to_h
+      {
+        :type => :meter,
+        :count => count,
+        :mean_rate => mean_rate,
+        :one_minute_rate => one_minute_rate,
+        :five_minute_rate => five_minute_rate,
+        :fifteen_minute_rate => fifteen_minute_rate
+      }
     end
+  end
 
-    def initialize(*args)
-      super
-      self.class.instance_gauges.each do |name, block|
-        instance_block = proc { instance_exec(&block) }
-        multimeter_registry.gauge(name, &instance_block)
-      end
-      self.class.instance_metrics.each do |type, name, options|
-        multimeter_registry.send(type, name, options)
-      end
+  class Counter
+    def to_h
+      {
+        :type => :counter,
+        :count => count
+      }
     end
+  end
 
-    def multimeter_registry
-      registry_mode = self.class.send(:registry_mode)
-      case registry_mode
-      when :instance, :linked_instance
-        @multimeter_registry ||= begin
-          package, _, class_name = self.class.name.rpartition('::')
-          group = self.class.send(:group) || package
-          scope = self.class.send(:scope) || class_name
-          if (iid_proc = self.class.send(:instance_id))
-            instance_id = instance_exec(&iid_proc)
-          else
-            instance_id = self.object_id
-          end
-          if registry_mode == :linked_instance
-            ::Multimeter.global_registry.sub_registry(scope, instance_id)
-          else
-            ::Multimeter.registry(group, scope, instance_id)
-          end
-        end
-      when :global
-        ::Multimeter.global_registry
-      else
-        self.class.multimeter_registry
-      end
+  class Histogram
+    def to_h
+      {
+        :type => :histogram,
+        :count => count,
+      }.merge(snapshot.to_h)
     end
+  end
 
-    module Dsl
-      def multimeter_registry
-        @multimeter_registry ||= begin
-          package, _, class_name = self.name.rpartition('::')
-          g = group || package
-          s = scope || class_name
-          case registry_mode
-          when :linked
-            ::Multimeter.global_registry.sub_registry(s)
-          when :global
-            ::Multimeter.global_registry
-          else
-            ::Multimeter.registry(g, s)
-          end
-        end
-      end
-
-      def instance_gauges
-        @instance_gauges || []
-      end
-
-      def instance_metrics
-        @instance_metrics || []
-      end
-
-      private
-
-      def group(g=nil)
-        @multimeter_registry_group = g.to_s if g
-        @multimeter_registry_group
-      end
-
-      def scope(t=nil)
-        @multimeter_registry_scope = t.to_s if t
-        @multimeter_registry_scope
-      end
-
-      def instance_id(pr=nil, &block_pr)
-        pr ||= block_pr
-        @multimeter_registry_iid = pr if pr
-        @multimeter_registry_iid
-      end
-
-      def registry_mode(m=nil)
-        @multimeter_registry_mode = m if m
-        @multimeter_registry_mode
-      end
-
-      def add_instance_gauge(name, block)
-        @instance_gauges ||= []
-        @instance_gauges << [name, block]
-      end
-
-      def add_instance_metric(type, name, options)
-        @instance_metrics ||= []
-        @instance_metrics << [type, name, options]
-      end
-
-      %w[counter meter histogram timer].each do |t|
-        type = t.to_sym
-        define_method(type) do |name, options={}|
-          case registry_mode
-          when :instance, :linked_instance
-            add_instance_metric(type, name, options)
-          else
-            multimeter_registry.send(type, name, options)
-          end
-          define_method(name) do
-            multimeter_registry.get(name)
-          end
-        end
-      end
-
-      def gauge(name, &block)
-        case registry_mode
-        when :instance, :linked_instance
-          add_instance_gauge(name, block)
-        else
-          multimeter_registry.gauge(name, &block)
-        end
-        define_method(name) do
-          multimeter_registry.gauge(name)
-        end
-      end
+  class Timer
+    def to_h
+      {
+        :type => :timer,
+        :count => count,
+        :mean_rate => mean_rate,
+        :one_minute_rate => one_minute_rate,
+        :five_minute_rate => five_minute_rate,
+        :fifteen_minute_rate => fifteen_minute_rate,
+      }.merge(snapshot.to_h(NANO_TO_MILLI_SCALE))
     end
   end
 
-  module InstanceMetrics
-    def self.included(m)
-      m.send(:include, Metrics)
-      m.send(:registry_mode, :instance)
+  class Snapshot
+    def to_h(scale=1)
+      {
+        :max => max * scale,
+        :min => min * scale,
+        :mean => mean * scale,
+        :std_dev => std_dev * scale,
+        :median => median * scale,
+        :percentiles => {
+          '75' => p75 * scale,
+          '95' => p95 * scale,
+          '98' => p98 * scale,
+          '99' => p99 * scale,
+          '99.9' => p999 * scale,
+        }
+      }
     end
   end
 
-  module GlobalMetrics
-    def self.included(m)
-      m.send(:include, Metrics)
-      m.send(:registry_mode, :global)
+  class Gauge
+    def to_h
+      {
+        :type => :gauge,
+        :value => value,
+      }
     end
   end
 
-  module LinkedMetrics
-    def self.included(m)
-      m.send(:include, Metrics)
-      m.send(:registry_mode, :linked)
-    end
+  def self.create_registry
+    MetricRegistry.new
   end
 
-  module LinkedInstanceMetrics
-    def self.included(m)
-      m.send(:include, Metrics)
-      m.send(:registry_mode, :linked_instance)
-    end
+  def self.jmx(registry, options = {})
+    Metrics::JmxReporter.forRegistry(registry.to_java).inDomain(options[:domain] || 'multimeter').build.tap(&:start)
   end
 
-  module Jmx
-    def jmx!(options={})
-      return if @jmx_reporter
-      @jmx_reporter = ::Yammer::Metrics::JmxReporter.new(@registry)
-      @jmx_reporter.start
-      if options[:recursive]
-        sub_registries.each do |registry|
-          registry.jmx!
-        end
-      end
+  def self.http(registry, rack_handler, options={})
+    server_thread = Java::JavaLang::Thread.new do
+      rack_handler.run(Http.create_app(registry), options)
     end
+    server_thread.daemon = true
+    server_thread.name = 'multimeter-http-server'
+    server_thread.start
+    server_thread
   end
 
-  module Http
-    def http!(rack_handler, options={})
-      return if @server_thread
-      @server_thread = JavaConcurrency::Thread.new do
-        rack_handler.run(create_app(self), options)
-      end
-      @server_thread.daemon = true
-      @server_thread.name = 'multimeter-http-server'
-      @server_thread.start
-    end
+  private
 
-    private
+  NANO_TO_MILLI_SCALE = 1.0/1_000_000
 
+  module Http
     class BadRequest < StandardError; end
 
     COMMON_HEADERS = {'Connection' => 'close'}.freeze
@@ -342,7 +121,7 @@ module Multimeter
     JSONP_HEADERS = COMMON_HEADERS.merge('Content-Type' => 'application/javascript').freeze
     ERROR_HEADERS = COMMON_HEADERS.merge('Content-Type' => 'text/plain').freeze
 
-    def create_app(registry)
+    def self.create_app(registry)
       proc do |env|
         begin
           body = registry.to_h.to_json
@@ -366,220 +145,4 @@ module Multimeter
       end
     end
   end
-
-  class Registry
-    include Enumerable
-    include Jmx
-    include Http
-
-    attr_reader :group, :scope, :instance_id
-
-    def initialize(*args)
-      @group, @scope, @instance_id = args
-      @registry = ::Yammer::Metrics::MetricsRegistry.new
-      @sub_registries = JavaConcurrency::ConcurrentHashMap.new
-    end
-
-    def instance_registry?
-      !!@instance_id
-    end
-
-    def sub_registry(scope, instance_id=nil)
-      full_id = scope.dup
-      full_id << "/#{instance_id}" if instance_id
-      r = @sub_registries.get(full_id)
-      unless r
-        r = self.class.new(@group, scope, instance_id)
-        @sub_registries.put_if_absent(full_id, r)
-        r = @sub_registries.get(full_id)
-      end
-      r
-    end
-
-    def sub_registries
-      @sub_registries.values.to_a
-    end
-
-    def each_metric
-      return self unless block_given?
-      @registry.all_metrics.each do |metric_name, metric|
-        yield metric_name.name, metric
-      end
-    end
-    alias_method :each, :each_metric
-
-    def get(name)
-      @registry.all_metrics[create_name(name)]
-    end
-
-    def find_metric(name)
-      m = get(name)
-      unless m
-        sub_registries.each do |registry|
-          m = registry.find_metric(name)
-          break if m
-        end
-      end
-      m
-    end
-
-    def gauge(name, options={}, &block)
-      existing_gauge = get(name)
-      if block_given? && existing_gauge.respond_to?(:same?) && existing_gauge.same?(block)
-        return
-      elsif existing_gauge && block_given?
-        raise ArgumentError, %(Cannot redeclare gauge #{name})
-      else
-        @registry.new_gauge(create_name(name), ProcGauge.new(block))
-      end
-    end
-
-    def counter(name, options={})
-      error_translation do
-        @registry.new_counter(create_name(name))
-      end
-    end
-
-    def meter(name, options={})
-      error_translation do
-        event_type = (options[:event_type] || '').to_s
-        time_unit = TIME_UNITS[options[:time_unit] || :seconds]
-        @registry.new_meter(create_name(name), event_type, time_unit)
-      end
-    end
-
-    def histogram(name, options={})
-      error_translation do
-        @registry.new_histogram(create_name(name), !!options[:biased])
-      end
-    end
-
-    def timer(name, options={})
-      error_translation do
-        duration_unit = TIME_UNITS[options[:duration_unit] || :milliseconds]
-        rate_unit = TIME_UNITS[options[:rate_unit] || :seconds]
-        @registry.new_timer(create_name(name), duration_unit, rate_unit)
-      end
-    end
-
-    def to_h
-      h = {@scope => {}}
-      each_metric do |metric_name, metric|
-        h[@scope][metric_name.to_sym] = metric.to_h
-      end
-      registries_by_scope = sub_registries.group_by { |r| r.scope }
-      registries_by_scope.each do |scope, registries|
-        if registries.size == 1
-          h.merge!(registries.first.to_h)
-        else
-          h[scope] = {}
-          registries_by_metric = Hash.new { |h, k| h[k] = [] }
-          registries.each do |registry|
-            registry.each_metric do |metric_name, _|
-              registries_by_metric[metric_name] << registry
-            end
-          end
-          registries_by_metric.each do |metric_name, registries|
-            if registries.size == 1
-              h[scope][metric_name.to_sym] = registries.first.get(metric_name).to_h
-            else
-              metrics_by_instance_id = Hash[registries.map { |r| [r.instance_id, r.get(metric_name)] }]
-              h[scope][metric_name.to_sym] = Aggregate.new(metrics_by_instance_id).to_h
-            end
-          end
-        end
-        h
-      end
-      h.delete_if { |k, v| v.empty? }
-      h
-    end
-
-    private
-
-    TIME_UNITS = {
-      :seconds      => JavaConcurrency::TimeUnit::SECONDS,
-      :milliseconds => JavaConcurrency::TimeUnit::MILLISECONDS
-    }.freeze
-
-    def create_name(name)
-      ::Yammer::Metrics::MetricName.new(@group, @scope, name.to_s)
-    end
-
-    def error_translation
-      begin
-        yield
-      rescue java.lang.ClassCastException => cce
-        raise ArgumentError, %(Cannot redeclare a metric as another type)
-      end
-    end
-  end
-
-  class Aggregate
-    def initialize(metrics)
-      @metrics = metrics
-      @type = check_type!
-    end
-
-    def to_h
-      {
-        :type => :aggregate,
-        :total => compute_total,
-        :parts => Hash[@metrics.map { |k, v| [k.to_s, v.to_h] }]
-      }
-    end
-
-    private
-
-    def check_type!
-      types = @metrics.values.map(&:type).uniq
-      unless types.size == 1
-        raise ArgumentError, %[All metrics of an aggregate must be of the same type (they were: #{types.join(', ')})]
-      end
-      types.first
-    end
-
-    def compute_total
-      h = {}
-      metric_hs = @metrics.values.map(&:to_h)
-      metric_hs.first.keys.each do |property|
-        values = metric_hs.map { |h| h[property] }
-        aggregate_value = begin
-          case property
-          when :type, :event_type then values.first
-          when :percentiles then nil
-          else
-            if values.all? { |v| v.nil? || v.is_a?(Numeric) }
-              min, max = values.compact.minmax
-              sum = values.compact.reduce(:+)
-              {
-                :max => max,
-                :min => min,
-                :sum => sum,
-                :avg => sum ? sum.fdiv(values.size) : nil,
-              }
-            end
-          end
-        end
-        h[property] = aggregate_value if aggregate_value
-      end
-      h
-    end
-  end
-
-  class ProcGauge < ::Yammer::Metrics::Gauge
-    def initialize(proc)
-      super()
-      @proc = proc
-    end
-
-    def value
-      @proc.call
-    end
-
-    def same?(other_proc)
-      other_proc.source_location == @proc.source_location
-    end
-  end
-
-  GLOBAL_REGISTRY = registry('multimeter', 'global')
 end

data/lib/multimeter/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Multimeter
-  VERSION = '1.1.8'
+  VERSION = '2.0.0'.freeze
 end

metadata

@@ -1,24 +1,24 @@
 --- !ruby/object:Gem::Specification
 name: multimeter
 version: !ruby/object:Gem::Version
-  version: 1.1.8
+  version: 2.0.0
 platform: java
 authors:
 - Theo Hultberg
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-02-05 00:00:00.000000000 Z
+date: 2016-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.1.2
+        version: '3.1'
     - - <
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 4.0.0
   name: metrics-core-jars
   prerelease: false
   type: :runtime
@@ -26,11 +26,11 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.1.2
+        version: '3.1'
     - - <
       - !ruby/object:Gem::Version
-        version: 3.0.0
-description: Multimeter provides a JRuby DSL for instrumenting your application. It uses Yammer's Metrics library under the hood.
+        version: 4.0.0
+description: Multimeter provides a thin wrapper around Dropwizard's (a.k.a. Coda Hale's) Metrics library under the hood.
 email:
 - theo@iconara.net
 executables: []
@@ -39,8 +39,10 @@ extra_rdoc_files: []
 files:
 - lib/multimeter.rb
 - lib/multimeter/version.rb
+- lib/multimeter_metrics.jar
 homepage: http://github.com/iconara/multimeter
-licenses: []
+licenses:
+- Apache-2.0
 metadata: {}
 post_install_message:
 rdoc_options: []
@@ -58,8 +60,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: multimeter
-rubygems_version: 2.2.2
+rubygems_version: 2.6.6
 signing_key:
 specification_version: 4
-summary: JRuby application metric instrumentation using Yammer's Metrics
+summary: JRuby application metric instrumentation using Dropwizard's Metrics
 test_files: []