exis_ray 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91d6964520e83c2088af45357edf601358d2ffefbff4861ef15e1abaf09a36bc
-  data.tar.gz: d276b0753bd7b956662a3f6e1d61cb51d707a9729496f17b8bd4a3ca1bc7fba4
+  metadata.gz: 95101aa6f502c3c839070a556ab984244493d9f8bbabaad2b3b4e2e83b19cc67
+  data.tar.gz: af2097e279144370005dd457effbeaf961a11938f191a9aa30053efe717f9b12
 SHA512:
-  metadata.gz: 4b382e4fcd8171db8771f9f5f8d2238fdf2cd17b2ac4e953c54d06248eab390c321bf37579b954e3965bb7092c0959dcfae999782200ea8cbee487ca6c74b314
-  data.tar.gz: a6da50e40e16e4560d6c52e6443b36d2c7ffef5263940b73a3696d7411817ef5990cd26bf625141984694b7d2f824b22fdd88ba2e9072762b721b9e1718a3eaf
+  metadata.gz: 62e1bf2fe943f02976ba69b73ba9d76e698f93f6b9d1284a02354c01c4ab4d5b18411212da27ffe0ea315616184dfce0d3b66dc9a871c6cebbb50320656f5342
+  data.tar.gz: 10cf92356274c0da04446c96a109f298eb2c94a8eacb3787762e9785cf42915b877304161f70aeb6ac8478598b29c6aca127057a0db8d7f089f29b046a9bd954

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.8.0] - 2026-05-14
+
+### Nuevas funcionalidades
+- **`Current.log_fields` hook** (#6, #8): class method overridable en `ExisRay::Current` para inyectar campos custom en cada log line. Cubre con un solo mecanismo tanto constantes de proceso (frozen constants en la subclass) como valores dinámicos per-request (atributos de Current). `JsonFormatter` filtra claves sensibles del hash retornado y rescata silenciosamente si el override revienta. Útil para servicios multi-tenant donde se necesita inyectar `tenant_id`, `region`, `stack_id`, etc.
+
+### Mejoras internas
+- **`.rubocop.yml` relajado para destrabar CI**: los thresholds default venían bloqueando todos los PRs recientes. Excluido `Metrics/BlockLength` en specs y railtie, deshabilitado `Lint/SuppressedException` (el estándar Wispro requiere `rescue StandardError` vacíos en logging), thresholds más realistas para Metrics en lib/.
+
+## [0.7.2] - 2026-05-11
+
+### Documentación
+- **Warning sobre `ActiveSupport::TaggedLogging` con JSON logging:** `TaggedLogging` antepone tags como texto raw antes del formatter, rompiendo el JSON (`[req_id] {...}`). `JsonFormatter` ya inyecta `request_id`/`trace_id` como campos JSON — usar ambos genera salida inválida. Documentada la config correcta del logger en `production.rb` (README + SKILL FAQ).
+- **Skill improvements (issue #4):** (1) Clarificado el criterio auto-inyectado vs manual — el formatter solo conoce contexto de ejecución (Tracer/Current), por eso `component` y `event` deben aportarse manualmente. (2) Agregados ejemplos concretos de output JSON lado-a-lado con el input KV/Hash. (3) Completada la lista de campos default de `LogSubscriber` (17 campos con tipos y condiciones, antes truncado con "etc."). (4) Documentados los 3 modos de input del formatter (KV / Hash / string libre) con ejemplos de cada uno.
+
 ## [0.7.1] - 2026-04-06
 
 ### Fixed

data/CLAUDE.md

@@ -111,6 +111,7 @@ ExisRay.configuration.json_logs?                # => true/false
 | `correlation_id` | Cuando `Current.correlation_id` está presente |
 | `user_id` | Cuando `Current.user_id` está presente |
 | `isp_id` | Cuando `Current.isp_id` está presente |
+| `Current.log_fields` (cualquier key) | Si la subclass overrideó el hook (default `{}`) |
 | `sidekiq_job` | Solo en procesos Sidekiq |
 | `task` | Solo en procesos TaskMonitor |
 | `tags` | Solo si hay Rails tagged logging activo |

data/README.md

@@ -151,6 +151,38 @@ end
 | `Current.user?` / `Current.isp?` | Predicate: true si el ID no es nil |
 | `Current.correlation_id?` | Predicate: true si está presente (no vacío) |
 
+#### Hook `log_fields` — inyectar campos custom en cada log
+
+`Current.log_fields` es un class method overridable que retorna un Hash de campos
+extra a inyectar en cada log line, junto a `user_id`/`isp_id`/`correlation_id`.
+Cubre tanto **constantes de proceso** (declaradas como frozen constants en la
+subclass) como **valores dinámicos per-request** (leídos de atributos de
+`Current`) — todo en un solo lugar.
+
+```ruby
+class Current < ExisRay::Current
+  TENANT_ID = ENV.fetch("TENANT_ID").freeze   # static, frozen al boot
+  attribute :region                             # dynamic, per-request
+
+  def self.log_fields
+    { tenant_id: TENANT_ID, region: region }.compact
+  end
+end
+
+# En un before_action / middleware:
+Current.region = request.headers["X-Region"]
+
+# Los logs salen automáticamente con tenant_id y region:
+# {"...":"...", "tenant_id":"42", "region":"us-east-1", "event":"..."}
+```
+
+**Reglas:**
+
+- Default `{}` — cero overhead si no se override.
+- `JsonFormatter` filtra claves sensibles del hash retornado (`api_key`, `token`, etc.).
+- Si el override revienta, el formatter lo rescata silenciosamente (logging nunca debe afectar el flujo principal).
+- **Precedencia**: los campos canónicos del Tracer (`trace_id`, `root_id`, etc.) y las keys del propio mensaje del developer (ej. `Rails.logger.info "tenant_id=99"`) pisan `log_fields`. No sirve para overrideear campos canónicos, solo para agregar nuevos.
+
 ### Reporter (reporte de errores)
 
 `ExisRay::Reporter` es un wrapper de Sentry que enriquece automáticamente cada evento con el trace context del `Tracer` y el contexto de negocio del `Current`. Soporta Sentry SDK moderno y legacy (Raven/Session).
@@ -252,22 +284,46 @@ Con `log_format: :json`, `ExisRay::JsonFormatter` reemplaza el formatter de Rail
 {"time":"2026-04-01T14:30:00Z","level":"INFO","severity_number":9,"service":"wispro_agent","service_version":"1.2.3","deployment_environment":"production","root_id":"1-65f...abc","trace_id":"Root=1-65f...;Self=...","source":"http","user_id":42,"isp_id":10,"component":"exis_ray","event":"http_request","method":"GET","path":"/api/v1/users","http_route":"/api/v1/users","http_status":200,"duration_s":0.0452,"user_agent_original":"Mozilla/5.0","server_address":"api.example.com"}
 ```
 
-Los mensajes con formato `key=value` se parsean y elevan al root del JSON. Los valores numéricos se castean automáticamente:
+El formatter acepta tres tipos de mensaje. Los tres producen output JSON equivalente; elegí el que sea más legible para tu caso:
 
 ```ruby
+# 1. String KV — one-liner rápido, valores numéricos se castean
 Rails.logger.info "component=billing event=invoice_created invoice_id=123 total=45.50"
-# => {"time":"...","level":"INFO","service":"...","root_id":"...","component":"billing","event":"invoice_created","invoice_id":123,"total":45.5}
-```
 
-Los mensajes tipo Hash (usados internamente por `LogSubscriber`) se mergean directamente. Los mensajes de texto libre se asignan a la clave `body`:
+# 2. Hash style — payloads complejos o con valores nested
+Rails.logger.info(component: "billing", event: "invoice_created",
+                  invoice: { id: 123, total: 45.50 })
 
-```ruby
+# 3. String libre — fallback, va a la clave `body`
 Rails.logger.info "Algo pasó sin formato KV"
 # => {"time":"...","level":"INFO","service":"...","body":"Algo pasó sin formato KV"}
 ```
 
+Los mensajes Hash también son la forma que usa internamente `LogSubscriber` para emitir el cierre de cada request HTTP.
+
+> **Nota:** `component` (módulo de negocio) y `event` (qué pasó) **no** son auto-inyectados — los aporta el call site. El formatter solo conoce el contexto de **ejecución** (quién, de dónde, con qué identidad), no el contexto del **lugar del código** que loguea.
+
 En modo `:text`, ExisRay inyecta el `trace_id` o `root_id` como tag de Rails (`config.log_tags`) y no modifica el formatter.
 
+### Configuración del logger en producción
+
+Para logs JSON limpios sin códigos ANSI ni texto extra, configurar el logger así:
+
+```ruby
+# config/environments/production.rb
+config.colorize_logging = false
+config.logger = ActiveSupport::Logger.new(STDOUT)
+config.logger.formatter = ExisRay::JsonFormatter
+```
+
+**No usar `ActiveSupport::TaggedLogging`** — agrega tags como texto al inicio de cada línea antes del formatter, lo cual rompe el JSON:
+
+```
+[request_id] {"time":"...","level":"INFO",...}   # ← texto antes del JSON (INVALIDO)
+```
+
+`ExisRay::JsonFormatter` ya inyecta los tags (`request_id`, `trace_id`, etc.) como campos JSON, así que `TaggedLogging` es redundante e incompatible.
+
 ### Campos auto-inyectados
 
 `JsonFormatter` inyecta estos campos automáticamente en cada línea. **Nunca** los incluyas manualmente en tus logs:
@@ -286,21 +342,34 @@ En modo `:text`, ExisRay inyecta el `trace_id` o `root_id` como tag de Rails (`c
 | `correlation_id` | Cuando `Current.correlation_id` está presente |
 | `user_id` | Cuando `Current.user_id` no es nil |
 | `isp_id` | Cuando `Current.isp_id` no es nil |
+| `Current.log_fields` (cualquier key) | Si la subclass overrideó el hook y retornó un Hash no vacío |
 | `sidekiq_job` | Solo en procesos Sidekiq |
 | `task` | Solo en procesos TaskMonitor |
 | `tags` | Solo si hay Rails tagged logging activo |
 
-`LogSubscriber` inyecta además estos campos en los logs de requests HTTP:
-
-| Campo | Descripción |
-|:------|:------------|
-| `http_status` | Código HTTP (Integer). Antes `status`, renombrado en v0.6.0 |
-| `http_route` | Template de ruta (ej: `/users/:id`). Resolución via `route.defaults` |
-| `user_agent_original` | Header `User-Agent` del request |
-| `server_address` | Hostname sin puerto del header `Host` |
-| `exception.type` | Clase de la excepción (cuando el request falla) |
-| `exception.message` | Mensaje de la excepción |
-| `exception.stacktrace` | Primeras 20 líneas del backtrace |
+`LogSubscriber` inyecta además estos campos en cada log de cierre de request HTTP. **Nunca duplicarlos** en logs manuales:
+
+| Campo | Tipo | Notas |
+|:------|:-----|:------|
+| `component` | String | Siempre `"exis_ray"` |
+| `event` | String | Siempre `"http_request"` |
+| `method` | String | Verbo HTTP |
+| `path` | String | URL concreta del request |
+| `http_route` | String | Template (ej: `/users/:id`). Baja cardinalidad para dashboards |
+| `format` | Symbol/String | `html`, `json`, etc. |
+| `controller` | String | Class name del controller |
+| `action` | String | Nombre del action |
+| `http_status` | Integer | Status HTTP final. Antes `status`, renombrado en v0.6.0 |
+| `duration_s` | Float | Segundos (Rails reporta ms, se convierte), redondeo 4 decimales |
+| `duration_human` | String | Legible: `"42.5ms"`, `"1.25s"`, `"2 minutes 5 seconds"` |
+| `view_runtime_s` | Float\|nil | Solo si Rails lo reporta |
+| `db_runtime_s` | Float\|nil | Solo si ActiveRecord lo reporta |
+| `user_agent_original` | String | Header `User-Agent` |
+| `server_address` | String | Hostname sin puerto del header `Host` |
+| `error_class`, `error_message` | String | Solo en fallo (legacy) |
+| `exception.type`, `exception.message`, `exception.stacktrace` | String | Solo en fallo (OTel; stack limitado a 20 líneas) |
+
+Severity del log: `ERROR` si `http_status >= 500`, sino `INFO`.
 
 ### Filtrado de claves sensibles
 

data/lib/exis_ray/current.rb

@@ -8,6 +8,30 @@ module ExisRay
   class Current < ActiveSupport::CurrentAttributes
     attribute :user_id, :isp_id, :correlation_id
 
+    # Hook overridable por la subclass de la app host. Retorna un Hash de campos
+    # extra a inyectar en cada log line, junto a `user_id`/`isp_id`/`correlation_id`.
+    #
+    # Pensado para cubrir tanto constantes de proceso (declaradas como `freeze`-d
+    # constants en la subclass) como valores dinámicos per-request (leídos de
+    # atributos de Current). El JsonFormatter invoca este método en cada log y
+    # mergea el resultado al payload — luego de los campos canónicos pero antes
+    # de las keys del propio mensaje del developer (que ganan por override).
+    #
+    # @example Constantes de proceso + valores per-request combinados
+    #   class Current < ExisRay::Current
+    #     TENANT_ID = ENV.fetch("TENANT_ID").freeze
+    #     attribute :region
+    #
+    #     def self.log_fields
+    #       { tenant_id: TENANT_ID, region: region }.compact
+    #     end
+    #   end
+    #
+    # @return [Hash] Pares clave/valor a inyectar. Default `{}`.
+    def self.log_fields
+      {}
+    end
+
     # Callback nativo de Rails: Se ejecuta automáticamente al llamar a Current.reset
     resets do
       @user_object = nil

data/lib/exis_ray/json_formatter.rb

@@ -122,9 +122,28 @@ module ExisRay
       payload[:user_id] = curr.user_id if curr.respond_to?(:user_id) && !curr.user_id.nil?
       payload[:isp_id]  = curr.isp_id  if curr.respond_to?(:isp_id)  && !curr.isp_id.nil?
 
-      return unless curr.respond_to?(:correlation_id) && curr.correlation_id
+      payload[:correlation_id] = curr.correlation_id if curr.respond_to?(:correlation_id) && curr.correlation_id
 
-      payload[:correlation_id] = curr.correlation_id
+      inject_log_fields(payload, curr)
+    end
+
+    # Mergea el resultado de `Current.log_fields` al payload, aplicando el mismo
+    # filtrado de claves sensibles que el resto del formatter. Si la subclass del
+    # host overrideó el hook y revienta, el error se traga: logging nunca debe
+    # afectar el flujo principal.
+    #
+    # @param payload [Hash]
+    # @param curr [Class] La clase Current configurada por la app host.
+    # @return [void]
+    def inject_log_fields(payload, curr)
+      return unless curr.respond_to?(:log_fields)
+
+      fields = curr.log_fields
+      return if fields.nil? || fields.empty?
+
+      payload.merge!(filter_sensitive_hash(fields))
+    rescue StandardError
+      nil
     end
 
     # Inyecta cualquier etiqueta nativa (tags) de Rails que esté presente en el hilo actual.

data/lib/exis_ray/railtie.rb

@@ -44,16 +44,12 @@ module ExisRay
       # y safe_constantize puede fallar aún con eager_load=true.
       if (name = ExisRay.configuration.current_class).present?
         klass = name.safe_constantize
-        if klass && !klass.<=(ExisRay::Current)
-          raise "ExisRay: current_class '#{name}' does not inherit from ExisRay::Current"
-        end
+        raise "ExisRay: current_class '#{name}' does not inherit from ExisRay::Current" if klass && !klass.<=(ExisRay::Current)
       end
 
       if (name = ExisRay.configuration.reporter_class).present?
         klass = name.safe_constantize
-        if klass && !klass.<=(ExisRay::Reporter)
-          raise "ExisRay: reporter_class '#{name}' does not inherit from ExisRay::Reporter"
-        end
+        raise "ExisRay: reporter_class '#{name}' does not inherit from ExisRay::Reporter" if klass && !klass.<=(ExisRay::Reporter)
       end
 
       # Aplicamos el formateador JSON globalmente al logger ya instanciado de Rails

data/lib/exis_ray/version.rb

@@ -2,5 +2,5 @@
 
 module ExisRay
   # Versión actual de la gema.
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end

data/skill/SKILL.md

@@ -71,8 +71,8 @@ ExisRay unifica trazabilidad distribuida, logging estructurado JSON, contexto de
 2. `Tracer.parse_trace_id` extrae `root_id`, `self_id`, `called_from`, `total_time_so_far`
 3. `ExisRay.sync_correlation_id` asigna `Tracer.correlation_id` a `Current.correlation_id`
 4. Controller ejecuta `before_action` para setear `Current.user_id`, `Current.isp_id`
-5. `JsonFormatter` intercepta cada `Rails.logger.*` e inyecta automaticamente: `time`, `level`, `severity_number`, `service`, `service_version`, `deployment_environment`, `root_id`, `trace_id`, `source`, `user_id`, `isp_id`, `correlation_id`
-6. `LogSubscriber` emite un unico Hash al finalizar el request (method, path, http_status, http_route, duration_s, user_agent_original, server_address, etc.)
+5. `JsonFormatter` intercepta cada `Rails.logger.*` e inyecta automaticamente: `time`, `level`, `severity_number`, `service`, `service_version`, `deployment_environment`, `root_id`, `trace_id`, `source`, `user_id`, `isp_id`, `correlation_id`. El developer aporta `component` (modulo de negocio) y `event` (que paso); estos NO son auto-inyectados porque dependen del call site, no del contexto de ejecucion.
+6. `LogSubscriber` emite un unico Hash al finalizar el request con campos default (`component`, `event`, `method`, `path`, `http_route`, `format`, `controller`, `action`, `http_status`, `duration_s`, `duration_human`, `view_runtime_s`, `db_runtime_s`, `user_agent_original`, `server_address`, y en error `error_class`/`error_message`/`exception.*`).
 7. En llamadas salientes, `FaradayMiddleware`/`ActiveResourceInstrumentation` inyectan `propagation_trace_header` con `Tracer.generate_trace_header`
 8. Al finalizar, `ActiveSupport::CurrentAttributes` hace reset automatico
 
@@ -163,6 +163,27 @@ Current.correlation_id? # => true si correlation_id es present?
 
 Los setters auto-sincronizan con `ActiveResource::Base.headers` y `PaperTrail.request` cuando estan definidos.
 
+#### Hook `log_fields` — inyectar campos custom en cada log
+
+Class method overridable que retorna un Hash de campos extra para JsonFormatter. Cubre tanto **constantes de proceso** (frozen constants en la subclass) como **valores dinámicos per-request** (atributos de Current) en un solo lugar. Default `{}`.
+
+```ruby
+class Current < ExisRay::Current
+  TENANT_ID = ENV.fetch("TENANT_ID").freeze   # static, frozen al boot
+  attribute :region                             # dynamic, per-request
+
+  def self.log_fields
+    { tenant_id: TENANT_ID, region: region }.compact
+  end
+end
+```
+
+Reglas:
+
+- `JsonFormatter` filtra claves sensibles del hash retornado (mismo regex que el resto del formatter).
+- Si el override revienta, el formatter rescata silenciosamente (logging no afecta flujo principal).
+- Precedencia: campos canónicos del Tracer y keys del mensaje del developer pisan `log_fields` en colisión. Solo sirve para agregar fields nuevos, no para overrideear los canónicos.
+
 ### ExisRay::Reporter (clase base abstracta)
 
 ```ruby
@@ -212,6 +233,32 @@ end
 
 ### ExisRay::LogSubscriber
 
+Reemplaza Lograge. Se suscribe a `process_action.action_controller` y emite un Hash por request HTTP. Severity es `ERROR` si `http_status >= 500`, sino `INFO`.
+
+**Campos default emitidos** (mergeados al payload JSON; nunca duplicarlos manualmente):
+
+| Campo | Tipo | Notas |
+|:------|:-----|:------|
+| `component` | String | Siempre `"exis_ray"` |
+| `event` | String | Siempre `"http_request"` |
+| `method` | String | Verbo HTTP |
+| `path` | String | URL concreta del request |
+| `http_route` | String | Template (ej: `/users/:id`). Baja cardinalidad para dashboards |
+| `format` | Symbol/String | `html`, `json`, etc. |
+| `controller` | String | Class name del controller |
+| `action` | String | Nombre del action |
+| `http_status` | Integer | Status HTTP final |
+| `duration_s` | Float | Segundos (Rails reporta ms, se convierte), redondeo 4 decimales |
+| `duration_human` | String | Legible: `"42.5ms"`, `"1.25s"`, `"2 minutes 5 seconds"` |
+| `view_runtime_s` | Float\|nil | Solo si Rails lo reporta |
+| `db_runtime_s` | Float\|nil | Solo si ActiveRecord lo reporta |
+| `user_agent_original` | String | Header `User-Agent` |
+| `server_address` | String | Hostname sin puerto (de `Host` header) |
+| `error_class`, `error_message` | String | Solo en fallo (legacy) |
+| `exception.type`, `exception.message`, `exception.stacktrace` | String | Solo en fallo (OTel; stack limitado a 20 lineas) |
+
+Para inyectar campos extra, sobreescribir `extra_fields`:
+
 ```ruby
 class MyLogSubscriber < ExisRay::LogSubscriber
   def self.extra_fields(event)
@@ -227,12 +274,41 @@ ExisRay.configure { |c| c.log_subscriber_class = "MyLogSubscriber" }
 
 Se asigna automaticamente a `Rails.logger.formatter` cuando `log_format: :json`. Acepta tres tipos de mensaje:
 
-- **Hash**: merge directo al payload JSON
-- **String KV** (`"event=foo bar=baz"`): parsea pares y los eleva al root del JSON
-- **String libre**: asigna al campo `body`
+- **Hash**: merge directo al payload JSON. Util para payloads complejos o con valores nested.
+- **String KV** (`"event=foo bar=baz"`): parsea pares y los eleva al root del JSON. Util para one-liners rapidos.
+- **String libre**: asigna al campo `body` (OTel log body).
 
 Casteo automatico: integers, floats, objetos JSON (`{...}`, `[...]`). Filtra claves sensibles (`password|secret|token|api_key|auth`) a `[FILTERED]`. Fallback a JSON minimo si el formateo falla.
 
+#### Criterio auto-inyectado vs manual
+
+- **Auto-inyectado** (formatter conoce desde `Tracer`/`Current`): contexto de **ejecucion** — quien hace el request, de donde viene, en que servicio, con que identidad.
+- **Manual** (lo aporta cada `Rails.logger.*`): contexto del **call site** — que modulo (`component`) y que paso (`event`). El formatter no puede saber esto sin recorrer el stack en cada log.
+
+Por eso `component` y `event` jamas se auto-inyectan, aunque el estandar Wispro los exija.
+
+#### Ejemplos: KV vs Hash producen output equivalente
+
+```ruby
+# KV string — one-liner rapido
+Rails.logger.info("component=billing event=invoice_paid invoice_id=42 total=199.99")
+
+# Hash style — payloads complejos / nested
+Rails.logger.info(component: "billing", event: "invoice_paid",
+                  invoice: { id: 42, total: 199.99 })
+
+# String libre — fallback, va a `body`
+Rails.logger.info("usuario hizo click")
+```
+
+#### Output JSON resultante (mismo para KV y Hash del ejemplo)
+
+```json
+{"time":"2026-05-11T09:15:00.123Z","level":"INFO","severity_number":9,"service":"box_radius_manager","service_version":"1.2.3","deployment_environment":"production","root_id":"1-abc","trace_id":"Root=1-abc;Self=...","source":"http","user_id":42,"isp_id":10,"correlation_id":"box_radius_manager;1-abc","component":"billing","event":"invoice_paid","invoice_id":42,"total":199.99}
+```
+
+Los campos hasta `correlation_id` los inyecta el formatter automaticamente. De `component` en adelante son los campos del mensaje del developer.
+
 ### Middlewares de propagacion
 
 ```ruby
@@ -290,6 +366,20 @@ Agrega `f.use ExisRay::FaradayMiddleware` al stack de Faraday. Solo inyecta head
 **P: Puedo usar ExisRay sin JSON logging?**
 Si. Con `log_format: :text` (default), ExisRay inyecta el `root_id` como tag de Rails via `config.log_tags`. El JsonFormatter y LogSubscriber no se activan.
 
+**P: Por que no usar `ActiveSupport::TaggedLogging` con JSON logging?**
+`TaggedLogging` agrega tags como texto plano al inicio de cada línea **antes** del formatter, lo cual rompe el JSON:
+```
+[request_id] {"time":"...","level":"INFO",...}   # ← texto antes del JSON
+```
+`ExisRay::JsonFormatter` ya inyecta los tags (`request_id`, `trace_id`, etc.) como campos JSON. Usar ambos genera JSON inválido.
+
+Configuración correcta en production.rb:
+```ruby
+config.colorize_logging = false
+config.logger = ActiveSupport::Logger.new(STDOUT)
+config.logger.formatter = ExisRay::JsonFormatter
+```
+
 **P: Que pasa con los logs de Sidekiq (el propio logger de Sidekiq)?**
 Si `json_logs?` es true, el Railtie asigna `Sidekiq.logger.formatter = ExisRay::JsonFormatter.new`, asi los logs internos de Sidekiq tambien salen en JSON.
 

data/spec/exis_ray/current_spec.rb

@@ -112,4 +112,38 @@ RSpec.describe ExisRay::Current do
       TestCurrent.correlation_id = "corr-1"
     end
   end
+
+  describe ".log_fields hook" do
+    it "retorna un Hash vacío por defecto" do
+      expect(TestCurrent.log_fields).to eq({})
+    end
+
+    it "permite que la subclass overridee el método para inyectar campos custom" do
+      stub_const("TenantCurrent", Class.new(ExisRay::Current) do
+        def self.log_fields
+          { tenant_id: "42", region: "us-east-1" }
+        end
+      end)
+
+      expect(TenantCurrent.log_fields).to eq(tenant_id: "42", region: "us-east-1")
+    end
+
+    it "soporta combinar constantes de proceso con atributos per-request" do
+      stub_const("MixedCurrent", Class.new(ExisRay::Current) do
+        attribute :region
+
+        STATIC_TENANT = "tenant-42"
+
+        def self.log_fields
+          { tenant_id: STATIC_TENANT, region: region }.compact
+        end
+      end)
+      MixedCurrent.region = "us-east-1"
+
+      expect(MixedCurrent.log_fields).to eq(tenant_id: "tenant-42", region: "us-east-1")
+
+      MixedCurrent.reset
+      expect(MixedCurrent.log_fields).to eq(tenant_id: "tenant-42")
+    end
+  end
 end

data/spec/exis_ray/json_formatter_spec.rb

@@ -261,6 +261,91 @@ RSpec.describe ExisRay::JsonFormatter do
         expect(result).not_to have_key("user_id")
       end
     end
+
+    describe "inyeccion de Current.log_fields" do
+      # Mock estilo ActiveSupport::CurrentAttributes que combina los atributos canónicos
+      # con un hook log_fields. Por defecto retorna {}, los tests lo redefinen vía stub.
+      let(:current_class_double) do
+        Class.new do
+          class << self
+            attr_accessor :user_id, :isp_id, :correlation_id, :_log_fields
+
+            def respond_to_missing?(method, *)
+              %i[user_id isp_id correlation_id log_fields].include?(method) || super
+            end
+          end
+
+          def self.log_fields
+            _log_fields || {}
+          end
+        end
+      end
+
+      before do
+        allow(ExisRay).to receive(:current_class).and_return(current_class_double)
+      end
+
+      it "inyecta los campos retornados por log_fields en el payload" do
+        current_class_double._log_fields = { tenant_id: "42", region: "us-east-1" }
+
+        result = call("event=boot")
+
+        # tenant_id="42" se castea a Integer por filter_sensitive_hash (igual que cualquier otro KV)
+        expect(result).to include("tenant_id" => 42, "region" => "us-east-1", "event" => "boot")
+      end
+
+      it "no agrega keys cuando log_fields retorna hash vacío" do
+        current_class_double._log_fields = {}
+
+        result = call("event=boot")
+
+        expect(result).not_to have_key("tenant_id")
+      end
+
+      it "no agrega keys cuando log_fields retorna nil" do
+        current_class_double._log_fields = nil
+
+        result = call("event=boot")
+
+        expect(result.keys).to contain_exactly("time", "level", "severity_number", "service", "event")
+      end
+
+      it "el mensaje del developer pisa log_fields (override por call site)" do
+        current_class_double._log_fields = { tenant_id: "from-current" }
+
+        result = call("event=override tenant_id=from-message")
+
+        expect(result["tenant_id"]).to eq("from-message")
+      end
+
+      it "filtra claves sensibles" do
+        current_class_double._log_fields = { api_key: "leaked", tenant_id: "42" }
+
+        result = call("event=boot")
+
+        expect(result["api_key"]).to eq("[FILTERED]")
+        expect(result["tenant_id"]).to eq(42)
+      end
+
+      it "no rompe el formatter si la subclass overrideó log_fields con un método que revienta" do
+        allow(current_class_double).to receive(:log_fields).and_raise(StandardError, "boom")
+
+        expect { call("event=boot") }.not_to raise_error
+        result = call("event=boot")
+        expect(result["event"]).to eq("boot")
+      end
+
+      it "no falla si Current configurado no implementa log_fields (backwards compat)" do
+        legacy_current = Class.new do
+          class << self
+            attr_accessor :user_id, :isp_id, :correlation_id
+          end
+        end
+        allow(ExisRay).to receive(:current_class).and_return(legacy_current)
+
+        expect { call("event=boot") }.not_to raise_error
+      end
+    end
   end
 
   describe "#kv_string? (privado)" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: exis_ray
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Gabriel Edera
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-07 00:00:00.000000000 Z
+date: 2026-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -87,8 +87,8 @@ licenses:
 metadata:
   homepage_uri: https://github.com/gedera/exis_ray
   source_code_uri: https://github.com/gedera/exis_ray
-  changelog_uri: https://github.com/gedera/exis_ray/blob/v0.7.1/CHANGELOG.md
-  documentation_uri: https://github.com/gedera/exis_ray/blob/v0.7.1/skill
+  changelog_uri: https://github.com/gedera/exis_ray/blob/v0.8.0/CHANGELOG.md
+  documentation_uri: https://github.com/gedera/exis_ray/blob/v0.8.0/skill
 post_install_message:
 rdoc_options: []
 require_paths: