iugu_logger 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f3b99e1a559a5f178c6b1912682683904d257c4f951f33ea5dce7f61e8c3e0d
-  data.tar.gz: 3eae5a9150343a4a467d422eb87956fe7995a0f83cd0636304559ba767fda055
+  metadata.gz: '015286b1afd6fc355f095a1ef61578d4b5d46e2015caa8604a1cb731e3c6cc74'
+  data.tar.gz: 21cc16a5dca1aab380d0e65be5f276c291213f733f4c3a089988412e5ae45c88
 SHA512:
-  metadata.gz: 4db9c2d097eb568762a8e931f7d484ca3b294d25a926f84b1031f75ef0bc6d27cf50c466a9d2049cccfe9221396d541608f73f65cade6af3d68f3efc2be56fe0
-  data.tar.gz: a1e4f13b8b04c6be87b5cacf2dbac6c09b1370906b2e83a7427eb3a63197a45033069085d148c78b5b582424b9441021ca22f1a71aedf09661ae0156e353903a
+  metadata.gz: 37b668182fbb6523ec9b69b9854637cc9d0b5b838bc8ccf0a554b0e664081ea8ee64d98d82446738d82ea401096013ea1af1c24a504841fb04eff35a0f8e297d
+  data.tar.gz: eab988738a54515f2f993a153a47a570b0d2f7689dcd93c34bb1e19edded0ba4e910e308c55a00bb955c6f8347d297d1fccef555bc844db4a4d1c60f2b19c2d6

data/CHANGELOG.md

@@ -0,0 +1,564 @@
+# Changelog
+
+All notable changes to `iugu_logger` are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.11.0](https://github.com/iugu-private/iugu-logger-ruby/compare/v0.10.0...v0.11.0) (2026-07-01)
+
+
+### Features
+
+* schema-sync guardrails (auto-sync, freshness gate, version manifest) ([#32](https://github.com/iugu-private/iugu-logger-ruby/issues/32)) ([3175f4a](https://github.com/iugu-private/iugu-logger-ruby/commit/3175f4a7fb44f5666bddd0aea2df522162e8ada3))
+
+## [0.10.0](https://github.com/iugu-private/iugu-logger-ruby/compare/v0.9.0...v0.10.0) (2026-06-01)
+
+
+### Features
+
+* add automated schema conformance gate to CI ([#31](https://github.com/iugu-private/iugu-logger-ruby/issues/31)) ([f3f3dfb](https://github.com/iugu-private/iugu-logger-ruby/commit/f3f3dfba18e1f6af126f16123b4b3c3e80e653b9))
+* single-line default, trace context OTEL-aware e service.instance opt-in ([#28](https://github.com/iugu-private/iugu-logger-ruby/issues/28)) ([e9f1f88](https://github.com/iugu-private/iugu-logger-ruby/commit/e9f1f88d0f73bb166f395e3082cd733c02ee6778))
+
+## [0.9.0](https://github.com/iugu-private/iugu-logger-ruby/compare/v0.8.1...v0.9.0) (2026-05-13)
+
+
+### Features
+
+* configurable log size cap + conformance suite runner ([c1d1be3](https://github.com/iugu-private/iugu-logger-ruby/commit/c1d1be3f3b5c98c1af37504649691d916d80bb7b))
+* configurable log size cap + conformance suite runner ([5d4bf82](https://github.com/iugu-private/iugu-logger-ruby/commit/5d4bf824c639567fb6c85bb6c64601f31f25b9d6))
+
+## [0.9.0] — Unreleased
+
+### Added — `Configuration#max_log_size_kb` + automatic params truncation
+
+Operational logs in iugu carry the full request payload (`request.params`)
+since v0.8.0 — great for ops/support/fraud but it can blow up the
+emitted log size for endpoints with large bodies (uploads with base64
+attachments, batched PIX, etc.).
+
+`Configuration#max_log_size_kb` (default 64) caps the encoded payload.
+When the JSON-encoded log would exceed the cap, the `Logger#emit` path:
+
+- Replaces `request.params` with the string `"[TRUNCATED]"`
+- Sets `request.params_truncated: true` so consumers know
+- Preserves every other canonical field (trace, iugu, http, rails, pii,
+  service, etc.) — observability and audit stay intact
+
+Set to `nil` to disable.
+
+### Added — Conformance suite runner
+
+`spec/conformance/conformance_spec.rb` exercises the YAML fixtures
+mirrored from `iugu-logging-schema/conformance/`. When the Go / Node
+SDKs are implemented, they should run the same fixtures and produce
+identical `pii.scanned`/`detected`/`redacted` and post-scan content —
+guaranteeing cross-language behavior parity.
+
+11 fixtures covering CPF, CNPJ, CC (Luhn-valid + Luhn-rejected CNPJ),
+email, phone, AWS key, Bearer, `iugu.account_id` SAFE_PATTERN, password
+Layer 1 filter, and multiple-PII independence.
+
+### Compatibility
+
+No breaking change. New configuration option defaults conservatively
+(64 KB cap, well above typical request sizes). API surface unchanged.
+PII strategies unchanged from v0.8 (data-completeness-first preserved).
+
+## [0.8.1](https://github.com/iugu-private/iugu-logger-ruby/compare/v0.8.0...v0.8.1) (2026-05-13)
+
+
+### Bug Fixes
+
+* cc Luhn + format empty-string + view/db runtime via subscriber ([911fe13](https://github.com/iugu-private/iugu-logger-ruby/commit/911fe13f728387c2bc409844b32f3822fc50d6f0))
+* CC Luhn + format empty-string + view/db runtime via subscriber ([a18eea9](https://github.com/iugu-private/iugu-logger-ruby/commit/a18eea9db8346dd9300478793c4506bd037f2289))
+* **railtie:** wrap rescue in explicit begin/end for Ruby 2.4 compat ([7811822](https://github.com/iugu-private/iugu-logger-ruby/commit/78118225a6a4b8e4c3fb007166e4bfd18bd5b8b6))
+
+## [0.8.1] — Unreleased
+
+### Fixed — CNPJ values being redacted as credit cards (production false positive)
+
+The CC regex matched any 13–19 digit sequence (the format only validates
+length and optional separators). In fraud-payout's v0.8.0 production
+deploy this redacted CNPJ values like `54565372000194` as
+`"**** **** **** 0194"` — losing operational signal AND inflating the
+`pii.detected: [cc]` count incorrectly.
+
+Fixed by adding a **Luhn (mod-10) checksum validation** before treating
+a match as a card. Real CC numbers pass Luhn; CPF / CNPJ / arbitrary
+numeric identifiers fail.
+
+`Pii::Scanner#safe_match?` now takes the type as a second argument and
+short-circuits CC matches that fail `luhn_valid?`.
+
+### Fixed — `request.format` emitting `""` for ActionController::API endpoints
+
+`extract_request_format` returned `Mime#symbol.to_s` even when the
+underlying symbol was `nil` (the `Mime::ALL` case for content-type-less
+API endpoints), producing `"format": ""` in production. Now we fall
+through to `Mime#to_s`, then `HTTP_ACCEPT`, then omit the key entirely.
+
+### Fixed — `rails.view_runtime_ms` / `rails.db_runtime_ms` missing for ActionController::API
+
+The `action_dispatch.view_runtime` / `db_runtime` env keys are only set
+by Rails' full-stack ActionController::Base; ActionController::API
+(used by fraud-payout and most iugu services) leaves them unset.
+
+The Railtie now subscribes to `process_action.action_controller` —
+canonical notification fired at the end of every action regardless of
+controller class — and stashes the `view_runtime` / `db_runtime`
+payload values in `Buffer.current.rails_runtime`. The middleware reads
+from there when building the `rails.*` block.
+
+Specs added covering all three fixes (Luhn rejection of CNPJ, format
+nil-symbol fallback, Buffer-sourced runtimes).
+
+### Compatibility
+
+- Hosts not using Rails: untouched (Buffer.rails_runtime stays empty).
+- Hosts using ActionController::Base (full-stack Rails view rendering):
+  unchanged behavior — env keys still take precedence over Buffer.
+- No public API change.
+
+## [0.8.0](https://github.com/iugu-private/iugu-logger-ruby/compare/v0.7.0...v0.8.0) (2026-05-13)
+
+
+### Features
+
+* **request_logger:** enrich canonical event for legacy rails_semantic_logger parity ([c1599aa](https://github.com/iugu-private/iugu-logger-ruby/commit/c1599aa6543261eab1359a8b383e172d375f27dc))
+* **request_logger:** enrich canonical event for legacy rails_semantic_logger parity ([8c48c95](https://github.com/iugu-private/iugu-logger-ruby/commit/8c48c95a6688ffd010378d2e9a597c3974bd8488))
+
+## [0.8.0] — Unreleased
+
+### Added — `RequestLogger` enriquece o evento canônico com paridade ao legacy `rails_semantic_logger`
+
+`http.request.completed` (e `.failed`) agora carrega:
+
+- `request.params` — payload do request com `config.filter_parameters`
+  do host Rails já aplicado (pix_key, cards, password etc. chegam como
+  `[FILTERED]`). Lido de `env['action_dispatch.request.parameters']`.
+- `request.format` — formato negociado da resposta. Lido de
+  `env['action_dispatch.request.formats']` (Rails Mime) com fallback
+  no header `HTTP_ACCEPT` pra apps Rack puro.
+- `http.status_message` — `"OK" / "Not Found" / ...` via
+  `Rack::Utils::HTTP_STATUS_CODES`.
+- `rails.controller`, `rails.action`, `rails.view_runtime_ms`,
+  `rails.db_runtime_ms` — bloco novo populado quando o dispatcher Rails
+  expõe `env['action_controller.instance']` e os runtimes
+  `action_dispatch.view_runtime` / `db_runtime`. Ausente em hosts
+  não-Rails (Sinatra, Rack puro, Jets/Lambda hoje).
+
+Motivação: fechar o gap operacional com o `Completed #...` do
+`rails_semantic_logger` que ops/suporte/fraude/ML pipelines da iugu
+consomem hoje. Com v0.7 (defaults `:detect_only` em PII) + v0.8
+(enriquecimento), um único evento canônico carrega:
+
+- Tudo que o legacy carrega (controller, action, params, runtimes…)
+- Mais o valor adicionado iugu (event.action, service.version,
+  service.instance, iugu.account_id, pii.detected, trace.*)
+
+Resultado: a próxima Phase C (PR's de migração `Rails.logger.info →
+IuguLogger.event` em fraud-payout etc.) pode finalmente REMOVER a
+linha legada, em vez de manter coexistência indefinida.
+
+### Compatibility
+
+- Sem mudança de API pública. Mesma surface; só campos novos no payload
+  emitido.
+- Sem mudança em hosts não-Rails — os blocos `rails.*` e
+  `request.params/format` simplesmente não aparecem.
+- Defensivo: cada extração tem `rescue StandardError` — instrumentação
+  nunca quebra a request.
+
+## [0.7.0](https://github.com/iugu-private/iugu-logger-ruby/compare/v0.6.3...v0.7.0) (2026-05-13)
+
+
+### ⚠ BREAKING CHANGES
+
+* default PII strategies for cpf / cnpj / phone / address changed from :full_redact to :detect_only. Apps that depend on '[CPF_REDACTED]'-style markers in log content will start seeing raw values. Migration is mechanical: either accept the new default or pin specific types back to :full_redact via the override pattern.
+
+### Features
+
+* flip default PII strategies to :detect_only (data-completeness-first) ([c44be0c](https://github.com/iugu-private/iugu-logger-ruby/commit/c44be0c88a378a51314d5607beb09fe7f2985070))
+
+## [0.6.3](https://github.com/iugu-private/iugu-logger-ruby/compare/v0.6.2...v0.6.3) (2026-05-12)
+
+
+### Bug Fixes
+
+* **request_logger:** re-read tenant after [@app](https://github.com/app).call ([b77805f](https://github.com/iugu-private/iugu-logger-ruby/commit/b77805f5f7dca7a721834f99d2bb38effd2d8bc7))
+* **request_logger:** re-read tenant after [@app](https://github.com/app).call ([448e43e](https://github.com/iugu-private/iugu-logger-ruby/commit/448e43e35522444a80398fb0fc7ee909d704b8f5))
+
+## [Unreleased]
+
+## [0.7.0] — 2026-05-12
+
+### Changed — Default PII strategies flip to `:detect_only` (data-completeness-first)
+
+Aligns the SDK with how iugu operationally consumes logs: ops, support,
+fraud analysts, compliance, and ML pipelines need the raw personal data
+that the legacy `rails_semantic_logger` output already emits today (full
+CPF, CNPJ, phone, email, address, bank account, etc.). The pre-v0.7
+defaults aggressively redacted those values, breaking parity with the
+legacy stream that downstream consumers depend on.
+
+New defaults in `IuguLogger::Pii::DEFAULT_STRATEGIES`:
+
+| Type | Before (0.6.x) | After (0.7) |
+|---|---|---|
+| `cpf` | `:full_redact` | `:detect_only` |
+| `cnpj` | `:full_redact` | `:detect_only` |
+| `phone` | `:full_redact` | `:detect_only` |
+| `email` | `:detect_only` | `:detect_only` (unchanged) |
+| `address` | (no default) | `:detect_only` |
+| `cc` | `:last4` | `:last4` (KEPT — PCI-DSS) |
+| `aws_key` | `:full_redact` | `:full_redact` (KEPT — credential) |
+| `bearer` | `:full_redact` | `:full_redact` (KEPT — credential) |
+| `url_with_creds` | `:full_redact` | `:full_redact` (KEPT — credential) |
+
+`:detect_only` means: **the scanner still scans, still records
+`pii.detected: [cpf, phone, ...]` (so audit / tagging / cardinality
+queries keep working) — but it does NOT modify the content.** LGPD
+compliance is then enforced by access-control and retention on the log
+store (Loki, Datadog), not by removing data at the source.
+
+Things explicitly NOT changed:
+
+- **PCI-DSS protection** — credit card numbers still redact to last-4.
+- **Credential redaction** — AWS keys, Bearer tokens, URLs with embedded
+  creds still fully redacted. These are never user data; they're only
+  leak risk.
+- **ILS-002 `iugu.account_id` SAFE_PATTERN** — still preserved.
+
+Apps that need stricter redaction can opt in per-type via
+`Configuration#pii_redaction`:
+
+```ruby
+IuguLogger.configure do |c|
+  c.pii_redaction = IuguLogger::Pii::DEFAULT_STRATEGIES.merge(
+    cpf:   :full_redact,
+    email: :full_redact
+  )
+end
+```
+
+### Changed — Smoke test renamed `pii_redaction` → `pii_detection`
+
+The 6th smoke check now validates detection-without-modification (the
+new default), instead of redaction. `bundle exec rake iugu_logger:smoke`
+shows `✓ pii_detection` instead of `✓ pii_redaction`.
+
+### Changed — Generator template
+
+`rails g iugu_logger:install` now emits an initializer that documents the
+new default and the override pattern, and drops the dead
+`HEROKU_SLUG_COMMIT` / `SOURCE_VERSION` fallback chain (use `GIT_SHA`
+only — same fallback the fraud-payout pilot uses).
+
+### Compatibility
+
+**Breaking change in default behavior** — code that asserts on
+`'[CPF_REDACTED]'`-style markers will start failing after upgrading.
+The migration is mechanical: either accept the new default (PII stays
+in the log) or pin specific types back to `:full_redact` via the
+override pattern above.
+
+No API surface change — same constants, same method signatures.
+
+## [0.6.3] — 2026-05-12
+
+### Fixed — `iugu.*` block always empty in canonical http.request.completed events (production bug)
+
+`RequestLogger` extracted tenant context (`TenantContext.from_rack(env)`) at
+the *start* of the request, before `@app.call`. In real apps, tenant
+identifiers (`env['iugu.current_account_id']`, etc.) are populated by a
+controller `before_action` that runs *during* dispatch — so the early
+extraction always saw the env keys missing, and the emitted
+`http.request.completed` event was missing the `iugu.*` block.
+
+Caught when fraud-payout (ILS-030 pilot) added the
+`Api::IuguTenantContext` concern in the canonical way (after authenticate,
+populating `request.env['iugu.current_account_id']`): no `iugu` block
+showed up in Datadog despite the env being correctly populated.
+
+Fix: re-read tenant *after* `@app.call` in both the success and exception
+paths. The pre-call extraction is kept as a best-effort fallback for hosts
+that prefer to populate tenant in a Rack middleware upstream of
+RequestLogger (still valid; both paths converge on whatever the final
+state of env is).
+
+This is the canonical timing for Rack middleware that emits per-request
+events — see `lograge`'s `before_format` hook for the equivalent pattern.
+
+No public API change. Existing callers see no behavior difference except
+that `iugu.*` now actually populates when the host app sets the env
+during dispatch.
+
+## [0.6.2] — 2026-05-09
+
+### Fixed — PII false positive on structural identifiers (production bug)
+
+The phone regex `/\(?\d{2}\)?\s?9?\d{4}-?\d{4}\b/` matched any 10-11 digit
+run, redacting hex `trace.span_id` / `trace.id` / `request.id` values that
+happened to contain numeric sub-strings as `[PHONE_REDACTED]`. Observed in
+**conector-vtex** (cluster 134, 2026-05-09): 100% of `http.request.completed`
+events had `trace.span_id` redacted to `"000000[PHONE_REDACTED]"`, breaking
+trace correlation downstream.
+
+Two-layer defense:
+
+- **`Pii::SAFE_KEY_PATHS`** — schema canonical paths (`trace.id`,
+  `trace.span_id`, `trace.parent_id`, `request.id`, `service.instance`,
+  `service.name`, `service.version`, `service.environment`, `event.action`,
+  `event.kind`, `log.level`, `@timestamp`, `http.status_code`,
+  `http.duration_ms`) skip the scan entirely. Values at these paths are
+  structural identifiers / controlled metadata defined by §2 of the spec
+  and never carry user-supplied content.
+- **`Pii::SAFE_PATTERNS` expanded** — added `otel_trace_id` (32-hex),
+  `otel_span_id` (16-hex), `uuid` (v4/v7), and made `iugu_account_id` 32-hex
+  case-insensitive (modern lowercase + legacy uppercase). Defense-in-depth
+  for hex IDs found in arbitrary string content.
+- **`Pii::PATTERNS[:phone]`** — added lookarounds `(?<![\w-])` and `(?![\w-])`
+  to require non-identifier flanking. Prevents matches inside dense
+  identifier tokens (e.g. `job-1234567890-def`) while still detecting
+  plain-text Brazilian phone numbers.
+
+### Added — Human-readable `message` summary in canonical middlewares
+
+`message` field now carries an Apache-style summary line so log viewers
+(Loki, Datadog, Grafana, plain `kubectl logs`) show actionable info
+without expanding the JSON. Canonical `event.action` is unchanged in
+attributes for queries.
+
+- `RequestLogger` — `"<METHOD> <PATH> <STATUS> [<duration_ms>ms]"` on
+  success, `"<METHOD> <PATH> failed [<duration_ms>ms] <ErrorClass>"` on
+  exceptions.
+- `JobLogger` — `"<JobClass>#perform [<queue>] ok [<duration_ms>ms]"` on
+  success, `"<JobClass>#perform [<queue>] failed [<duration_ms>ms] <ErrorClass>"`
+  on exceptions.
+- `Logger#event` — accepts `message:` keyword (already supported); no API
+  change required for app code calling `IuguLogger.event(...)`.
+
+### Compatibility
+
+Fully backward compatible. No public API change. All call-sites that already
+work with 0.6.1 continue to work; the only observable difference is the
+`message` field now contains a summary instead of repeating `event.action`.
+
+---
+
+### Added — v0.6 Install generator + smoke rake task (zero-puxadinho onboarding)
+Standard "drop in any Rails project" pattern, used by the fraud-payout pilot
+and by every future consumer:
+
+```sh
+rails g iugu_logger:install        # generates config/initializers/iugu_logger.rb
+bundle exec rake iugu_logger:smoke # validates the integration end-to-end
+```
+
+- `rails g iugu_logger:install` — `IuguLogger::Generators::InstallGenerator`
+  creates `config/initializers/iugu_logger.rb` from an ERB template with
+  sensible defaults (service_name auto-derived from `Rails.application.class`,
+  format pretty in dev / JSON elsewhere, validator `:warn`, PII defaults).
+  Idempotent — re-running asks before overwriting.
+- `rake iugu_logger:smoke` — `IuguLogger::SmokeTest.run` runs 6 end-to-end
+  checks against an isolated Logger that mirrors the host app's config:
+  1. `sdk_loaded` — required modules defined
+  2. `configuration_present` — service_name/version/environment set
+  3. `basic_emit` — canonical schema fields populated
+  4. `pii_redaction` — CPF in message → `[CPF_REDACTED]` + `pii.detected`
+  5. `account_id_safe_pattern` — 32-hex preserved (ILS-002)
+  6. `single_line_json` — Loki-friendly one-line output, valid JSON
+  Exits non-zero on any failure.
+- Railtie now `load`s `lib/iugu_logger/tasks/iugu_logger.rake` so the rake
+  task is available in any Rails app the moment the gem is bundled.
+- Gemspec includes `lib/**/*.rake` and `lib/generators/**/*.tt` in the
+  shipped package.
+
+### Changed
+- Bumped to `0.6.0`.
+
+### Added — v0.5 Railtie auto-config (ILS-023 finale)
+- `IuguLogger::Railtie` (loaded only when `::Rails::Railtie` is defined):
+  - **Middleware insertion:** `IuguLogger::RequestLogger` is inserted after
+    `ActionDispatch::DebugExceptions` automatically. Apps no longer need to
+    edit `config/application.rb`.
+  - **Sidekiq auto-register:** when Sidekiq is loaded server-side,
+    `IuguLogger::JobLogger::Sidekiq` is added to the server middleware chain.
+  - **Service name auto-derive:** `Rails.application.class.name` →
+    snake_case + dashed (e.g. `PixuguPlatform::Application` → `pixugu-platform`).
+    Skipped when `service_name` was already set explicitly.
+- `Rails.logger` is intentionally **not** replaced in this release. Apps
+  migrate to `IuguLogger.event(...)` for schema-conforming events; existing
+  `Rails.logger.X` calls keep working unchanged. (A future opt-in adapter
+  may route `Rails.logger` through the buffer; deferred until the
+  fraud-payout pilot validates the migration ergonomics.)
+- 6 RSpec examples for `derive_service_name` heuristic + Railtie load.
+  Real Rails integration is verified during the fraud-payout pilot
+  (ILS-030).
+
+### Changed
+- Bumped to `0.5.0` (auto-config completes the v0.4 series).
+
+### Added — v0.4.1 JobLogger (Sidekiq + ActiveJob middlewares — ILS-023 part 2)
+- `IuguLogger::JobLogger::Adapter` — shared body around a job execution
+  (Buffer reset/drain, request+labels context, completed/failed event emit,
+  exception fingerprint, monotonic clock).
+- `IuguLogger::JobLogger::Sidekiq` — server middleware. Register via
+  `Sidekiq.configure_server { ... chain.add IuguLogger::JobLogger::Sidekiq }`.
+  Compatible with sidekiq, sidekiq-pro, sidekiq-ent (msg payload format
+  identical). Maps `msg['retry_count']` → `attempt` (first execution = 1).
+- `IuguLogger::JobLogger::ActiveJob` — mixin. `include` in ApplicationJob.
+  Falls back to `attempt: 1` when ActiveJob does not implement
+  `#executions` (Rails 4.2 / platform).
+- Each job execution emits one canonical event:
+  - `<source>.job.completed` (`sidekiq.job.completed` or `activejob.job.completed`)
+    on success — severity `:info`, includes `request`, `labels`, `duration_ms`,
+    drained `logs:`.
+  - `<source>.job.failed` on exception — severity `:error`, includes
+    `error.{type, message, fingerprint}`. Re-raises so other middleware sees
+    the original error.
+- `labels` carries low-cardinality dimensions (`job_class`, `queue`,
+  `attempt`); per-execution things (`duration_ms`, `job_id`) live elsewhere
+  to avoid Loki cardinality blowup.
+
+### Changed
+- Bumped to `0.4.1`.
+
+### Added — v0.4 thread-local Buffer + Rack RequestLogger middleware (ILS-023 part 1)
+- `IuguLogger::Buffer` — per-thread buffer (via `Concurrent::ThreadLocalVar`):
+  - `Buffer.current` — lazy-instantiated singleton per thread
+  - `Buffer.reset!` — wipes current thread's buffer
+  - `#push(severity:, message:, **extras)` — appends a log entry
+  - `#drain` — returns and clears entries (used by middleware at request end)
+  - `#add_context(**)` / `#context` / `#reset_context!` — request-scoped fields
+  - `MAX_ENTRIES = 100` cap to prevent unbounded growth
+- `IuguLogger::RequestLogger` — Rack middleware:
+  - Resets buffer at request start, populates context with `trace` (via
+    `TraceContext.extract`) and `iugu` (via `TenantContext.from_rack`)
+  - Wraps downstream app, captures duration via monotonic clock
+  - On success: emits `http.request.completed` with `request`, `http`,
+    `trace`, `iugu`, and drained `logs: [...]`. Severity inferred from
+    HTTP status (info <400, warn <500, error ≥500)
+  - On exception: emits `http.request.failed` with `error.{type, message,
+    fingerprint}` (sha256 of normalized message — stable for grouping),
+    re-raises so other middleware sees the original error
+  - Always resets buffer in `ensure`, even on exception
+  - Empty `trace` / `iugu` / `logs` blocks omitted from emitted payload
+
+### Changed
+- `lib/iugu_logger.rb` now requires `buffer` and `request_logger` modules.
+- Bumped to `0.4.0`.
+
+### Added — v0.3.1 trace + tenant context extractors (ILS-023 prep)
+- `IuguLogger::TraceContext.extract(rack_env:)` — chain of sources:
+  1. `OpenTelemetry::Trace.current_span` (when otel-api gem loaded)
+  2. `Datadog::Tracing.active_trace` (when ddtrace loaded — Ruby 2.4 OK)
+  3. W3C `traceparent` header (manual parse, version-agnostic)
+  4. Legacy iugu `X-Request-Id` / `action_dispatch.request_id` (padded to
+     32 hex; correlation only, not a real W3C trace ID — for platform/Ruby 2.4)
+  5. `nil`
+- Ruby 2.4 first-class — defensive `rescue StandardError` around tracing-lib
+  calls so any oddity in OTEL/ddtrace can't break logging.
+- `IuguLogger::TenantContext.from_rack(env, key_mapping:)` — extracts
+  iugu.* identifiers from Rack env using the convention
+  `env['iugu.current_<field>']`. Default mapping covers account_id,
+  subaccount_id, organization_id, user_id, tier, feature.
+- 27 new RSpec examples for the two extractor modules (priority chain,
+  malformed traceparent rejection, OTEL/Datadog stubbed extraction,
+  custom key mappings).
+
+These modules are pure utilities — Logger does NOT call them automatically
+yet. Apps integrate manually:
+
+```ruby
+IuguLogger.event('pix.out.requested',
+  trace: IuguLogger::TraceContext.extract(rack_env: request.env),
+  iugu:  IuguLogger::TenantContext.from_rack(request.env),
+  pix:   { ... })
+```
+
+The `IuguLogger::RequestLogger` Rack middleware (v0.4) will automate this.
+
+### Changed
+- Bumped to `0.3.1`.
+
+### Added — v0.3 event.action registry validator (ILS-022)
+- `IuguLogger::Schema::Validator` with 3 modes:
+  - `:strict` — raises `IuguLogger::UnknownEventAction` (with typo suggestions
+    via Levenshtein) or `IuguLogger::SchemaViolation` (with missing field list)
+  - `:warn` — emits the log with `labels.schema_warning` annotation
+    (`unknown_event_action` or `missing_required:<fields>`)
+  - `:off` — disabled (default — backward compatible)
+- `IuguLogger::Schema.load_from_file(path)` — loads `dist/registry.json`
+  from `iugu-logging-schema` (or any compatible file).
+- `Configuration#event_action_validator` (`:strict`/`:warn`/`:off`)
+- `Configuration#event_action_registry` (Hash from load_from_file or nil)
+- Logger applies registry `event_kind` override when caller does not pass
+  explicit `kind:` (e.g. `pix.out.executed` → audit class automatically).
+- Required fields support dot-notation paths (`pix.end_to_end_id`,
+  `iugu.account_id`); accepts both string and symbol keys; empty strings
+  treated as missing.
+- 16 RSpec examples for Schema + 8 integration tests in Logger.
+
+### Changed
+- `Logger#event` validates against registry BEFORE PII scan (fail fast).
+- `event(action, severity:, kind:, ...)` now defaults severity/kind to nil
+  (was `:info`/`'event'`); registry overrides take precedence over defaults
+  but caller-provided values still win.
+- Bumped to `0.3.0`.
+
+### Added — v0.2 PII redaction (ILS-021)
+- `IuguLogger::Pii` — 3-layer defense:
+  - **Layer 1 (param-name filter):** values of keys matching the blocklist
+    (password, secret, token, authorization, api_key, cvv, ssn, pin, etc.)
+    replaced with `[FILTERED]` before any content scan. Case-insensitive.
+  - **Layer 2 (regex content redaction):** patterns for CPF, CNPJ, email,
+    phone (BR), CC, AWS access key, Bearer token, URL with embedded
+    credentials. Regex reused from production-validated
+    `core/utils/sanitizer.py` (iugu-agents).
+  - **Layer 3 (Logger enforcement):** every emitted payload carries
+    `pii.scanned=true` populated by Scanner.
+- `Pii::SAFE_PATTERNS` — `iugu.account_id` 32-hex preserved (ILS-002).
+- `Pii::DEFAULT_STRATEGIES` — per-type redaction config:
+  - `cpf/cnpj/phone/aws_key/bearer/url_with_creds` → `:full_redact`
+  - `cc` → `:last4` (PCI-safe `**** **** **** 1234`)
+  - `email` → `:detect_only` (ILS-003 deferred — tech debt)
+  - Override per-type via `Configuration#pii_redaction`.
+- `Pii::Result` — frozen object with `payload`, `detected`, `redacted_count`,
+  `to_pii_block` for serialization.
+- `Configuration#pii_redaction` and `#pii_param_blocklist` accessors.
+- 23 new RSpec examples for the Pii module + 7 integration tests in Logger.
+
+### Changed
+- `Logger#event` now scans the user-supplied portion (message + fields) via
+  `Pii::Scanner` before emitting. SDK-controlled metadata fields
+  (`@timestamp`, `service.*`, `pii.*`) bypass scanning.
+- `pii.*` block in emitted payload populated dynamically from scan results
+  (was static placeholder in v0.1).
+- Bumped to `0.2.0`.
+
+### Added — v0.1 skeleton (ILS-020)
+- `IuguLogger.configure` DSL with `service_name`, `service_version`,
+  `service_environment`, `output`, `format`.
+- `IuguLogger.event(action, **fields)` — emits a JSON line conforming to the
+  iugu canonical schema (`@timestamp`, `log.level`, `event.kind`,
+  `event.action`, `service.*`, `pii.*`, plus pass-through fields).
+- `IuguLogger::Severity` with custom `:note` level between `:info` and `:warn`.
+- `IuguLogger::Configuration` with `validate!` (raises on missing required
+  fields).
+- `IuguLogger::Logger` core — recursive hash key stringification, nil field
+  omission, JSON/pretty output formats.
+- Custom error classes: `Error`, `ConfigurationError`, `SchemaViolation`,
+  `UnknownEventAction`.
+- 14 RSpec examples covering happy paths and edge cases.
+- CI matrix: Ruby 2.4 / 2.7 / 3.2.
+
+### Pending (next releases)
+- v0.2 — `IuguLogger::Pii` (deep PII redaction, BR regex)
+- v0.3 — `IuguLogger::Schema` (event.action registry validator)
+- v0.4 — `IuguLogger::Transformer` + `TraceContext` + `TenantContext` Rack /
+  Sidekiq / ActiveJob middlewares + Railtie auto-config
+- v1.0 — production-ready, conformance suite passing, fraud-payout pilot
+
+[Unreleased]: https://github.com/iugu-private/iugu-logger-ruby/compare/v0.1.0...HEAD

data/CODEOWNERS

@@ -0,0 +1 @@
+* @iugu-private/devops

data/README.md

@@ -2,11 +2,13 @@
 
 > SDK Ruby do iugu Logging Standard (ILS) — schema canônico, PII detection, trace context, registry de eventos, paridade `rails_semantic_logger`. Funciona de Ruby 2.4 (platform) até 3.x (Rails 8).
 
-SDK Ruby que implementa o **iugu Logging Standard (ILS)**: logging estruturado JSON, schema canônico de eventos, detecção de PII e correlação de trace context.
+📖 **Conceito do projeto + como funciona o ILS:** [`iugu-logging-schema/README.md`](https://github.com/iugu-private/iugu-logging-schema)
+🏗️ **Arquitetura técnica detalhada:** [`iugu-logging-schema/ARCHITECTURE.md`](https://github.com/iugu-private/iugu-logging-schema/blob/main/ARCHITECTURE.md)
+🤖 **Contexto pra agentes de IA continuarem:** [CLAUDE.md](CLAUDE.md)
 
 ---
 
-## Status: **v0.9.0 — em produção**
+## Status: **v0.9.0 — em produção no fraud-payout (ILS-030 pilot)**
 
 Validado em produção em 2026-05-13 com tráfego real. Componentes:
 
@@ -42,14 +44,59 @@ Validado em produção em 2026-05-13 com tráfego real. Componentes:
 ### 1. Adicionar a gem ao `Gemfile`
 
 ```ruby
-gem "iugu_logger", "~> 0.9"
+source "https://rubygems.pkg.github.com/iugu-private" do
+  gem "iugu_logger", "~> 0.9"
+end
+```
+
+### 2. Workflow CI declara `permissions: { contents: read, packages: read }`
+
+Pra workflows que rodam `bundle install`:
+
+```yaml
+jobs:
+  test:
+    permissions:
+      contents: read
+      packages: read
+    steps:
+      - uses: iugu-private/workflows-engenharia/.github/actions/setup-ruby@v1
+        with:
+          ruby-version: 3.3.9
+          bundler-cache: true
+```
+
+Pra workflows que buildam Docker image (production deploys), passar opt-in:
+
+```yaml
+build_and_push:
+  permissions:
+    contents: read
+    packages: read
+  uses: iugu-private/workflows-engenharia/.github/workflows/build-and-push-workflow.yml@v1
+  with:
+    BUNDLE_GITHUB_PACKAGES_AUTH: true
+    # ... outros inputs
 ```
 
-Depois rode `bundle install`. A gem é pública na RubyGems.org — sem `source` customizado, autenticação ou secret de build.
+E no `Dockerfile`:
 
-Defina `GIT_SHA` no build/deploy (`service.version` dos eventos): no Dockerfile via `ARG GIT_SHA` + `ENV GIT_SHA=${GIT_SHA}`, ou via env no Deployment.
+```dockerfile
+# syntax=docker/dockerfile:1.4
 
-### 2. Gerar initializer + populate Rack tenant + smoke
+FROM ruby:3.3.9
+ARG GIT_SHA=0.0.0
+ENV GIT_SHA=${GIT_SHA}
+
+COPY . /app
+WORKDIR /app
+
+RUN --mount=type=secret,id=bundle_github_packages_auth \
+    BUNDLE_RUBYGEMS__PKG__GITHUB__COM="$(cat /run/secrets/bundle_github_packages_auth)" \
+    bundle install
+```
+
+### 3. Gerar initializer + populate Rack tenant + smoke
 
 ```sh
 rails g iugu_logger:install
@@ -99,7 +146,7 @@ end
   "message": "PATCH /api/v1/payments 200 [39ms]",
 
   "service": {
-    "name": "payments-api",
+    "name": "iugu-fraud-payout",
     "version": "1db43d1c238229c550a68d44c3be6892fc11d398",  // build SHA
     "environment": "production"
     // "instance" (= pod name) é opt-in: por padrão NÃO é emitido, pois o
@@ -219,7 +266,7 @@ end
 
 ```ruby
 IuguLogger.configure do |c|
-  c.service_name        = "payments-api"   # auto-derived em Rails
+  c.service_name        = "iugu-fraud-payout"   # auto-derived em Rails
   c.service_version     = ENV["GIT_SHA"] || "0.0.0"
   c.service_environment = Rails.env
 
@@ -328,10 +375,11 @@ IuguLogger.event("user.processing.failed",
 
 ---
 
-## Decisões aplicadas
+## Decisões aplicadas (ver [iugu-logging-schema/CONTRIBUTING.md](https://github.com/iugu-private/iugu-logging-schema/blob/main/CONTRIBUTING.md))
 
 | ID | Decisão | Implementação |
 |---|---|---|
+| ILS-001 | 4 repos próprios em `iugu-private` | Este é um deles |
 | ILS-002 | `iugu.account_id` 32-hex preservado | `Pii::SAFE_PATTERNS` + `SAFE_KEY_PATHS` |
 | ILS-003 | Email `:detect_only` (deferido — agora **generalizado** em v0.7) | `Pii::DEFAULT_STRATEGIES` |
 | §13.7 | Ruby 2.4 first-class | `gemspec.required_ruby_version >= 2.4` + CI matrix |
@@ -348,7 +396,9 @@ IuguLogger.event("user.processing.failed",
 
 ## Distribuição
 
-Publicada na [RubyGems.org](https://rubygems.org/gems/iugu_logger) — `gem "iugu_logger"`, sem autenticação. Versionamento segue [SemVer](https://semver.org) e o `CHANGELOG.md` acompanha cada release.
+Tag `v*` no main dispara `release-please` → cria Release PR → ao mergear, tag + workflow `release.yml` rodam automaticamente (via `workflow_call`) e publicam a gem em `https://rubygems.pkg.github.com/iugu-private`. Zero `gh workflow run` manual.
+
+Composite `iugu-private/workflows-engenharia/setup-ruby@v1` exporta `BUNDLE_RUBYGEMS__PKG__GITHUB__COM` automaticamente nos consumers.
 
 ---
 
@@ -376,4 +426,4 @@ CI valida matriz Ruby 2.4 + 2.7 + 3.2 em todo PR.
 
 ## Ownership
 
-Mantido pela Engenharia de Plataforma da iugu — `eng-plataforma@iugu.com`.
+Eng Plataforma. Spec completo: [`devops/docs/IUGU_LOGGING_STANDARD.md`](https://github.com/iugu-private/devops/blob/main/docs/IUGU_LOGGING_STANDARD.md). Workflow de contribuição: [`iugu-logging-schema/CONTRIBUTING.md`](https://github.com/iugu-private/iugu-logging-schema/blob/main/CONTRIBUTING.md).

data/lib/generators/iugu_logger/install/install_generator.rb

@@ -21,6 +21,7 @@ module IuguLogger
       def post_install_summary
         say "\n  iugu_logger #{IuguLogger::VERSION} initializer installed.", :green
         say '  Run `bundle exec rake iugu_logger:smoke` to validate the setup.', :green
+        say '  Spec: https://github.com/iugu-private/devops/blob/main/docs/IUGU_LOGGING_STANDARD.md', :cyan
       end
 
       private

data/lib/generators/iugu_logger/install/templates/iugu_logger.rb.tt

@@ -6,6 +6,8 @@
 # below cover the canonical case. After changes, validate with:
 #
 #     bundle exec rake iugu_logger:smoke
+#
+# Spec: https://github.com/iugu-private/devops/blob/main/docs/IUGU_LOGGING_STANDARD.md
 
 IuguLogger.configure do |c|
   c.service_name        = '<%= default_service_name %>'

data/lib/iugu_logger/job_logger.rb

@@ -101,8 +101,9 @@ module IuguLogger
           error: {
             'type'        => error.class.name,
             'message'     => error.message.to_s,
+            'stack_trace' => clean_backtrace(error),
             'fingerprint' => fingerprint(error)
-          },
+          }.compact,
           logs: logs.empty? ? nil : logs
         )
       end
@@ -135,6 +136,24 @@ module IuguLogger
       def normalized_message(msg)
         msg.to_s.gsub(/\d+/, 'N').gsub(/[a-f0-9]{16,}/i, 'HEX')
       end
+
+      # error.stack_trace as an array of frames (schema v2.0.0). Mirrors
+      # RequestLogger#clean_backtrace: nil when no backtrace (dropped by
+      # `.compact`), Rails BacktraceCleaner when available (gem is standalone),
+      # capped at 50 frames.
+      STACK_TRACE_LIMIT = 50
+
+      def clean_backtrace(error)
+        frames = error.backtrace
+        return nil if frames.nil? || frames.empty?
+
+        if defined?(::Rails) && ::Rails.respond_to?(:backtrace_cleaner)
+          cleaned = ::Rails.backtrace_cleaner.clean(frames)
+          frames  = cleaned unless cleaned.nil? || cleaned.empty?
+        end
+
+        frames.first(STACK_TRACE_LIMIT)
+      end
     end
 
     # Sidekiq server middleware. Compatible with sidekiq, sidekiq-pro,

data/lib/iugu_logger/railtie.rb

@@ -46,7 +46,7 @@ module IuguLogger
 
     # Captures Rails view/db runtime from the canonical ActiveSupport
     # notification fired at the end of every controller action. For
-    # ActionController::API
+    # ActionController::API (used by fraud-payout and most iugu services)
     # the legacy `action_dispatch.view_runtime` / `db_runtime` env keys
     # aren't populated by Rails — but the `process_action.action_controller`
     # notification payload always has both. We stash them in Buffer; the

data/lib/iugu_logger/request_logger.rb

@@ -139,7 +139,9 @@ module IuguLogger
     #   - env['action_dispatch.db_runtime']     → db_runtime_ms   (full-stack Rails)
     #   - Buffer.current.rails_runtime          → view_ms / db_ms captured by
     #                                              process_action subscriber
-    #                                              (ActionController::API path)
+    #                                              (ActionController::API path —
+    #                                              fraud-payout, smart-vault,
+    #                                              most iugu services)
     def extract_rails_info(env)
       controller = env['action_controller.instance']
 
@@ -191,8 +193,9 @@ module IuguLogger
         error:    {
           'type'        => error.class.name,
           'message'     => error.message.to_s,
+          'stack_trace' => clean_backtrace(error),
           'fingerprint' => fingerprint(error)
-        },
+        }.compact,
         logs:     logs.empty? ? nil : logs
       )
     end
@@ -253,5 +256,26 @@ module IuguLogger
       # Strip variable parts (numbers, hex blobs) so similar errors group
       msg.to_s.gsub(/\d+/, 'N').gsub(/[a-f0-9]{16,}/i, 'HEX')
     end
+
+    # error.stack_trace as an array of frames (schema v2.0.0: array, maxItems
+    # 50). Returns nil (→ dropped by `.compact`) when there is no backtrace, so
+    # we never emit a null into the array-typed field. Uses Rails'
+    # BacktraceCleaner to strip framework noise WHEN available — the gem is
+    # standalone (Ruby 2.4+, no hard Rails dep), so we degrade to the raw
+    # backtrace outside Rails. PII in frames is handled by the scanner
+    # downstream (the error block is scanned like any other field).
+    STACK_TRACE_LIMIT = 50
+
+    def clean_backtrace(error)
+      frames = error.backtrace
+      return nil if frames.nil? || frames.empty?
+
+      if defined?(::Rails) && ::Rails.respond_to?(:backtrace_cleaner)
+        cleaned = ::Rails.backtrace_cleaner.clean(frames)
+        frames  = cleaned unless cleaned.nil? || cleaned.empty?
+      end
+
+      frames.first(STACK_TRACE_LIMIT)
+    end
   end
 end

data/lib/iugu_logger/schema.rb

@@ -5,8 +5,8 @@ require 'json'
 module IuguLogger
   # event.action registry validator.
   #
-  # Loads a compiled event.action registry (`dist/registry.json`) and validates
-  # each `event.action` emitted against it.
+  # Loads a registry produced by `iugu-private/iugu-logging-schema/tools/compile_registry.rb`
+  # (`dist/registry.json`) and validates each `event.action` emitted against it.
   #
   # Three modes:
   #   :strict — raise IuguLogger::UnknownEventAction / SchemaViolation

data/lib/iugu_logger/version.rb

@@ -1,5 +1,16 @@
 # frozen_string_literal: true
 
 module IuguLogger
-  VERSION = '0.10.0'
+  VERSION = '0.11.0'
+
+  # Canonical schema version this SDK is built against. MUST match the
+  # `version` of the vendored snapshot at
+  # spec/conformance/fixtures/canonical_schema.json — the schema_version_spec
+  # asserts this, and the schema-freshness CI compares it against the latest
+  # release of iugu-private/iugu-logging-schema.
+  #
+  # Bump this ONLY via `rake iugu_logger:sync_schema` (or the schema-sync
+  # workflow), never by hand. Schema changes upstream FIRST, the SDK syncs
+  # AFTER. See CONTRIBUTING / IUGU_LOGGING_STANDARD.md §4.
+  SUPPORTED_SCHEMA_VERSION = '2.0.0'
 end

data/lib/iugu_logger.rb

@@ -18,9 +18,11 @@ require 'iugu_logger/railtie' if defined?(::Rails::Railtie)
 # iugu Logging Standard (ILS) — Ruby SDK
 #
 # Native iugu structured logging SDK. Standalone (no third-party logging
-# gem dependency). Implements the iugu Logging Standard (ILS) canonical schema.
+# gem dependency). Implements the canonical schema from `iugu-logging-schema`.
 #
-# Compatibility: Ruby >= 2.4 (covers Rails 4.2 through modern services).
+# Spec: https://github.com/iugu-private/devops/blob/main/docs/IUGU_LOGGING_STANDARD.md
+#
+# Compatibility: Ruby >= 2.4 (covers platform Rails 4.2 through modern services).
 #
 # @example basic setup
 #   IuguLogger.configure do |c|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: iugu_logger
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Eng Plataforma iugu
@@ -100,7 +100,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE.md
+- CHANGELOG.md
+- CODEOWNERS
 - README.md
 - lib/generators/iugu_logger/install/install_generator.rb
 - lib/generators/iugu_logger/install/templates/iugu_logger.rb.tt
@@ -119,12 +120,13 @@ files:
 - lib/iugu_logger/tenant_context.rb
 - lib/iugu_logger/trace_context.rb
 - lib/iugu_logger/version.rb
-homepage: https://rubygems.org/gems/iugu_logger
+homepage: https://github.com/iugu-private/iugu-logger-ruby
 licenses:
-- Apache-2.0
+- Nonstandard
 metadata:
-  allowed_push_host: https://rubygems.org
-  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/iugu-private/iugu-logger-ruby
+  changelog_uri: https://github.com/iugu-private/iugu-logger-ruby/blob/main/CHANGELOG.md
+  iugu_logging_standard: https://github.com/iugu-private/devops/blob/main/docs/IUGU_LOGGING_STANDARD.md
 rdoc_options: []
 require_paths:
 - lib
@@ -139,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.6.8
 specification_version: 4
 summary: Native iugu structured logging SDK — schema canonical, PII-aware, trace-context
   aware.

data/LICENSE.md

@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2026 iugu
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.