puma_metrics_engine 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ab335fa7843d45934fd97c5442b9bfd3a87006066b6f14ef99123a9316ab165
-  data.tar.gz: 7bd9134d5a436aecebd2a3f2a4073a5b51c46f3fb3d4a8b2391464e108326503
+  metadata.gz: c38944df392cee8b15a51aebd6130426a41421a84441822c94ab97010368b3e7
+  data.tar.gz: 47bcfd77948a243f840f2609d802855a1e441108efa3ec6ce84556d3afebac2a
 SHA512:
-  metadata.gz: c9f71532254eed460c8169a894c41e0ac03c7a089c37a133fc097d7632a0ab2bd2e282bbe84b7cd3ea667ea1adfa9f5a9cb3afc4aaaeb8d470107e5f403ab016
-  data.tar.gz: b704e4c376bdbdad8324b004c71ed20d176dbdda1febaaa63c6c411da33beee40cdb98460671dd8c558feb085a491602f2babc220d3ede42f2d77e90594b00d7
+  metadata.gz: 47940a6f3a8d99b046301df2cf5b5dc31e5236ccfc39a09dae2cdb7d0f2b044cfe09f665f00311e66e9f42cb1e76a3c01f14bc01ebc94fe17ab95418b39378d8
+  data.tar.gz: 406da9dd0fd2721cb640eaf5e772f43fb4a0c2c45eeb6696521cbfe1f28718f61d9bc4cc156341d42991989a450d39a75d81ef81987eb738a64aafde60aaee42

data/lib/puma_metrics_engine/queue_time_tracker.rb

@@ -8,6 +8,12 @@ module PumaMetricsEngine
 
     def initialize(app)
       @app = app
+      @writer = Writer.new(
+        queue_times_key: QUEUE_TIMES_KEY,
+        requests_key: REQUESTS_KEY,
+        redis_url: ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" },
+        after_write: method(:cleanup_old_data)
+      )
     end
 
     def call(env)
@@ -57,7 +63,7 @@ module PumaMetricsEngine
 
       def extract_request_start_time(env)
         # Try X-Request-Start header (common in nginx, HAProxy, etc.)
-        # Format: "t=1234567890.123" or "1234567890.123" or Unix timestamp in microseconds
+        # Format: "t=1234567890.123" or "1234567890.123" or Unix timestamp in milliseconds/microseconds
         header_value = env["HTTP_X_REQUEST_START"] || env["X-Request-Start"]
 
         return nil unless header_value
@@ -75,10 +81,25 @@ module PumaMetricsEngine
 
         timestamp = timestamp_str.to_f
 
-        # If timestamp is in microseconds (common with nginx), convert to seconds
-        # Timestamps > year 2100 are likely in microseconds
+        # Detect timestamp format based on magnitude:
+        # - 10 digits or less: seconds (e.g., 1764410986)
+        # - 11-13 digits: milliseconds (e.g., 1764410986245)
+        # - 14+ digits: microseconds (e.g., 1764410986245000)
         if timestamp > 4_102_444_800 # Year 2100 in seconds
-          timestamp = timestamp / 1_000_000.0
+          # Count digits in integer part to determine format
+          integer_part = timestamp.to_i.to_s
+          digit_count = integer_part.length
+
+          if digit_count <= 10
+            # Already in seconds
+            timestamp
+          elsif digit_count <= 13
+            # Milliseconds - convert to seconds
+            timestamp = timestamp / 1_000.0
+          else
+            # Microseconds - convert to seconds
+            timestamp = timestamp / 1_000_000.0
+          end
         end
 
         timestamp
@@ -87,34 +108,11 @@ module PumaMetricsEngine
       end
 
       def store_metrics_async(timestamp, queue_time_ms)
-        # Use a thread pool or async job, but for simplicity, we'll do it synchronously
-        # In production, you might want to use a background job
-        Thread.new do
-          begin
-            redis_client = redis
-            # Store queue time with timestamp as score
-            redis_client.zadd(QUEUE_TIMES_KEY, timestamp, queue_time_ms)
-            # Store request timestamp
-            redis_client.zadd(REQUESTS_KEY, timestamp, timestamp)
-            # Cleanup old data (older than TTL)
-            cleanup_old_data(redis_client)
-          rescue StandardError => e
-            Rails.logger.error("[QueueTimeTracker] Failed to store metrics: #{e.message}") if defined?(Rails)
-            Rails.logger.error("[QueueTimeTracker] Redis error backtrace: #{e.backtrace.first(3).join("\n")}") if defined?(Rails)
-          end
-        end
+        @writer.record(timestamp, queue_time_ms)
       end
 
       def store_request_timestamp_async(timestamp)
-        Thread.new do
-          begin
-            redis_client = redis
-            redis_client.zadd(REQUESTS_KEY, timestamp, timestamp)
-            cleanup_old_data(redis_client)
-          rescue StandardError => e
-            Rails.logger.error("[QueueTimeTracker] Failed to store request timestamp: #{e.message}") if defined?(Rails)
-          end
-        end
+        @writer.record(timestamp, nil)
       end
 
       def cleanup_old_data(redis_client)
@@ -126,10 +124,6 @@ module PumaMetricsEngine
         redis_client.zremrangebyscore(QUEUE_TIMES_KEY, "-inf", cutoff_time)
         redis_client.zremrangebyscore(REQUESTS_KEY, "-inf", cutoff_time)
       end
-
-      def redis
-        @redis ||= Redis.new(url: ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" })
-      end
   end
 end
 

data/lib/puma_metrics_engine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PumaMetricsEngine
-  VERSION = "1.2.0"
+  VERSION = "1.3.0"
 end

data/lib/puma_metrics_engine/writer.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module PumaMetricsEngine
+  # Sends samples to Redis from one background thread, so a request never
+  # waits on Redis and no thread is started per request.
+  #
+  # Each sample gets a random suffix in its sorted-set member. Members are
+  # unique, so storing the bare value made equal values overwrite each other.
+  # Readers parse members with String#to_f, which stops at the colon, so they
+  # read "12.5:1a2b3c4d" as 12.5 without any change.
+  class Writer
+    # Samples waiting to be written. When Redis is unreachable the queue stops
+    # growing here and new samples are dropped instead.
+    MAX_PENDING = 10_000
+    BATCH_SIZE = 500
+
+    def initialize(queue_times_key:, requests_key:, redis_url:, after_write: nil)
+      @queue_times_key = queue_times_key
+      @requests_key = requests_key
+      @redis_url = redis_url
+      @after_write = after_write
+      @queue = Thread::Queue.new
+      @mutex = Mutex.new
+      @thread = nil
+      @pid = nil
+    end
+
+    # queue_time_ms is nil when the request carried no usable start time; the
+    # request still counts towards requests per minute.
+    def record(timestamp, queue_time_ms)
+      ensure_thread
+      return if @queue.size >= MAX_PENDING
+
+      @queue << [timestamp, queue_time_ms]
+    end
+
+    private
+
+      def ensure_thread
+        return if running?
+
+        @mutex.synchronize do
+          next if running?
+
+          # After a fork the thread and connection belong to the parent.
+          if @pid != Process.pid
+            @queue = Thread::Queue.new
+            @redis = nil
+          end
+          @pid = Process.pid
+          @thread = Thread.new { run }
+          @thread.name = "puma_metrics_writer"
+        end
+      end
+
+      def running?
+        @pid == Process.pid && @thread&.alive?
+      end
+
+      def run
+        loop do
+          write(next_batch)
+        rescue StandardError => e
+          log_error(e)
+          sleep(1)
+        end
+      end
+
+      def next_batch
+        batch = [@queue.pop]
+        while batch.size < BATCH_SIZE
+          sample = begin
+            @queue.pop(true)
+          rescue ThreadError
+            break
+          end
+          batch << sample
+        end
+        batch
+      end
+
+      def write(batch)
+        queue_times = []
+        requests = []
+        batch.each do |timestamp, queue_time_ms|
+          id = SecureRandom.hex(4)
+          queue_times << [timestamp, "#{queue_time_ms}:#{id}"] if queue_time_ms
+          requests << [timestamp, "#{timestamp}:#{id}"]
+        end
+
+        redis.pipelined do |pipeline|
+          pipeline.zadd(@queue_times_key, queue_times) if queue_times.any?
+          pipeline.zadd(@requests_key, requests)
+        end
+        @after_write&.call(redis)
+      end
+
+      def redis
+        @redis ||= Redis.new(url: @redis_url)
+      end
+
+      def log_error(error)
+        return unless defined?(Rails) && Rails.logger
+
+        Rails.logger.error("[QueueTimeTracker] Failed to store metrics: #{error.class}: #{error.message}")
+      end
+  end
+end

data/lib/puma_metrics_engine.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "rails"
+require "redis"
 require "puma_metrics_engine/version"
+require "puma_metrics_engine/writer"
 require "puma_metrics_engine/queue_time_tracker"
 require "puma_metrics_engine/engine"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: puma_metrics_engine
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
-- Neeto
-autorequire:
+- Neeraj Singh
 bindir: exe
 cert_chain: []
-date: 2025-11-29 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -94,20 +93,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.12'
-- !ruby/object:Gem::Dependency
-  name: fakeredis
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
@@ -139,7 +124,7 @@ dependencies:
 description: A Rails engine that exposes Puma server metrics, queue time statistics,
   and request rate information via a /matrix endpoint
 email:
-- engineering@bigbinary.com
+- neeraj@neeto.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -153,14 +138,14 @@ files:
 - lib/puma_metrics_engine/engine.rb
 - lib/puma_metrics_engine/queue_time_tracker.rb
 - lib/puma_metrics_engine/version.rb
-homepage: https://github.com/bigbinary/puma_metrics_engine
+- lib/puma_metrics_engine/writer.rb
+homepage: https://github.com/neetozone/puma_metrics_engine
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/bigbinary/puma_metrics_engine
-  source_code_uri: https://github.com/bigbinary/puma_metrics_engine
-  changelog_uri: https://github.com/bigbinary/puma_metrics_engine/blob/main/CHANGELOG.md
-post_install_message:
+  homepage_uri: https://github.com/neetozone/puma_metrics_engine
+  source_code_uri: https://github.com/neetozone/puma_metrics_engine
+  changelog_uri: https://github.com/neetozone/puma_metrics_engine/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -175,8 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.10
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Rails engine that provides a /matrix endpoint for Puma metrics and queue
   time statistics