monus 0.1.5 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c2e07d32bf02ceecba6f076d9a36f5761d88603a
-  data.tar.gz: cbd46daca888e4557fcf1bf6c3b710e47c05d7cd
+  metadata.gz: d06a333007c12ef83cbf10f6b52d25f8cdd38717
+  data.tar.gz: fee56317634433c00b9da1e8c6c61b73e22470c8
 SHA512:
-  metadata.gz: 23cf5413788123080a710c8907f33add6216d01f4ae18d23d356edeb248bae219a7344c885d99cfe5e24f9222111426c3c18c24a205c7925340b89cbfcb04e55
-  data.tar.gz: 32d3ff3c4f2af77ff55e22c0908bb0f36cc2d2bffb0d81126547cd41f6f020e99c9aefd49391af716f6f19b77bb0fe9e2b27e2aed120002a92709de90cc43dcd
+  metadata.gz: c2452aaece8e5a2278cec6a48155669fddb160d498289b3fb672a732888d492465f1ef15835cc63bb0a64edf82c8e5a39f327cde8844f84847d6253eb4836ae2
+  data.tar.gz: 2283d374c3977ac89f9795e486df93416c1e2326a1d775760d68cdd21ad32ceb10868746f738dad515eeb9f75fd48ad842755ea437081d1d7e26dfa179fb8dd8

data/lib/monus/built_in_metrics/em_callbacks.rb

@@ -0,0 +1,41 @@
+module Monus::BuiltInMetric::EmCallbacks
+  def activate
+    @interval = Monus.options.dig(:em_callbacks_metric_options, :interval) || 1
+
+    begin
+      require 'lspace/eventmachine'
+    rescue LoadError
+      raise LoadError, 'in order to use em_callbacks metric you should add `lspace` gem to your Gemfile'
+    end
+
+    timings = []
+
+    LSpace.around_filter do |&block|
+      time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      begin
+        block.call
+      ensure
+        delta = Process.clock_gettime(Process::CLOCK_MONOTONIC) - time
+        timings.push(delta)
+      end
+    end
+
+    Monus.engine.every @interval do
+      slice = timings.slice!(0..-1)
+
+      next if slice.empty?
+
+      number = slice.size
+      maximum = slice.max
+      total = slice.sum
+
+      Monus.write em_callbacks_number: number,
+                  em_callbacks_maximum: maximum,
+                  em_callbacks_total: total
+    end
+  end
+
+  extend self
+
+  Monus::BuiltInMetric.register :em_callbacks, self
+end

data/lib/monus/built_in_metrics/em_latency.rb

@@ -0,0 +1,27 @@
+module Monus::BuiltInMetric::EmLatency
+  def activate
+    unless Monus.engine.kind_of? Monus::Engine::EventMachine
+      raise LoadError, 'in order to use em_latency metric you should use :eventmachine engine'
+    end
+
+    @interval = Monus.options.dig(:em_latency_metric_options, :interval) || 1
+
+    last_time, current_time = nil, nil
+
+    Monus.engine.every @interval do
+      current_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      if last_time
+        latency = current_time - last_time - @interval
+
+        Monus.set :em_latency, latency
+      end
+
+      last_time = current_time
+    end
+  end
+
+  extend self
+
+  Monus::BuiltInMetric.register :em_latency, self
+end

data/lib/monus/built_in_metrics/em_threadpool.rb

@@ -2,24 +2,30 @@ module Monus::BuiltInMetric::EmThreadpool
   def activate
     @interval = Monus.options.dig(:em_threadpool_metric_options, :interval) || 1
 
-    threadpool = nil
+    threadpool, threadqueue = nil, nil
 
     Monus.engine.every @interval do
       threadpool ||= EM.send(:instance_variable_get, :@threadpool)
+      threadqueue ||= EM.send(:instance_variable_get, :@threadqueue)
 
-      if threadpool
-        by_status = threadpool.group_by(&:status).transform_values(&:size)
-        by_status.default = 0
-
+      if threadpool and threadqueue
         total = threadpool.size
-        run = by_status['run']
-        load_percent = run.to_f / total
-        broken = total - run - by_status['sleep']
+        alive = threadpool.count(&:alive?)
+        broken = total - alive
+
+        free = threadqueue.num_waiting
+        busy = alive - free
+        load_percent = busy.to_f / alive
+
+        threadqueue_length = threadqueue.length
 
         Monus.write em_threadpool_load: load_percent,
-                    em_threadpool_run: run,
+                    em_threadpool_free: free,
+                    em_threadpool_busy: busy,
                     em_threadpool_total: total,
-                    em_threadpool_broken: broken
+                    em_threadpool_alive: alive,
+                    em_threadpool_broken: broken,
+                    em_threadqueue_length: threadqueue_length
       end
     end
   end

data/lib/monus/engines/eventmachine.rb

@@ -0,0 +1,82 @@
+require 'resolv'
+
+module Monus::Engine::EventMachine
+  def prepare
+    @dns_cache = {}
+    @prepared = true
+  end
+
+  def make_http_connection(host, port)
+    load_http
+    EM::HttpRequest.new("http://#{host}:#{port}")
+  end
+
+  def send_http_request(uri, method: :get, body: nil, connection: nil)
+    load_http
+    EM.schedule do
+      if connection
+        connection.setup_request(method, path: uri, keepalive: true)
+      else
+        EM::HttpRequest.new(uri).send(method)
+      end
+    end
+  end
+
+  def load_http
+    @http_loaded ||= begin
+      require 'em-http-request'
+      true
+    rescue LoadError
+      raise LoadError, 'in order to use HTTP requests in EventMachine engine you should add `em-http-request` gem to your Gemfile'
+    end
+  end
+
+  def send_udp_datagram(message, host, port)
+    EM.schedule do
+      @udp_socket ||= EM.open_datagram_socket '0.0.0.0', 0
+
+      ip = @dns_cache[host]
+
+      if ip.nil? and (host =~ Resolv::IPv4::Regex or host =~ Resolv::IPv6::Regex)
+        ip = host
+        @dns_cache[host] = ip
+      end
+
+      if ip
+        @udp_socket.send_datagram message, ip, port
+      else
+        EM::DNS::Resolver.resolve(host).callback do |ip_list|
+          ip = ip_list.first
+          @dns_cache[host] = ip
+          send_udp_datagram(message, host, port)
+        end
+      end
+    end
+  end
+
+  def invalidate_dns_cache!
+    keys = @dns_cache.keys.reject { |key| key =~ Resolv::IPv4::Regex || key =~ Resolv::IPv6::Regex }
+    keys.each { |key| @dns_cache.delete(key) }
+  end
+
+  def every(interval, fire_immediately: true, on_error: nil, &block)
+    EM.schedule do
+      block.call if fire_immediately
+
+      EM.add_periodic_timer(interval) do
+        begin
+          block.call
+        rescue => error
+          interval_binding = binding
+          Array(on_error).each do |handler|
+            handler.call error, :interval, interval_binding
+          end
+        end
+      end
+    end
+  end
+
+  extend self
+
+  Monus::Engine.register :eventmachine, self
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: monus
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.8
 platform: ruby
 authors:
 - Xanders
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-18 00:00:00.000000000 Z
+date: 2019-05-26 00:00:00.000000000 Z
 dependencies: []
 description: Monus is an in-process monitoring library for several backends and engines
 email: necropolis@inbox.ru
@@ -22,10 +22,12 @@ files:
 - lib/monus/backend.rb
 - lib/monus/backends/influxdb.rb
 - lib/monus/built_in_metric.rb
+- lib/monus/built_in_metrics/em_callbacks.rb
+- lib/monus/built_in_metrics/em_latency.rb
 - lib/monus/built_in_metrics/em_threadpool.rb
-- lib/monus/built_in_metrics/em_ticks.rb
 - lib/monus/built_in_metrics/works.rb
 - lib/monus/engine.rb
+- lib/monus/engines/eventmachine.rb
 - lib/monus/engines/pure.rb
 homepage: https://github.com/xanders/monus.rb
 licenses:
@@ -47,8 +49,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: God of Monitoring
 test_files: []
+has_rdoc: 

data/lib/monus/built_in_metrics/em_ticks.rb

@@ -1,22 +0,0 @@
-module Monus::BuiltInMetric::EmTicks
-  def activate
-    @interval = Monus.options.dig(:em_ticks_metric_options, :interval) || 1
-
-    counter, time = 0, Time.now
-
-    @tick_loop = EM.tick_loop do
-      counter += 1
-      delta = Time.now - time
-      if delta > @interval
-        ticks = (counter.to_f / delta).round
-        Fiber.new { Monus.set :em_ticks, ticks }.resume
-        counter = 0
-        time = Time.now
-      end
-    end
-  end
-
-  extend self
-
-  Monus::BuiltInMetric.register :em_ticks, self
-end