pinqloq 1.1.2 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b34593f2d1e32afe9a03124e36c7b3b824eb8155ba7a16156f113928e605cddf
-  data.tar.gz: f0ac5ed9f372d187d8d15be83e4a8832bc1637e190c18773fbf36925bd8b9b60
+  metadata.gz: 914e5824e9dd8331e2c0ccb92e166d8e4f00ac14e49c19430d0106bf2eb1dd53
+  data.tar.gz: 7c3de9222525f8f1ee6d7faf746065711a49da6af8f57b3d2f34467427e6d957
 SHA512:
-  metadata.gz: bcfb49cb5f6c33f5aa27c1f52e94e3d42f53efad2aee1808bb4c866fc36517e386bf12875257c2abf2e190a21d1b685e8d82d5c8fdf988b9ba8da424c089c0a6
-  data.tar.gz: 976f6719d2d3ffddc12c54f9ac98f50676b1c948fd5dad6ccd516afd16d78d1c451f12eac8cae271b733626e1fa36cdd9cd28afc57bdb39903e0b3f1d0777e2e
+  metadata.gz: b81217eb46cbec0af99e1a03c0d09a4bd62c7b6122ed8c542ddb81693b4c1bba3ad3541aa11b10ab2ca27ec4a83fc475c512948602cafccc651f7b1209cec0d7
+  data.tar.gz: f83ff0b79f361ab163449c75ae131e4d200d2417471639e884be798a372641f746905c154fef79128b8ebdc3f73a80d52501e0b614570facb98d14f7e9f9863b

data/CHANGELOG.md

@@ -5,6 +5,40 @@ All notable changes to the `pinqloq` gem are documented here. This gem follows
 `pinqloq` NuGet package and the `pinqloq` npm package — all three ship on separate cadences for
 the same platform, and mirror each other's feature set rather than their version numbers.
 
+## 1.2.1 — 2026-09-18
+
+**Changed:**
+
+- `device_identifier` is now optional.
+  - The request-logging middleware no longer rejects a request with HTTP 400 when no
+    `device_identifier` resolves. The log is sent without one.
+  - `enqueue` / `enqueue_many` no longer raise when an entry has no `device_identifier`.
+  - A blank `device_identifier` is now sent as `null` instead of an empty string. The ingest API
+    accepts logs without one and stores `null`.
+
+**Changed (breaking):**
+
+- `Pinqloq::Options#device_identifier` removed ([pinqponq/pinqloq-dashboard#57](https://github.com/pinqponq/pinqloq-dashboard/issues/57)).
+  With the field optional, a global fallback for it had nothing left to guarantee.
+  `device_identifier` is now set per entry on a manual `enqueue`, and resolved per request by
+  `resolve_device_identifier` then the `device-identifier` header — nothing after that. Drop
+  `device_identifier:` from `Pinqloq.create(...)`; it now raises `ArgumentError: unknown keyword`.
+  If you relied on it to guarantee a value, pass `resolve_device_identifier:` instead.
+- `Pinqloq::Rack::RequestLogging` no longer takes `pinqloq_options:`. It only read that object to
+  reach the removed fallback, so the keyword is gone; remove
+  `pinqloq_options: pinqloq_client.options` from your `use` line or Rack raises
+  `ArgumentError: unknown keyword`.
+
+## 1.2.0 — 2026-09-12
+
+**Added:**
+
+- `Client#enqueue` / `Client#enqueue_many` — shortcuts for `Client#logger.enqueue` /
+  `Client#logger.enqueue_many`, so manual logging no longer needs the extra `.logger` hop.
+  `Client#logger` is unchanged and still useful when a method should only receive the logging
+  capability, not the whole client. Matches the Go SDK's `Client#Enqueue`/`Client#EnqueueMany`
+  shortcuts.
+
 ## 1.1.2 — 2026-09-08
 
 **Fixed:**

data/README.md

@@ -47,19 +47,17 @@ credentials.
 ```ruby
 require "pinqloq"
 
-pinqloq = Pinqloq.create(
+pinqloq_client = Pinqloq.create(
   secret_key: ENV.fetch("PINQLOQ_SECRET_KEY"),
-  api_logs_collection_name: "myapp_api_logs",
-  device_identifier: "myapp-instance-1"
+  api_logs_collection_name: "myapp_api_logs"
 )
 
 # Rack app / Rails config/application.rb / config.ru
 use Pinqloq::Rack::RequestLogging,
-    logger: pinqloq.logger,
-    pinqloq_options: pinqloq.options,
+    logger: pinqloq_client.logger,
     exclude_paths: ["/health"]
 
-at_exit { pinqloq.shutdown }
+at_exit { pinqloq_client.shutdown }
 ```
 
 The middleware captures the HTTP method, path, and status code as searchable metadata. The
@@ -68,10 +66,10 @@ request body, response body, request headers, and response headers go to the log
 
 ## Manual Logging
 
-Use `pinqloq.logger` to send structured application events:
+Use `pinqloq_client.enqueue` to send structured application events:
 
 ```ruby
-pinqloq.logger.enqueue(
+pinqloq_client.enqueue(
   Pinqloq::LogEntry.new(
     event: "order.created",
     device_identifier: order.customer_id,
@@ -82,23 +80,24 @@ pinqloq.logger.enqueue(
 )
 ```
 
-`event` and `device_identifier` are required on every entry. Leave `device_identifier` unset on
-an entry to inherit the global `device_identifier` option. `enqueue` raises if an entry has no
-`device_identifier` and no global fallback is set — a missing required field fails loudly rather
-than being silently dropped.
+`event` is required on every entry.
+
+`device_identifier` is optional and has no global fallback: set it per entry, and an entry that
+leaves it unset is stored without one.
+
+`pinqloq_client.logger` still returns the same `Logger` — useful when you want to pass just the
+logging capability into a function without handing it the whole client.
 
 ## Add Request Metadata
 
-By default the middleware reads the required `device_identifier` from the `device-identifier`
-request header automatically. Override how it is resolved with `resolve_device_identifier`; the
-override wins, and if it returns nil/blank the middleware falls back to the `device-identifier`
-header, then to the global `device_identifier` option. If none of these resolve a value, the
-middleware rejects the request with **HTTP 400** before it runs.
+By default the middleware reads the optional `device_identifier` from the `device-identifier`
+request header. Override how it is resolved with `resolve_device_identifier`. The override wins;
+if it returns nil/blank, the middleware falls back to the `device-identifier` header. If neither
+resolves a value, the log is stored without a `device_identifier`.
 
 ```ruby
 use Pinqloq::Rack::RequestLogging,
-    logger: pinqloq.logger,
-    pinqloq_options: pinqloq.options,
+    logger: pinqloq_client.logger,
     exclude_paths: ["/health"],
     resolve_device_identifier: ->(request) { request.session[:user_id] },
     resolve_app_version_name: ->(request) { request.get_header("HTTP_X_APP_VERSION") },
@@ -118,7 +117,7 @@ The request-logging middleware fills it with no configuration: the caller's `cor
 request header when present, otherwise a generated UUID.
 
 ```ruby
-pinqloq.logger.enqueue(
+pinqloq_client.enqueue(
   Pinqloq::LogEntry.new(
     event: "order.created",
     device_identifier: order.customer_id,
@@ -142,8 +141,7 @@ redacts by **name**, exactly like the Node.js SDK:
 
 ```ruby
 use Pinqloq::Rack::RequestLogging,
-    logger: pinqloq.logger,
-    pinqloq_options: pinqloq.options,
+    logger: pinqloq_client.logger,
     redact_fields: ["ssn_last_four"],
     redact_paths: ["/payment"]
 ```
@@ -156,7 +154,7 @@ list.
 ## Security and Reliability
 
 Logs are buffered in memory and sent in batches by a single background thread. Buffered logs may
-be lost if the process is terminated without a graceful shutdown — call `pinqloq.shutdown` on
+be lost if the process is terminated without a graceful shutdown — call `pinqloq_client.shutdown` on
 exit (`at_exit`, a `Rails.application.config.after_initialize` shutdown hook, or your process
 manager's stop signal handler).
 

data/lib/pinqloq/client.rb

@@ -16,11 +16,19 @@ module Pinqloq
       @buffer = Buffering::LogBuffer.new(options.queue_capacity)
       api_client = Http::IngestApiClient.new(options)
       @dispatcher = Buffering::LogDispatcher.new(@buffer, api_client, options)
-      @logger = Logger.new(@buffer, @dispatcher, options)
+      @logger = Logger.new(@buffer, @dispatcher)
 
       @dispatcher.start
     end
 
+    def enqueue(entry, on_sent: nil, on_failed: nil)
+      @logger.enqueue(entry, on_sent: on_sent, on_failed: on_failed)
+    end
+
+    def enqueue_many(entries, on_sent: nil, on_failed: nil)
+      @logger.enqueue_many(entries, on_sent: on_sent, on_failed: on_failed)
+    end
+
     def shutdown
       @dispatcher.shutdown
     end

data/lib/pinqloq/http/ingest_api_client.rb

@@ -137,7 +137,7 @@ module Pinqloq
         app_version_name = (app_version_name && !app_version_name.empty?) ? entry.app_version_name : @options.app_version_name
 
         device_identifier = entry.device_identifier&.strip
-        device_identifier = (device_identifier && !device_identifier.empty?) ? entry.device_identifier : (@options.device_identifier || "")
+        device_identifier = nil if device_identifier&.empty?
 
         {
           logLevel: entry.log_level,

data/lib/pinqloq/logger.rb

@@ -2,39 +2,21 @@
 
 module Pinqloq
   class Logger
-    DEVICE_IDENTIFIER_REQUIRED_MESSAGE =
-      "Pinqloq: device_identifier is required. Set it on the entry, or configure the global " \
-      "Options#device_identifier fallback."
-
-    def initialize(buffer, dispatcher, options)
+    def initialize(buffer, dispatcher)
       @buffer = buffer
       @dispatcher = dispatcher
-      @options = options
     end
 
     def enqueue(entry, on_sent: nil, on_failed: nil)
-      ensure_device_identifier!(entry)
       written = @buffer.enqueue(entry, on_sent: on_sent, on_failed: on_failed)
       @dispatcher.notify_enqueued
       written
     end
 
     def enqueue_many(entries, on_sent: nil, on_failed: nil)
-      entries.each { |entry| ensure_device_identifier!(entry) }
       written = @buffer.enqueue_many(entries, on_sent: on_sent, on_failed: on_failed)
       @dispatcher.notify_enqueued
       written
     end
-
-    private
-
-    def ensure_device_identifier!(entry)
-      entry_value = entry.device_identifier&.strip
-      global_value = @options.device_identifier&.strip
-
-      return if (entry_value && !entry_value.empty?) || (global_value && !global_value.empty?)
-
-      raise DEVICE_IDENTIFIER_REQUIRED_MESSAGE
-    end
   end
 end

data/lib/pinqloq/options.rb

@@ -11,7 +11,7 @@ module Pinqloq
     DEFAULT_HTTP_TIMEOUT = 10.0
 
     attr_reader :secret_key, :api_logs_collection_name, :bulk_path, :batch_size,
-                :flush_interval, :queue_capacity, :http_timeout, :app_version_name, :device_identifier
+                :flush_interval, :queue_capacity, :http_timeout, :app_version_name
 
     def initialize(
       secret_key:,
@@ -21,8 +21,7 @@ module Pinqloq
       flush_interval: DEFAULT_FLUSH_INTERVAL,
       queue_capacity: DEFAULT_QUEUE_CAPACITY,
       http_timeout: DEFAULT_HTTP_TIMEOUT,
-      app_version_name: nil,
-      device_identifier: nil
+      app_version_name: nil
     )
       raise ArgumentError, "Pinqloq: secret_key is required." if secret_key.nil? || secret_key.strip.empty?
 
@@ -34,7 +33,6 @@ module Pinqloq
       @queue_capacity = [1, queue_capacity].max
       @http_timeout = [0.001, http_timeout].max
       @app_version_name = app_version_name
-      @device_identifier = device_identifier
     end
   end
 end

data/lib/pinqloq/rack/request_logging.rb

@@ -19,11 +19,6 @@ module Pinqloq
       DEVICE_IDENTIFIER_HEADER_NAME = "device-identifier"
       CORRELATION_ID_HEADER_NAME = "correlation-id"
 
-      DEVICE_IDENTIFIER_REQUIRED_MESSAGE =
-        "Pinqloq: the required device_identifier could not be resolved. Send the " \
-        "'device-identifier' request header, or configure resolve_device_identifier, or set " \
-        "Options#device_identifier."
-
       SERVER_ERROR_STATUS_THRESHOLD = 500
       CLIENT_ERROR_STATUS_THRESHOLD = 400
 
@@ -32,7 +27,6 @@ module Pinqloq
       def initialize(
         app,
         logger:,
-        pinqloq_options:,
         exclude_paths: [],
         resolve_device_identifier: nil,
         resolve_app_version_name: nil,
@@ -43,7 +37,6 @@ module Pinqloq
       )
         @app = app
         @logger = logger
-        @pinqloq_options = pinqloq_options
         @exclude_paths = exclude_paths
         @resolve_device_identifier = resolve_device_identifier
         @resolve_app_version_name = resolve_app_version_name
@@ -60,9 +53,6 @@ module Pinqloq
         return @app.call(env) if PathMatch.matches_any_prefix?(path, @exclude_paths)
 
         device_identifier = resolve_device_identifier(request)
-        if device_identifier.nil? || device_identifier.strip.empty?
-          return [400, { "Content-Type" => "text/plain" }, [DEVICE_IDENTIFIER_REQUIRED_MESSAGE]]
-        end
 
         redact_plan = build_redact_plan(path)
         started_at = monotonic_now
@@ -157,7 +147,7 @@ module Pinqloq
         header = request.get_header(rack_header_key(DEVICE_IDENTIFIER_HEADER_NAME))
         return header unless header.nil? || header.strip.empty?
 
-        @pinqloq_options.device_identifier
+        nil
       end
 
       def resolve_correlation_id(request)

data/lib/pinqloq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pinqloq
-  VERSION = "1.1.2"
+  VERSION = "1.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pinqloq
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 1.2.1
 platform: ruby
 authors:
 - pinqponq
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-09 00:00:00.000000000 Z
+date: 2026-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack