async-background 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6668497aee969150ccc5e31b7c9ec57a47c2b107aa337686393262ee2b78f429
-  data.tar.gz: 3cbf76732b4987bfa5d7c9257b529c716e0adfec11e7d02f6a4105b5c5ce54e1
+  metadata.gz: 00b7ba6035c743fb4c4568d2309da4bc7f454a3cbe5e17ac5d2251a417a4a31c
+  data.tar.gz: a3dff9b2b51f590a095120a18f1e3d5424b339ab5a6cff90b148f8e9316ee242
 SHA512:
-  metadata.gz: 5f75ed0c52dda7d988fbf73fa701c00f3c6ff3b869cd36d6566593c9a8095134721a011ada08c337206d64348f919ca807c77e07dd43c4c14f31c637f58769d4
-  data.tar.gz: 0b00eb1e333173929e788103042dcd2c3be4696da0acad65a2f5d6bc0bdc6e5bbeeccf0353ad27af7281d0d62aaf3342c1c9d1f8ce8594caee18dc28435e645a
+  metadata.gz: b9c36893b1cb14ba251d9c5a1c614ac50b988ffcbd69c43a876c1e0a2995ee749592618c2e328d2e05573ccf46186616a59615d7c01a785b28fe5897a1e0650f
+  data.tar.gz: 3f47cf30226b45b6c543f48812e95778206e9cccc07445c5066e32cdf88a71f68bf88be9f0134750344cd7e0ed8df1a907107d0e5a3c910ce00a3a493ea700e7

data/lib/async/background/metrics.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Async
+  module Background
+    class Metrics
+      SCHEMA_FIELDS = {
+        total_runs:       :u64,
+        total_successes:  :u64,
+        total_failures:   :u64,
+        total_timeouts:   :u64,
+        total_skips:      :u64,
+        active_jobs:      :u32,
+        last_run_at:      :u64,
+        last_duration_ms: :u32
+      }.freeze
+
+      attr_reader :registry
+
+      def initialize(worker_index:, total_workers:, shm_path: self.class.default_shm_path)
+        require 'async/utilization'
+
+        @registry = nil
+        @enabled  = false
+        @registry = ::Async::Utilization::Registry.new
+        @enabled  = true
+
+        ensure_shm!(total_workers, shm_path)
+        attach_observer!(worker_index, total_workers, shm_path)
+      rescue LoadError
+      end
+
+      def enabled?
+        @enabled
+      end
+
+      def job_started(entry)
+        return unless @enabled
+
+        @registry.increment(:total_runs)
+        @registry.increment(:active_jobs)
+        @registry.set(:last_run_at, Process.clock_gettime(Process::CLOCK_REALTIME).to_i)
+      end
+
+      def job_finished(entry, duration)
+        return unless @enabled
+
+        @registry.decrement(:active_jobs)
+        @registry.increment(:total_successes)
+        @registry.set(:last_duration_ms, (duration * 1000).to_i)
+      end
+
+      def job_failed(entry, error)
+        return unless @enabled
+
+        @registry.decrement(:active_jobs)
+        @registry.increment(:total_failures)
+      end
+
+      def job_timed_out(entry)
+        return unless @enabled
+
+        @registry.decrement(:active_jobs)
+        @registry.increment(:total_timeouts)
+      end
+
+      def job_skipped(entry)
+        return unless @enabled
+
+        @registry.increment(:total_skips)
+      end
+
+      def values
+        return {} unless @enabled
+
+        @registry.values
+      end
+
+      def self.schema
+        require 'async/utilization'
+        ::Async::Utilization::Schema.build(SCHEMA_FIELDS)
+      end
+
+      # Read metrics for all workers from the shm file.
+      # No server needed — just reads the mmap'd file.
+      #
+      #   Async::Background::Metrics.read_all(total_workers: 2)
+      #   # => [
+      #   #   { worker: 1, total_runs: 142, active_jobs: 1, ... },
+      #   #   { worker: 2, total_runs: 98,  active_jobs: 0, ... }
+      #   # ]
+      #
+      def self.read_all(total_workers:, path: default_shm_path)
+        require 'async/utilization'
+
+        s = schema
+        segment = segment_size
+        file_size = segment * total_workers
+
+        buffer = File.open(path, "rb") do |f|
+          IO::Buffer.map(f, file_size, 0)
+        end
+
+        (1..total_workers).map do |i|
+          base = (i - 1) * segment
+          row = { worker: i }
+          s.fields.each do |field|
+            row[field.name] = buffer.get_value(field.type, base + field.offset)
+          end
+          row
+        end
+      end
+
+      def self.default_shm_path
+        File.join(Dir.tmpdir, "async-background.shm")
+      end
+
+      def self.segment_size
+        SCHEMA_FIELDS.sum { |_, type| IO::Buffer.size_of(type) }
+      end
+
+      private
+
+      def ensure_shm!(total_workers, path)
+        required = self.class.segment_size * total_workers
+
+        File.open(path, File::CREAT | File::RDWR, 0644) do |f|
+          f.flock(File::LOCK_EX)
+          f.truncate(required) if f.size < required
+          f.flock(File::LOCK_UN)
+        end
+      end
+
+      def attach_observer!(worker_index, total_workers, path)
+        segment = self.class.segment_size
+        offset  = (worker_index - 1) * segment
+        observer = ::Async::Utilization::Observer.open(
+          self.class.schema, path, segment, offset
+        )
+        @registry.observer = observer
+      end
+    end
+  end
+end

data/lib/async/background/runner.rb

@@ -12,7 +12,7 @@ module Async
     MAX_JITTER      = 5
 
     class Runner
-      attr_reader :logger, :semaphore, :heap, :worker_index, :total_workers, :shutdown
+      attr_reader :logger, :semaphore, :heap, :worker_index, :total_workers, :shutdown, :metrics
 
       def initialize(config_path:, job_count: 2, worker_index:, total_workers:)
         @logger        = Console.logger
@@ -20,6 +20,7 @@ module Async
         @total_workers = total_workers
         @running       = true
         @shutdown      = ::Async::Condition.new
+        @metrics       = Metrics.new(worker_index: worker_index, total_workers: total_workers)
 
         logger.info { "Async::Background worker_index=#{worker_index}/#{total_workers}, job_count=#{job_count}" }
 
@@ -47,6 +48,7 @@ module Async
 
               if entry.running
                 logger.warn('Async::Background') { "#{entry.name}: skipped, previous run still active" }
+                metrics.job_skipped(entry)
               else
                 entry.running = true
                 semaphore.async do
@@ -180,14 +182,20 @@ module Async
       end
 
       def run_job(task, entry)
+        metrics.job_started(entry)
         t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         task.with_timeout(entry.timeout) { entry.job_class.perform_now }
+
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - t
+        metrics.job_finished(entry, duration)
         logger.info('Async::Background') {
-          "#{entry.name}: completed in #{(Process.clock_gettime(Process::CLOCK_MONOTONIC) - t).round(2)}s"
+          "#{entry.name}: completed in #{duration.round(2)}s"
         }
       rescue ::Async::TimeoutError
+        metrics.job_timed_out(entry)
         logger.error('Async::Background') { "#{entry.name}: timed out after #{entry.timeout}s" }
       rescue => e
+        metrics.job_failed(entry, e)
         logger.error('Async::Background') {
           "#{entry.name}: #{e.class} #{e.message}\n#{e.backtrace.join("\n")}"
         }

data/lib/async/background/version.rb

@@ -2,6 +2,6 @@
 
 module Async
   module Background
-    VERSION = '0.2.6'
+    VERSION = '0.3.0'
   end
 end

data/lib/async/background.rb

@@ -4,8 +4,10 @@ require 'async'
 require 'async/semaphore'
 require 'console'
 require 'fugit'
+require 'tmpdir'
 
 require_relative 'background/version'
 require_relative 'background/min_heap'
 require_relative 'background/entry'
+require_relative 'background/metrics'
 require_relative 'background/runner'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-background
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - Roman Hajdarov
@@ -92,6 +92,7 @@ extra_rdoc_files: []
 files:
 - lib/async/background.rb
 - lib/async/background/entry.rb
+- lib/async/background/metrics.rb
 - lib/async/background/min_heap.rb
 - lib/async/background/runner.rb
 - lib/async/background/version.rb