pinqloq 1.2.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b13614cfc46b42b8434593f4fa92cb7f0a105097dd70732d04c3e14569396550
-  data.tar.gz: c56ed2b52ae2a4f0e24d7b9ee6b858d232cdb513d22b16941fe7abf50564d97d
+  metadata.gz: 914e5824e9dd8331e2c0ccb92e166d8e4f00ac14e49c19430d0106bf2eb1dd53
+  data.tar.gz: 7c3de9222525f8f1ee6d7faf746065711a49da6af8f57b3d2f34467427e6d957
 SHA512:
-  metadata.gz: 3d1ac680ab8af895cac427d09b88218f530e698923078f44265857bc9af053fbf5555759626cf4109d0a91872785033c1fa8a7230ec1b483fd2b533be8bddbe2
-  data.tar.gz: 2518b0bc7825265daada5f06984d4451ed17ed84d4d6db298457dc0a7153e23cdd19a79731410c801ad2b452e9eb0721623eb6fb57bd8191e8eb490669760723
+  metadata.gz: b81217eb46cbec0af99e1a03c0d09a4bd62c7b6122ed8c542ddb81693b4c1bba3ad3541aa11b10ab2ca27ec4a83fc475c512948602cafccc651f7b1209cec0d7
+  data.tar.gz: f83ff0b79f361ab163449c75ae131e4d200d2417471639e884be798a372641f746905c154fef79128b8ebdc3f73a80d52501e0b614570facb98d14f7e9f9863b

data/CHANGELOG.md

@@ -5,6 +5,30 @@ 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:**

data/README.md

@@ -49,14 +49,12 @@ require "pinqloq"
 
 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_client.logger,
-    pinqloq_options: pinqloq_client.options,
     exclude_paths: ["/health"]
 
 at_exit { pinqloq_client.shutdown }
@@ -82,26 +80,24 @@ pinqloq_client.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_client.logger,
-    pinqloq_options: pinqloq_client.options,
     exclude_paths: ["/health"],
     resolve_device_identifier: ->(request) { request.session[:user_id] },
     resolve_app_version_name: ->(request) { request.get_header("HTTP_X_APP_VERSION") },
@@ -146,7 +142,6 @@ redacts by **name**, exactly like the Node.js SDK:
 ```ruby
 use Pinqloq::Rack::RequestLogging,
     logger: pinqloq_client.logger,
-    pinqloq_options: pinqloq_client.options,
     redact_fields: ["ssn_last_four"],
     redact_paths: ["/payment"]
 ```

data/lib/pinqloq/client.rb

@@ -16,7 +16,7 @@ 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

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.2.0"
+  VERSION = "1.2.1"
 end

metadata

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