restless-sdk 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e4d46a242b46c64f20924eab0d2d41387a77abbc50a3eb008f133f7073fb344
-  data.tar.gz: b007f007343dbba867b331137b35a106e44a5b5569bbc8ee2762a1390709f94f
+  metadata.gz: 82907e8d32a7662ffb2e9aa15b19a7866578451c0b14fe1cb60196a04d26703a
+  data.tar.gz: 030f27989031f51461208c12cbe9f1c2499303abfb9d74e713db995aea9fd39b
 SHA512:
-  metadata.gz: ff857105fd9427f2f19d8c39c76c743eb57e2ac8a834acea71d43d4bd4caceeb4fe67001188d2e08308b19636da303fbc9faf05b0927a558405765a14176bf2f
-  data.tar.gz: 56a95c3f28179c558a2c59d566c2bb4916c2d4b223d5660a89fa83db403468f1fdbe22ca8a74486a2b86013f82be2d3326d6eafebe91c13d5a4b5057971d671d
+  metadata.gz: c4ce380faaa258e6d4b91fe557ccd47fcf4731bc6e59ba731cab405e207d52118f00c7d4f59f0c432301a600dd9d2e9aa048fe09194a8e96f89cefee654b3663
+  data.tar.gz: c500e8a60dcda664336a64c947d66e113aa422cdafe31b251e13c7f0e26be9c55045d57436a1bf87c90ba01bc13315546284c030dd753273360790d475ea7d06

data/CONFORMANCE.md

@@ -2,7 +2,7 @@
 
 | | |
 |---|---|
-| **Spec version** | 1.2.0 |
+| **Spec version** | 1.3.0 |
 | **Level** | L2 (core + batching, caches, injection, safety) |
 | **Reference** | `restlesshq/node` (`@restlessai/sdk`) |
 | **Driver** | `ruby exe/restless-conformance` |
@@ -79,6 +79,11 @@ the reference. They are the reason this SDK is byte-compatible.
 | INJECT-005 | `Text.ws_trim`, not `String#strip`. Ruby's strip removes NUL and leaves NBSP; the contract wants exactly the PRIM-002 set. |
 | BATCH-003 | The environment indicator is `RESTLESS_ENV`, then `RACK_ENV`, then `RAILS_ENV`. Ruby has three spellings in the wild and no single winner. |
 | BATCH-008 | Test detection keys on those same variables being `test`, plus `RSpec::Core`, `Minitest::Test` and `Test::Unit::TestCase` being defined. |
+| BATCH-009 | A slot is a worker thread, counted under the uploader's `Mutex`. A worker that finishes takes the next batch itself (up to 100, BATCH-010) instead of handing off, and releases its slot in an `ensure`, so a killed thread cannot leak one. `flush` waits on a `ConditionVariable` that every release broadcasts. |
+| BATCH-009 (forking) | Puma and Unicorn fork after the app loads. The child inherits the slot count and queue but none of the threads behind them, so a stale count would block uploads forever. The uploader records `Process.pid` and starts the child from a clean state (new `Mutex`, empty queue, zero slots). The parent's queue is dropped in the child rather than sent twice. |
+| WIRE-026 | "Never reached the ingest" is `Errno::ECONNREFUSED` and `SocketError` (DNS). `Net::HTTP` re-raises a connect failure with the same class, so the classification holds on a real socket (`test/test_uploader.rb` checks one). `Retry-After` is parsed with `Float()` (seconds) and then `Time.httpdate`. |
+| WIRE-027 | `Net::ReadTimeout`, `Net::OpenTimeout`, `Timeout::Error`, `Errno::ECONNRESET`, `EOFError` and everything else fall through to the drop. `max_retries = 0` keeps `Net::HTTP` from resending on its own. |
+| WIRE-028 | `open_timeout`, `read_timeout` and `write_timeout` are per operation, so a slow-trickling response could outlive them. The whole exchange also runs inside `Timeout.timeout(10)`. |
 | CACHE-* | Both caches are Mutex-guarded. Puma, Falcon and threaded Unicorn all serve requests on many threads, so an unsynchronized Hash is a real race. |
 
 ## Exemption: PRIM-034 (unpaired surrogates)

data/README.md

@@ -188,6 +188,15 @@ and swallowed (surfaced only under `DEBUG=restless`). Uploads happen on a
 background thread and are fire-and-forget. Streaming responses
 (`text/event-stream`) and bodies over 1 MiB are never buffered.
 
+It also stays bounded when Restless is slow or busy. At most 4 uploads run at
+once, each with a 10 s timeout; captures queue behind them (up to 1000, oldest
+dropped first) and a freed slot sends up to 100 at a time to catch up. An
+upload Restless turns away with `503` or `429` is retried up to twice, waiting
+for its `Retry-After` (at most 10 s). Anything Restless may already have
+stored, such as a `502`, `504`, timeout or dropped connection, is never resent,
+so a log is never doubled. `flush` waits for all of it, retries included. A
+worker forked by Puma or Unicorn starts with its own empty queue.
+
 An exception your app raises is captured with its stack - so the error
 fingerprint keys on the method that raised, not on the middleware - and then
 re-raised untouched, leaving your own error handling completely unaffected.
@@ -203,7 +212,7 @@ re-raised untouched, leaving your own error handling completely unaffected.
 
 ## Conformance
 
-This SDK implements version 1.2.0 of the Restless SDK Contract at level L2,
+This SDK implements version 1.3.0 of the Restless SDK Contract at level L2,
 and is verified against the shared cross-language conformance vectors and a
 differential fuzzer run against the reference implementation. See
 [CONFORMANCE.md](./CONFORMANCE.md).

data/install.md

@@ -50,7 +50,7 @@ The client exposes four things:
 | `setup(&block)` | Register the per-request callback. Takes a block or any callable. |
 | `mask(key)` | Hash an end-user API key for safe logging. |
 | `rack` | The middleware factory to mount. |
-| `flush` | Force-upload the current batch (e.g. before exit). |
+| `flush` | Upload everything queued and wait for it, retries included (e.g. before exit). |
 
 `Restless.new` and `Restless::Client.new` are the same thing. `mask` is also available as `Restless.mask` without a client, for scripts and tests.
 
@@ -299,7 +299,16 @@ The handler never runs. The response body is JSON `{"error": "<message>"}`. `enr
 | `DEBUG=restless` | Print upload diagnostics to stderr |
 | `RESTLESS_SETUP_MODE=1` | Upload even under a test runner (see below) |
 
-Batching is fixed: 10 requests per batch, a 5000 ms flush interval, a 1000-entry queue that drops oldest on overflow, and immediate flushing against a localhost base URL. Uploads never block a response, and failures are swallowed unless `DEBUG=restless`.
+Batching is fixed, with no config:
+
+- 10 requests per batch, a 5000 ms flush interval, and immediate flushing outside production or against a localhost base URL
+- A 1000-entry queue that drops oldest on overflow
+- At most 4 uploads in flight; while capped, each freed slot sends up to 100 queued entries
+- Upload timeout: 10 s
+- Retries: only `503`/`429` (honouring `Retry-After`, max 2 retries, max 10 s wait) and connections that never reached the ingest (refused, DNS failure). Never `502`/`504`, timeouts or dropped connections, which the ingest may already have stored.
+- Safe under forking servers (Puma, Unicorn): a forked worker starts with an empty queue and its own uploads.
+
+Uploads run on background threads and never block a response. Failures are swallowed unless `DEBUG=restless`. There is nothing to configure here and nothing to add to the user's code.
 
 **Test runs do not upload.** Detected via `RAILS_ENV`/`RACK_ENV` of `test`, or RSpec / Minitest / Test::Unit being loaded. Capture still runs, so your tests exercise the real path.
 

data/lib/restless/uploader.rb

@@ -2,6 +2,8 @@
 
 require "json"
 require "net/http"
+require "time"
+require "timeout"
 require "uri"
 
 require_relative "env"
@@ -9,37 +11,40 @@ require_relative "har"
 require_relative "version"
 
 module Restless
-  # CONTRACT.md sections 8 (wire format) and 9 (batching).
-  #
-  # Never raises to callers. Upload failures go to stderr under the debug flag
-  # and are otherwise swallowed: observability must not break the request path
-  # (SAFETY-004, SAFETY-008).
+  # CONTRACT.md sections 8 (wire format) and 9 (batching). Never raises to
+  # callers; failures surface only under the debug flag (SAFETY-004, SAFETY-008).
   class Uploader
     BATCH_SIZE = 10          # BATCH-001
     FLUSH_INTERVAL_MS = 5000 # BATCH-002
     MAX_QUEUE = 1000         # BATCH-004
-    HTTP_TIMEOUT_S = 10
+    MAX_IN_FLIGHT = 4        # BATCH-009
+    MAX_UPLOAD_ENTRIES = 100 # BATCH-010
+    HTTP_TIMEOUT_S = 10      # WIRE-028
+    MAX_RETRIES = 2          # WIRE-026
+    RETRY_BASE_S = 1.0
+    MAX_RETRY_DELAY_S = 10.0
+
+    # Failures where the request never reached the ingest, so a resend cannot
+    # duplicate (WIRE-026). SocketError is a DNS lookup failure.
+    NOT_SENT_ERRORS = [Errno::ECONNREFUSED, SocketError].freeze
 
     attr_reader :base_url, :request_id_prefix
 
-    # `sampling_hash` is the SAMPLE-040 hash of a non-default sampling config,
-    # stamped on every upload as `x-restless-sampling` (SAMPLE-052). Nil when
-    # sampling is not configured, and then no header is sent at all.
+    # `sampling_hash` is the SAMPLE-040 hash stamped on every upload as
+    # `x-restless-sampling` (SAMPLE-052); nil sends no header at all.
     def initialize(api_key:, base_url:, request_id_prefix: nil, on_response: nil,
-                   sampling_hash: nil, transport: nil)
+                   sampling_hash: nil, transport: nil, sleeper: nil)
       @api_key = api_key.to_s
       @sampling_hash = sampling_hash
       @base_url = base_url.to_s
       @request_id_prefix = request_id_prefix
       @on_response = on_response
-      # Test hook. Anything responding to
-      # `call(url, headers, body) -> [status, body]`.
+      # Test hooks: `transport.call(url, headers, body) -> [status, body, headers]`
+      # and `sleeper.call(seconds)` in place of a real retry wait.
       @transport = transport
+      @sleeper = sleeper
 
-      @queue = []
-      @mutex = Mutex.new
-      @timer = nil
-      @inflight = []
+      reset_state
 
       warn_if_insecure
     end
@@ -66,41 +71,63 @@ module Restless
       # BATCH-008.
       return if Env.test_run? && !Env.setup_mode?
 
-      batch = nil
-      @mutex.synchronize do
+      reset_after_fork
+      batches = @mutex.synchronize do
         if @queue.length >= MAX_QUEUE
-          # Drop the OLDEST. The newest entries are the ones an operator is
-          # actively debugging.
+          # Drop the OLDEST: the newest are what an operator is debugging.
           @queue.shift
           Env.debug_log("queue at #{MAX_QUEUE} -- dropping oldest captured request")
         end
         @queue << captured
 
-        if flush_immediately? || @queue.length >= BATCH_SIZE
-          batch = take_batch
+        if flush_immediately?
+          take_batches(true)
+        elsif @queue.length >= BATCH_SIZE
+          take_batches(false)
         else
           start_timer
+          []
         end
       end
 
-      upload_async(batch) if batch
+      start_workers(batches)
+      nil
+    rescue StandardError => e
+      Env.debug_log("push failed: #{e.class}: #{e.message}")
       nil
     end
 
-    # BATCH-005, BATCH-006, BATCH-007. Synchronous: resolves when the attempt
-    # completes.
+    # BATCH-005 to BATCH-007. Uploads everything queued, at most MAX_IN_FLIGHT
+    # at a time, and returns once all of it has settled, retries included.
     def flush
-      batch = @mutex.synchronize { take_batch }
-      upload(batch) unless batch.nil? || batch.empty?
-      join_inflight
+      reset_after_fork
+      @mutex.synchronize do
+        cancel_timer
+        @draining += 1
+        begin
+          loop do
+            start_workers(take_batches(true))
+            break if @queue.empty? && @active.zero?
+
+            # Timed only as a guard against a worker that vanished without
+            # releasing its slot; every real release broadcasts.
+            @cond.wait(@mutex, 1.0)
+          end
+        ensure
+          @draining -= 1
+        end
+      end
+      join_reports
+      nil
+    rescue StandardError => e
+      Env.debug_log("flush failed: #{e.class}: #{e.message}")
       nil
     end
 
-    # SAMPLE-050, SAMPLE-051. POST the sampling report on a background
-    # thread, then yield (on that thread) however it went. Same gates as an
-    # upload: nothing under a test runner or without a project key. Never
-    # raises, never retries.
+    # SAMPLE-050, SAMPLE-051. POST the sampling report on a background thread,
+    # then yield on that thread. Same gates as an upload; never raises or retries.
     def send_sampling_report_async(report, &on_done)
+      reset_after_fork
       thread = Thread.new do
         begin
           send_sampling_report(report)
@@ -113,7 +140,10 @@ module Restless
         end
       end
       thread.abort_on_exception = false
-      track(thread)
+      @mutex.synchronize do
+        @reports.reject! { |t| !t.alive? }
+        @reports << thread
+      end
       nil
     end
 
@@ -127,9 +157,25 @@ module Restless
 
     private
 
-    # BATCH-003. Flush every push when the app is not in production, or when
-    # the ingest is on localhost. Both keep the customer dev loop and
-    # self-hosted setups low-latency.
+    def reset_state
+      @pid = Process.pid
+      @mutex = Mutex.new
+      @cond = ConditionVariable.new
+      @queue = []
+      @active = 0   # uploads holding a BATCH-009 slot, including retry waits
+      @draining = 0 # flushes in progress, which let partial batches through
+      @timer = nil
+      @reports = []
+    end
+
+    # Puma and Unicorn fork after the app loads: the child inherits this state
+    # but none of its threads, so it starts clean rather than count dead slots.
+    def reset_after_fork
+      reset_state unless @pid == Process.pid
+    end
+
+    # BATCH-003. Outside production, or against a localhost ingest, every push
+    # flushes, keeping the dev loop and self-hosted setups low-latency.
     def flush_immediately?
       return true unless Env.production?
       return true if Env.localhost?(@base_url)
@@ -137,16 +183,68 @@ module Restless
       false
     end
 
-    # Caller holds @mutex.
-    def take_batch
-      cancel_timer
-      return nil if @queue.empty?
+    # Caller holds @mutex. Claims a slot per batch; `partial` lets a batch
+    # under BATCH_SIZE go (BATCH-010).
+    def take_batches(partial)
+      # BATCH-007. No key: drop everything, never retry or accumulate.
+      unless api_key?
+        Env.debug_log("no API key -- dropping batch of #{@queue.length}") unless @queue.empty?
+        @queue.clear
+        cancel_timer
+        return []
+      end
 
-      batch = @queue
-      @queue = []
+      batches = []
+      while @active < MAX_IN_FLIGHT && !@queue.empty? && (partial || @queue.length >= BATCH_SIZE)
+        batches << @queue.shift(MAX_UPLOAD_ENTRIES)
+        @active += 1
+      end
+      cancel_timer if @queue.empty?
+      batches
+    end
+
+    # Caller holds @mutex. The next batch for a worker whose upload just
+    # finished, or nil when it should give its slot back.
+    def next_batch
+      return nil if @queue.empty? || !api_key?
+      return nil unless flush_immediately? || @draining.positive? || @queue.length >= BATCH_SIZE
+
+      batch = @queue.shift(MAX_UPLOAD_ENTRIES)
+      cancel_timer if @queue.empty?
       batch
     end
 
+    # Caller holds @mutex. A remainder under BATCH_SIZE waits for the timer.
+    def release_slot
+      @active -= 1
+      start_timer unless @queue.empty?
+      @cond.broadcast
+    end
+
+    # SAFETY-008. Uploads run on background threads, never the request thread.
+    def start_workers(batches)
+      batches.each do |batch|
+        thread = Thread.new(batch) { |b| run_worker(b) }
+        thread.abort_on_exception = false
+        thread.report_on_exception = false
+      end
+    end
+
+    # One slot. It keeps sending while a backlog is waiting, then frees itself.
+    def run_worker(batch)
+      holding = true
+      while holding
+        send_batch(batch)
+        @mutex.synchronize do
+          batch = next_batch
+          holding = !batch.nil?
+          release_slot unless holding
+        end
+      end
+    ensure
+      @mutex.synchronize { release_slot } if holding
+    end
+
     # Caller holds @mutex.
     def start_timer
       return if @timer
@@ -154,11 +252,11 @@ module Restless
       @timer = Thread.new do
         sleep(FLUSH_INTERVAL_MS / 1000.0)
         begin
-          batch = @mutex.synchronize do
+          batches = @mutex.synchronize do
             @timer = nil
-            @queue.empty? ? nil : take_batch_unsafe
+            take_batches(true)
           end
-          upload(batch) if batch
+          start_workers(batches)
         rescue StandardError => e
           Env.debug_log("flush timer failed: #{e.class}: #{e.message}")
         end
@@ -166,14 +264,6 @@ module Restless
       @timer.abort_on_exception = false
     end
 
-    # Like take_batch but without cancelling the timer, which the timer thread
-    # has already cleared.
-    def take_batch_unsafe
-      batch = @queue
-      @queue = []
-      batch
-    end
-
     # Caller holds @mutex.
     def cancel_timer
       timer = @timer
@@ -181,20 +271,10 @@ module Restless
       timer.kill if timer && timer != Thread.current
     end
 
-    # SAFETY-008. The capture path performs no blocking I/O; uploads are
-    # asynchronous and fire-and-forget.
-    def upload_async(batch)
-      thread = Thread.new { upload(batch) }
-      thread.abort_on_exception = false
-      track(thread)
-    end
-
-    # `flush` joins these, so it also waits for an in-flight sampling report.
-    def track(thread)
-      @mutex.synchronize do
-        @inflight.reject! { |t| !t.alive? }
-        @inflight << thread
-      end
+    def join_reports
+      threads = @mutex.synchronize { @reports.dup }
+      threads.each { |t| t.join(HTTP_TIMEOUT_S) }
+      @mutex.synchronize { @reports.reject! { |t| !t.alive? } }
     end
 
     def send_sampling_report(report)
@@ -216,27 +296,13 @@ module Restless
       nil
     end
 
-    def join_inflight
-      threads = @mutex.synchronize { @inflight.dup }
-      threads.each { |t| t.join(HTTP_TIMEOUT_S) }
-      @mutex.synchronize { @inflight.reject! { |t| !t.alive? } }
-    end
-
-    def upload(batch)
-      return if batch.nil? || batch.empty?
-
-      # BATCH-007. No key: drop the batch, never retry or accumulate.
-      unless api_key?
-        Env.debug_log("no API key -- dropping batch of #{batch.length}")
-        return
-      end
-
+    # One upload, holding its slot through any retries. Only what the ingest
+    # certainly did not store is resent (WIRE-024, WIRE-026, WIRE-027).
+    def send_batch(batch)
       fingerprints = distinct_fingerprints(batch)
-      payload = batch.map { |captured| entry_for(captured) }
+      # WIRE-004: a JSON ARRAY, even for a single capture.
+      body = JSON.generate(batch.map { |captured| entry_for(captured) })
       url = "#{@base_url}/v1/request" # WIRE-001
-
-      Env.debug_log("uploading #{batch.length} entr#{batch.length == 1 ? 'y' : 'ies'} to #{url}")
-
       headers = {
         "Content-Type" => "application/json",           # WIRE-002
         "Authorization" => "Bearer #{@api_key}",        # WIRE-003
@@ -245,23 +311,85 @@ module Restless
       }
       headers["x-restless-sampling"] = @sampling_hash if @sampling_hash # SAMPLE-052
 
-      # WIRE-004: a JSON ARRAY, even for a single capture.
-      status, body = send_request(url, headers, JSON.generate(payload))
+      attempt = 0
+      loop do
+        Env.debug_log("uploading #{batch.length} entr#{batch.length == 1 ? 'y' : 'ies'} to #{url}" \
+                      "#{attempt.positive? ? " (retry #{attempt})" : ''}")
+        begin
+          status, response_body, response_headers = send_request(url, headers, body)
+        rescue *NOT_SENT_ERRORS => e
+          raise unless attempt < MAX_RETRIES
+
+          Env.debug_log("upload not sent (#{e.class}); retrying")
+          pause(retry_delay(nil, attempt))
+          attempt += 1
+          next
+        end
+
+        if status.is_a?(Integer) && status >= 200 && status < 300
+          handle_response(response_body, fingerprints)
+          return
+        end
+
+        if [503, 429].include?(status) && attempt < MAX_RETRIES
+          wait = retry_delay(header_value(response_headers, "retry-after"), attempt)
+          Env.debug_log("upload refused (#{status}); retrying in #{(wait * 1000).round}ms")
+          pause(wait)
+          attempt += 1
+          next
+        end
 
-      # WIRE-024: a non-2xx is never retried and never raises. The batch is
-      # dropped.
-      unless status && status >= 200 && status < 300
         Env.debug_log("upload failed: #{status.inspect}")
         return
       end
-
-      handle_response(body, fingerprints)
     rescue StandardError => e
-      # SAFETY-004.
+      # SAFETY-004. Timeouts and resets land here and are never retried.
       Env.debug_log("upload error: #{e.class}: #{e.message}")
       nil
     end
 
+    # WIRE-026: the server's Retry-After (seconds or an HTTP date), else
+    # jittered exponential backoff; either way capped.
+    def retry_delay(retry_after, attempt)
+      seconds = parse_retry_after(retry_after)
+      if seconds.nil? || !seconds.finite? || seconds.negative?
+        seconds = RETRY_BASE_S * (2**attempt) * (0.5 + rand)
+      end
+      [seconds, MAX_RETRY_DELAY_S].min
+    end
+
+    def parse_retry_after(value)
+      text = value.to_s.strip
+      return nil if text.empty?
+
+      begin
+        Float(text)
+      rescue ArgumentError
+        begin
+          Time.httpdate(text) - Time.now
+        rescue ArgumentError
+          nil
+        end
+      end
+    end
+
+    def header_value(headers, name)
+      return nil unless headers.respond_to?(:each_pair)
+
+      headers.each_pair do |key, value|
+        next unless key.to_s.casecmp(name).zero?
+
+        return value.is_a?(Array) ? value.first : value
+      end
+      nil
+    end
+
+    def pause(seconds)
+      return @sleeper.call(seconds) if @sleeper
+
+      sleep(seconds) if seconds.positive?
+    end
+
     def send_request(url, headers, body)
       return @transport.call(url, headers, body) if @transport
 
@@ -270,11 +398,15 @@ module Restless
       http.use_ssl = uri.scheme == "https"
       http.open_timeout = HTTP_TIMEOUT_S
       http.read_timeout = HTTP_TIMEOUT_S
+      http.write_timeout = HTTP_TIMEOUT_S if http.respond_to?(:write_timeout=)
+      # Net::HTTP never resends a POST anyway; zero keeps WIRE-027 explicit.
+      http.max_retries = 0 if http.respond_to?(:max_retries=)
       request = Net::HTTP::Post.new(uri.request_uri)
       headers.each { |k, v| request[k] = v }
       request.body = body
-      response = http.request(request)
-      [response.code.to_i, response.body]
+      # The per-operation timeouts above do not bound the whole exchange.
+      response = Timeout.timeout(HTTP_TIMEOUT_S) { http.request(request) }
+      [response.code.to_i, response.body, response.to_hash]
     end
 
     # WIRE-020..023.

data/lib/restless/version.rb

@@ -6,7 +6,7 @@ module Restless
   # META-001: the spec version an SDK implements must be recorded in a
   # machine-readable form alongside its conformance level.
 
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 
   # WIRE-016: distinct per implementation, so the ingest can attribute a
   # payload to a language.
@@ -17,7 +17,7 @@ module Restless
   # REDACT-010 requires full Unicode name folding
   # to require full Unicode lowercase. Keep this in step with
   # spec/VECTORS_VERSION.
-  SPEC_VERSION = "1.2.0"
+  SPEC_VERSION = "1.3.0"
 
   # CONTRACT.md 1.1: L1 is the pure functions, L2 adds batching, caches,
   # injection and the safety guarantees.

data/lib/restless.rb

@@ -23,7 +23,7 @@ require_relative "restless/rack"
 
 # Capture your API traffic and send it to Restless.
 #
-# This SDK implements version 1.2.0 of the Restless SDK Contract at level L2.
+# This SDK implements version 1.3.0 of the Restless SDK Contract at level L2.
 # See CONFORMANCE.md.
 #
 #     client = Restless.new(ENV["RESTLESS_KEY"])

data/spec/VECTORS_VERSION

@@ -1 +1 @@
-1.2.0
+1.3.0

data/spec/vectors/debug-injection.json

@@ -1,7 +1,7 @@
 {
   "$generated": "GENERATED FILE - do not edit by hand. Inputs live in spec/cases.ts; run `npm run spec:vectors` to regenerate.",
   "$contract": "spec/CONTRACT.md",
-  "specVersion": "1.2.0",
+  "specVersion": "1.3.0",
   "cases": [
     {
       "id": "inject/2xx-headers-only",

data/spec/vectors/fingerprint.json

@@ -1,7 +1,7 @@
 {
   "$generated": "GENERATED FILE - do not edit by hand. Inputs live in spec/cases.ts; run `npm run spec:vectors` to regenerate.",
   "$contract": "spec/CONTRACT.md",
-  "specVersion": "1.2.0",
+  "specVersion": "1.3.0",
   "cases": [
     {
       "id": "fp/404-parameterized",

data/spec/vectors/har.json

@@ -1,7 +1,7 @@
 {
   "$generated": "GENERATED FILE - do not edit by hand. Inputs live in spec/cases.ts; run `npm run spec:vectors` to regenerate.",
   "$contract": "spec/CONTRACT.md",
-  "specVersion": "1.2.0",
+  "specVersion": "1.3.0",
   "cases": [
     {
       "id": "har/basic",

data/spec/vectors/mask.json

@@ -1,7 +1,7 @@
 {
   "$generated": "GENERATED FILE - do not edit by hand. Inputs live in spec/cases.ts; run `npm run spec:vectors` to regenerate.",
   "$contract": "spec/CONTRACT.md",
-  "specVersion": "1.2.0",
+  "specVersion": "1.3.0",
   "cases": [
     {
       "id": "mask/ascii",

data/spec/vectors/recovery-slug.json

@@ -1,7 +1,7 @@
 {
   "$generated": "GENERATED FILE - do not edit by hand. Inputs live in spec/cases.ts; run `npm run spec:vectors` to regenerate.",
   "$contract": "spec/CONTRACT.md",
-  "specVersion": "1.2.0",
+  "specVersion": "1.3.0",
   "cases": [
     {
       "id": "slug/basic",

data/spec/vectors/redact.json

@@ -1,7 +1,7 @@
 {
   "$generated": "GENERATED FILE - do not edit by hand. Inputs live in spec/cases.ts; run `npm run spec:vectors` to regenerate.",
   "$contract": "spec/CONTRACT.md",
-  "specVersion": "1.2.0",
+  "specVersion": "1.3.0",
   "cases": [
     {
       "id": "redactValue/long",

data/spec/vectors/request-id.json

@@ -1,7 +1,7 @@
 {
   "$generated": "GENERATED FILE - do not edit by hand. Inputs live in spec/cases.ts; run `npm run spec:vectors` to regenerate.",
   "$contract": "spec/CONTRACT.md",
-  "specVersion": "1.2.0",
+  "specVersion": "1.3.0",
   "cases": [
     {
       "id": "reqid/format-with-prefix",

data/spec/vectors/sampling.json

@@ -1,7 +1,7 @@
 {
   "$generated": "GENERATED FILE - do not edit by hand. Inputs live in spec/cases.ts; run `npm run spec:vectors` to regenerate.",
   "$contract": "spec/CONTRACT.md",
-  "specVersion": "1.2.0",
+  "specVersion": "1.3.0",
   "cases": [
     {
       "id": "sampling/config-absent",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: restless-sdk
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Restless
@@ -15,7 +15,7 @@ description: |
   recovered from, and uploads the result to Restless. Works with Rails,
   Sinatra, Hanami, Grape, Roda and anything else that speaks Rack.
 
-  Implements version 1.2.0 of the Restless SDK Contract at
+  Implements version 1.3.0 of the Restless SDK Contract at
   level L2.
 executables: []
 extensions: []
@@ -60,7 +60,7 @@ licenses:
 metadata:
   source_code_uri: https://github.com/restlesshq/ruby
   bug_tracker_uri: https://github.com/restlesshq/ruby/issues
-  restless_spec_version: 1.2.0
+  restless_spec_version: 1.3.0
   restless_conformance_level: L2
 rdoc_options: []
 require_paths: