tinymonrb 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8df6c08b32ccae44e241b41fbd2a98f2033043c37ce6292a2f529869838cb8aa
-  data.tar.gz: 8e924831169fbbbbd9c409c49c10a71428eef4dbd48e9b01345f606230e75eb5
+  metadata.gz: 721bdc7f477b8281a78914201aadf4367fe02206248735b91dc6c564459c4050
+  data.tar.gz: 5b119d9cd4b65d8cef7648b779be6a84f93ffca1c78c7fd0560e63529ca31560
 SHA512:
-  metadata.gz: 27265f4b71e845ffba1f87f3679f6979e7ec5a0175cdbc3399130a2140a8896178554ce72504159f1469674e288ef6a959f0dc84c293ff20a8a4f6b89cf55345
-  data.tar.gz: 0ff34d5f4fa892fb1dc00076ba17746836fd5d2205a4b804ca3cf16ec333e81fb307cdcabbbf0a1b778e1ae8cd8a8ff8392e1affaae381def405c72953af09d1
+  metadata.gz: 911fac08481f040b354966c3baf7d14db96d9a5deab26b86bd077b432c430eca3dcda7c9dc84e0fc600efd344c4c8354c31137651e3b22cada233e976b142a47
+  data.tar.gz: b3cf2caffb694ba16700b9f69d758d2f025d87bae3a4c1849bc10d0899118905a096082b79a29aa87f23b786b69ed48f82fb7231c419c3b2d02bf40e8ef032a2

data/lib/tinymon/client.rb

@@ -37,7 +37,7 @@ module Tinymon
       return if rand > @sample_rate
       event = _prepare(exception)
       return if event.nil?
-      @transport.enqueue(event)
+      @transport.send_event(event)
     rescue StandardError
       # SWALLOW. The SDK must never throw into the host app.
       nil
@@ -48,7 +48,7 @@ module Tinymon
       return if event.nil?
       event["level"] = level
       event["exception"]["type"] = "Message"
-      @transport.enqueue(event)
+      @transport.send_event(event)
     rescue StandardError
       nil
     end
@@ -60,7 +60,15 @@ module Tinymon
       return if rand > @sample_rate
       event = _prepare(exception, ctx: { request: request, user: user, tags: tags })
       return if event.nil?
-      @transport.enqueue(event)
+      @transport.send_event(event)
+    rescue StandardError
+      nil
+    end
+
+    # Block until queued events are delivered (or timeout). Call before a
+    # short-lived process exits so events aren't dropped.
+    def flush(timeout = 2.0)
+      @transport.flush(timeout)
     rescue StandardError
       nil
     end

data/lib/tinymon/transport.rb

@@ -5,46 +5,55 @@ require "net/http"
 require "uri"
 
 module Tinymon
-  # Batched HTTP transport. stdlib-only. A background thread flushes every
-  # 5 seconds; at_exit drains the queue on shutdown.
+  # HTTP transport. stdlib-only. Sends each event immediately on a background
+  # worker thread; events are only queued when the network fails, and that
+  # retry queue is drained with exponential backoff. This matches how
+  # production error SDKs behave — the error lands in the dashboard now, not
+  # on a 5-second timer. at_exit drains anything still pending on shutdown.
   class Transport
-    FLUSH_INTERVAL = 5.0  # seconds
-    MAX_BATCH = 10
-    MAX_QUEUE = 30
-    REQUEST_TIMEOUT = 5  # seconds
+    MAX_QUEUE = 30          # cap on retry buffer (dead-network memory guard)
+    REQUEST_TIMEOUT = 5     # seconds
+    BACKOFF_START = 1.0     # seconds
+    BACKOFF_MAX = 30.0      # seconds
 
     def initialize(endpoint, dsn)
       @endpoint = endpoint
       @dsn = dsn
-      @queue = []
+      @pending = []         # fresh events — sent immediately
+      @retry = []           # failed events — retried with backoff
       @mutex = Mutex.new
+      @cond = ConditionVariable.new
+      @backoff = BACKOFF_START
       @stop = false
       @thread = Thread.new { run_loop }
       @thread.name = "tinymon-transport" if @thread.respond_to?(:name=)
       at_exit { shutdown }
     end
 
-    def enqueue(event)
-      should_flush = false
+    # Queue for immediate send on the worker thread (non-blocking).
+    def send_event(event)
       @mutex.synchronize do
-        @queue.shift while @queue.length >= MAX_QUEUE
-        @queue.push(event)
-        should_flush = @queue.length >= MAX_BATCH
+        @pending.push(event)
+        @cond.signal
       end
-      flush if should_flush
     end
 
-    def flush
-      batch = nil
-      @mutex.synchronize do
-        batch = @queue.shift(MAX_BATCH)
+    # Block until pending + retry events are sent, or timeout elapses.
+    def flush(timeout = 2.0)
+      deadline = monotonic + timeout
+      loop do
+        empty = @mutex.synchronize { @pending.empty? && @retry.empty? }
+        return if empty
+        break if monotonic >= deadline
+        @mutex.synchronize { @cond.signal }
+        sleep(0.02)
       end
-      return if batch.nil? || batch.empty?
-      batch.each { |event| send_one(event) }
     end
 
     private
 
+    # Returns true on success OR an unrecoverable 4xx (retrying a client bug
+    # won't help); false on 5xx / network failure.
     def send_one(event)
       uri = URI.parse(@endpoint)
       http = Net::HTTP.new(uri.host, uri.port)
@@ -57,33 +66,89 @@ module Tinymon
       })
       req.body = JSON.dump(event)
       begin
-        http.request(req)
+        res = http.request(req)
+        code = res.code.to_i
+        return true if code >= 200 && code < 300
+        return true if code >= 400 && code < 500 # client bug — drop, don't retry
+        false
       rescue StandardError
-        # Network failed — re-enqueue if there's room.
-        @mutex.synchronize do
-          @queue.unshift(event) if @queue.length < MAX_QUEUE
-        end
+        false
       end
     end
 
     def run_loop
       until @stop
-        sleep(FLUSH_INTERVAL)
-        begin
-          flush
-        rescue StandardError
-          # swallow — never crash the host app
+        event = next_pending
+        if event
+          queue_retry(event) unless send_one(event)
+          next
+        end
+
+        next if drain_retry
+
+        # Idle — wait for new work or the next retry window.
+        @mutex.synchronize do
+          wait = @retry.empty? ? nil : @backoff
+          @cond.wait(@mutex, wait) unless @stop
+        end
+      end
+    end
+
+    def next_pending
+      @mutex.synchronize { @pending.shift }
+    end
+
+    def queue_retry(event)
+      @mutex.synchronize do
+        @retry.shift while @retry.length >= MAX_QUEUE
+        @retry.push(event)
+      end
+    end
+
+    def drain_retry
+      batch = @mutex.synchronize do
+        next nil if @retry.empty?
+        b = @retry.dup
+        @retry.clear
+        b
+      end
+      return false if batch.nil?
+
+      any_failed = false
+      batch.each do |event|
+        unless send_one(event)
+          any_failed = true
+          queue_retry(event)
         end
       end
+      if any_failed
+        @backoff = [@backoff * 2, BACKOFF_MAX].min
+        sleep(@backoff)
+      else
+        @backoff = BACKOFF_START
+      end
+      true
     end
 
     def shutdown
-      @stop = true
-      begin
-        flush
-      rescue StandardError
-        nil
+      # Best-effort: deliver anything still pending before exit.
+      deadline = monotonic + 2.0
+      while monotonic < deadline
+        event = next_pending
+        event ||= @mutex.synchronize { @retry.shift }
+        break if event.nil?
+        send_one(event)
+      end
+      @mutex.synchronize do
+        @stop = true
+        @cond.broadcast
       end
+    rescue StandardError
+      nil
+    end
+
+    def monotonic
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
   end
 end

data/lib/tinymon/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Tinymon
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
   SDK_NAME = "tinymon.ruby"
 end

data/lib/tinymon.rb

@@ -1,64 +1,7 @@
 # frozen_string_literal: true
 
-require_relative "tinymon/version"
-require_relative "tinymon/stacktrace"
-require_relative "tinymon/event_builder"
-require_relative "tinymon/scope"
-require_relative "tinymon/transport"
-require_relative "tinymon/client"
-require_relative "tinymon/integrations"
-
-# Public API:
-#
-#   require "tinymon"
-#   Tinymon.init(dsn: "tm_pub_xxx", environment: "production", release: "1.0.0")
-#
-#   begin
-#     risky_thing
-#   rescue => e
-#     Tinymon.capture_exception(e)
-#   end
-#
-module Tinymon
-  @client = nil
-
-  class << self
-    def init(dsn:, endpoint: nil, environment: nil, release: nil, sample_rate: 1.0, before_send: nil)
-      @client = Client.new(
-        dsn: dsn,
-        endpoint: endpoint,
-        environment: environment,
-        release: release,
-        sample_rate: sample_rate,
-        before_send: before_send,
-      )
-      Integrations.install(@client)
-      @client
-    end
-
-    def capture_exception(exception)
-      @client&.capture_exception(exception)
-    end
-
-    def capture_message(message, level: "info")
-      @client&.capture_message(message, level: level)
-    end
-
-    def set_user(user)
-      SCOPE.set_user(user)
-    end
-
-    def set_tag(key, value)
-      SCOPE.set_tag(key, value)
-    end
-
-    def add_breadcrumb(crumb)
-      SCOPE.add_breadcrumb(crumb)
-    end
-
-    # Exposed for the cross-language contract test in test/test_contract.rb.
-    def _build_event(exception, **kwargs)
-      EventBuilder.build(exception, **kwargs)
-    end
-  end
-end
+# Back-compat shim. The gem is published as `tinymonrb`, so the canonical
+# entry point is `require "tinymonrb"`. This file only exists so that older
+# code doing `require "tinymon"` keeps working — it loads the full SDK
+# (context capture, Rack middleware, Rails railtie) rather than a partial copy.
+require_relative "tinymonrb"

data/lib/tinymonrb.rb

@@ -66,6 +66,12 @@ module Tinymon
       @client&.capture_message(message, level: level)
     end
 
+    # Block until queued events are delivered (or timeout). Call before a
+    # short-lived process exits so events aren't dropped.
+    def flush(timeout = 2.0)
+      @client&.flush(timeout)
+    end
+
     def set_user(user)
       SCOPE.set_user(user)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tinymonrb
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - tinymon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-06-10 00:00:00.000000000 Z
+date: 2026-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json_schemer