closeyourit-ruby 0.9.3 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7fb813ea37f0fb206ed31a5a960f795e364c6b23902d59b9b5d6e56ff4fb295
-  data.tar.gz: 926f4e714781796b43ad8c9eaf0e6bf52d7976599a188d3e3720637df623d2bb
+  metadata.gz: 0bc659e436ad9b08b9861d4898e6876a3b753ec88ebb7f8e81075729d958fcb4
+  data.tar.gz: 2bb509651ce4aa880a40f2d49f29c9584bb1bfde984b6fba3065c1a954800f82
 SHA512:
-  metadata.gz: d8d590e358c098c3061383a85f9e1593b0b574a0ee52fcb67bbdd76e215cf44076703d9a1917d52acc99e43dee0ba58113afd9516c44b1adaa807341c22cf3ee
-  data.tar.gz: e492934a7b0329fe0ba887dc45b05fa8c148ac3fb9665d866f95bdfe25b1cd114aa66bf95bca76cb83f3f16a96a34b4b24165152a247971e43888358e69291f9
+  metadata.gz: d3cfd52ac4b7ddda5a5a92485ebe1fb4be25b808e706b11af7c5e0c6767fff19af3aa3958a8a3d9e6d94ec6ec36162a942fa439700bd16d07d52987d34a4328e
+  data.tar.gz: fe22c4cae5a0e94f4eeaf8284d00c0a42d51a0d8c3830dcd703abcf9774eaf31c4e5e81c0c4b8ba6331a1e3d331078136b2cf05e09316325c5f545acaa8b9c17

data/README.md

@@ -79,6 +79,7 @@ end
 | `before_send` | `nil` | `->(payload) { ... }` — scrub finale; ritorna payload o `nil` per scartare |
 | `sample_rate` | `1.0` | Frazione di errori/messaggi inviata (`1.0` tutto, `0.0` niente) |
 | `async_threads` | `cpu/2` | Thread di invio; `0` = sincrono (test) |
+| `shutdown_timeout` | `15` | Secondi di attesa, alla chiusura, perché gli invii in volo completino; scaduto il tempo gli eventi residui sono contati come `dropped` (vedi [Flush di fine-vita](#flush-di-fine-vita)) |
 | `trap_signals` | `false` | Intercetta `SIGTERM` per garantire il flush di fine-vita (deploy/Kamal); opt-in perché sovrascrive un eventuale handler `TERM` dell'app ospite (vedi [Flush di fine-vita](#flush-di-fine-vita)) |
 | `slow_query_threshold_ms` | `100` | Soglia query lente |
 | `excluded_query_patterns` | `solid_queue_`, `solid_cache_`, `solid_cable_` | Query da NON misurare come rallentamento — **Regexp** (pattern) o **String** (testo letterale). Vale solo per la misura: breadcrumb e profiling N+1 vedono tutto |
@@ -92,7 +93,7 @@ end
 | `send_pii` | `false` | Master switch PII |
 | `obfuscate_sql` | `true` | Maschera i literal nello SQL |
 | `filter_parameters` | `[]` | Chiavi extra da redarre (mergiate con quelle di Rails) |
-| `scrub_message_patterns` | `[]` | Regexp da redarre da messaggi d'eccezione **e da `message` dei log** |
+| `scrub_message_patterns` | `[]` | Regexp **aggiuntive** da redarre da messaggi d'eccezione **e da `message` dei log**; le credenziali `Bearer`/`Basic`/`Token` sono già redatte di serie |
 | `logs_enabled` | `true` | Master switch dello stream di log strutturato |
 | `logs_min_level` | `:info` | Soglia minima: i log sotto (es. `debug`) non vengono inviati |
 | `logs_sample_rate` | `1.0` | Frazione di log inviata (`1.0` tutto, `0.0` niente) |
@@ -227,6 +228,11 @@ buffer), così i log sotto-batch di rake/CLI non vanno persi all'uscita. `SIGTER
 termina il processo **senza** eseguire gli `at_exit`: imposta `trap_signals = true` per intercettarlo e
 convertirlo in un exit pulito, oppure chiama `CloseYourIt.shutdown` esplicitamente prima di terminare.
 
+Il drain attende fino a `shutdown_timeout` secondi (default `15`, il tetto di durata di una singola
+POST verso l'ingest). Gli eventi ancora in coda quando il tempo scade sono contati come `dropped`
+nello snapshot diagnostico di fine-vita: nessuna perdita silenziosa. Abbassa il valore se l'uscita
+del processo deve essere più rapida della consegna.
+
 #### Server che forkano (Puma cluster, Sidekiq, Unicorn)
 
 I server che precaricano l'app (`preload_app!`) inizializzano la gemma nel processo **master**, poi
@@ -381,8 +387,10 @@ Privacy-by-default (`send_pii = false`). In sintesi:
 - **SQL**: inviato il template, **mai** i bind values; `obfuscate_sql` maschera anche i literal inline.
 - **Chiavi sensibili** (`password`, `token`, `authorization`, `cookie`, `secret`, `api_key`, `csrf`,
   `credit_card`, `cvv`, `ssn`, `iban`, …) → `[FILTERED]`; estendibili con `filter_parameters`.
-- **Messaggi d'eccezione**: inviati per il debug, ma redigibili con `scrub_message_patterns` /
-  `before_send`.
+- **Messaggi d'eccezione**: inviati per il debug. Le credenziali di autenticazione finite nel testo
+  (`Authorization: Bearer …`, `Basic …`, `Token …`) sono redatte **di serie**, senza configurazione:
+  chiave e schema restano leggibili, sparisce il valore → `Authorization: Bearer [FILTERED]`. Il resto
+  è redigibile con `scrub_message_patterns` / `before_send`.
 - **Mai inviati**: variabili locali dei frame, argomenti dei metodi, IP/cookie/Authorization, token (che
   viaggia solo nell'header su HTTPS).
 

data/lib/closeyourit/background_worker.rb

@@ -32,15 +32,34 @@ module CloseYourIt
       accepted
     end
 
-    def shutdown(timeout = 1)
+    # Drena la coda attendendo fino a `timeout` secondi. Il default è il tetto di durata di UNA POST
+    # (Transport::MAX_REQUEST_SECONDS): aspettare meno abbandona invii ancora sani, ed è quello che
+    # succedeva con il vecchio secondo fisso (CYRB-24). Se il drain scade, i task rimasti in coda sono
+    # persi: contali come `dropped`, altrimenti lo snapshot di fine vita dichiara zero perdite.
+    def shutdown(timeout = Transport::MAX_REQUEST_SECONDS)
       return unless @executor.respond_to?(:shutdown)
 
       @executor.shutdown
-      @executor.wait_for_termination(timeout)
+      terminated = @executor.wait_for_termination(timeout)
+      report_abandoned(timeout) unless terminated
+      terminated
     end
 
     private
 
+    # Task accodati e mai eseguiti al momento della scadenza del drain. `queue_length` non esiste
+    # sull'ImmediateExecutor (sincrono, niente coda) → zero residui.
+    def report_abandoned(timeout)
+      abandoned = @executor.respond_to?(:queue_length) ? @executor.queue_length.to_i : 0
+      CloseYourIt.internal_logger.warn(
+        "CloseYourIt background worker: drain scaduto dopo #{timeout}s, #{abandoned} eventi abbandonati"
+      )
+      abandoned.times do
+        CloseYourIt.stats.increment(:dropped)
+        CloseYourIt.notify_diagnostic(:drop, reason: :shutdown_timeout)
+      end
+    end
+
     def build_executor(threads, max_queue)
       return Concurrent::ImmediateExecutor.new if threads <= 0
 

data/lib/closeyourit/client.rb

@@ -54,17 +54,7 @@ module CloseYourIt
     def flush_logs(events)
       return nil if events.nil? || events.empty?
 
-      payloads = events.map(&:to_h)
-      if @configuration.before_send
-        kept = payloads.filter_map { |payload| @configuration.before_send.call(payload) }
-        # I log che before_send porta a nil sono scarti voluti: contabilizzali come gli errori/metriche
-        # (parità con #capture_event), altrimenti sparirebbero silenziosamente dai contatori (CYRB-12).
-        (payloads.size - kept.size).times do
-          CloseYourIt.stats.increment(:dropped)
-          CloseYourIt.notify_diagnostic(:drop, reason: :before_send)
-        end
-        payloads = kept
-      end
+      payloads = events.filter_map { |event| build_log_payload(event) }
       return nil if payloads.empty?
 
       path = events.first.ingest_path(@configuration.project_id)
@@ -95,7 +85,30 @@ module CloseYourIt
     end
 
     def shutdown
-      @worker.shutdown
+      @worker.shutdown(@configuration.shutdown_timeout)
+    end
+
+    private
+
+    # Costruisce il payload di UNA voce di log. `to_h` (scrubber su un byte non UTF-8) e `before_send`
+    # possono sollevare: qui il buffer è già stato drenato, quindi una sola voce rotta valutata
+    # insieme alle altre porterebbe via l'intero batch di voci sane. Ogni voce è isolata e scartata
+    # da sola, come fa il client JS (CYRB-24). `nil` = voce da non spedire, già contabilizzata.
+    def build_log_payload(event)
+      payload = event.to_h
+      payload = @configuration.before_send.call(payload) if @configuration.before_send
+      return payload unless payload.nil?
+
+      # Scarto voluto di before_send: contabilizzato come in #capture_event, altrimenti sparirebbe
+      # silenziosamente dai contatori (CYRB-12).
+      CloseYourIt.stats.increment(:dropped)
+      CloseYourIt.notify_diagnostic(:drop, reason: :before_send)
+      nil
+    rescue StandardError => e
+      CloseYourIt.internal_logger.error("CloseYourIt client: log scartato — #{e.class}: #{e.message}")
+      CloseYourIt.stats.increment(:dropped)
+      CloseYourIt.notify_diagnostic(:drop, reason: :error, error: e.class.name)
+      nil
     end
   end
 end

data/lib/closeyourit/configuration.rb

@@ -27,7 +27,7 @@ module CloseYourIt
     ].freeze
 
     attr_accessor :endpoint_url, :token, :project_id, :environment, :before_send, :on_diagnostic,
-                  :async_threads, :background_worker_max_queue,
+                  :async_threads, :background_worker_max_queue, :shutdown_timeout,
                   :slow_query_threshold_ms, :slow_method_threshold_ms,
                   :send_pii, :obfuscate_sql, :send_server_name,
                   :capture_query_bindings, :capture_method_arguments,
@@ -65,6 +65,10 @@ module CloseYourIt
 
       @async_threads               = default_threads
       @background_worker_max_queue  = 30
+      # Quanto attendere, alla chiusura del processo, che gli invii in volo completino. Default: il
+      # tetto di durata di UNA POST, così l'ultimo batch non viene abbandonato a metà (CYRB-24).
+      # Abbassalo se l'uscita del processo deve essere più rapida della consegna.
+      @shutdown_timeout = Transport::MAX_REQUEST_SECONDS
 
       # Intercetta SIGTERM per garantire il flush di fine-vita (deploy/Kamal): SIGTERM di default
       # termina il processo SENZA eseguire gli at_exit. OPT-IN perché sovrascrive un eventuale handler

data/lib/closeyourit/instrumenter.rb

@@ -13,8 +13,16 @@ module CloseYourIt
       start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       yield
     ensure
-      duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000.0
-      report(label, duration_ms, location, args: args, kwargs: kwargs)
+      # `measure` gira DENTRO il metodo dell'app (Monitor fa prepend): un guasto qui — soglia non
+      # configurata, ingest irraggiungibile — solleverebbe in un chiamante che aveva già il suo
+      # risultato. È l'unico ingresso della gemma che era scoperto: ora è come tutti gli altri
+      # (CYRB-24). Un'eccezione del blocco misurato continua invece a propagare intatta.
+      begin
+        duration_ms = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000.0
+        report(label, duration_ms, location, args: args, kwargs: kwargs)
+      rescue StandardError => e
+        CloseYourIt.internal_logger.error("CloseYourIt instrumenter: #{e.class}: #{e.message}")
+      end
     end
 
     def report(label, duration_ms, location = nil, args: nil, kwargs: nil)

data/lib/closeyourit/scrubber.rb

@@ -23,6 +23,53 @@ module CloseYourIt
       email phone telephone mobile dob birth passport bearer session pin pan
     ].freeze
 
+    # CYRB-23 — redazione INTEGRATA delle credenziali di autenticazione nel testo libero.
+    # `filter_params`/`filter_value` coprono gli header STRUTTURATI (la chiave `authorization` è in
+    # DENYLIST); un `Authorization: Bearer <token>` incollato dentro `exception.message` o dentro la
+    # riga di un log è testo, non una chiave, e prima di questo ticket partiva in chiaro perché
+    # `scrub_message` applicava solo i pattern configurati dall'utente (default `[]`).
+    #
+    # Forma del testo redatto (decisa qui una volta per tutti gli SDK — gemelli CYDA-26/CYJS-38/
+    # CYPY-15): chiave e schema restano leggibili, sparisce SOLO la credenziale →
+    # `Authorization: Bearer [FILTERED]`. Il messaggio resta diagnosticamente utile (si vede CHE
+    # c'era un header e con quale schema) senza trasportare il segreto.
+    AUTH_SCHEME = /(?i:Bearer|Basic|Token)/
+
+    # `token68` (RFC 7235) con padding `=` finale: la forma di una credenziale reale. Minimo 4
+    # caratteri — un `Basic` di credenziali brevi è corto (`dTpw` = `u:p`); a filtrare la prosa
+    # pensa NOT_PROSE, non la lunghezza.
+    CREDENTIAL_TOKEN = %r{[A-Za-z0-9\-._~+/]{4,}={0,2}}
+
+    # Guardia anti-falso-positivo per lo schema NUDO: quello che segue NON è una credenziale se ha
+    # la forma di una parola scritta da un umano, cioè sole lettere in UNA di tre forme —
+    # `minuscole`, `Capitalizzata`, `MAIUSCOLE` — e più corta di 20 caratteri. Salva "the bearer of
+    # bad news", "invalid bearer credentials", "Basic HTTP authentication", "Bearer Token expired".
+    # Tutto il resto è credenziale: entropia (cifre, `_`, `-`, `.`), maiuscole interne miste
+    # (`dTpw`, base64) o lunghezza ≥ 20 (nessuna parola è così lunga, mentre un token opaco di sole
+    # minuscole sì).
+    # Trade-off accettato: un CamelCase subito dopo lo schema (`Token MyAppName`) viene redatto.
+    PROSE_WORD = /(?:[a-z]{1,19}|[A-Z][a-z]{0,18}|[A-Z]{1,19})/
+    NOT_PROSE = %r{(?!\[FILTERED\])(?!#{PROSE_WORD}(?![A-Za-z0-9\-._~+/=]))}
+
+    # Valore di un header incollato nel testo: sequenza di pezzi non delimitatori, dove una stringa
+    # fra virgolette conta come UN pezzo. NON `\S+`, che si mangerebbe la `)` di
+    # "(Authorization: Bearer <token>)"; ma nemmeno una classe secca, che si fermerebbe alla prima
+    # virgoletta lasciando in chiaro il segreto di `Token token="<token>"` (sintassi RFC 7235 e
+    # `authenticate_with_http_token` di Rails) e di un frammento JSON incollato nel messaggio.
+    QUOTED = /"[^"\n]*"|'[^'\n]*'/
+    HEADER_VALUE = /(?:#{QUOTED}|[^\s,;)\]}"'<>])+/
+
+    # `Authorization:`/`authorization=` (anche `Proxy-Authorization`, anche `authorization_header`)
+    # seguito dal valore: qui la chiave è esplicita, quindi si redige senza euristica di prosa —
+    # over-redaction voluta, coerente con la DENYLIST. `[ \t]` e non `\s`: mai oltre il newline.
+    # Il lookahead copre lo schema OPZIONALE: senza, su un testo già redatto il motore farebbe
+    # backtracking sul ramo "senza schema" e redigerebbe la parola `Bearer` stessa (non idempotente).
+    AUTH_HEADER = /((?i:(?:proxy[_-]?)?authorization)[\w-]*["']?[ \t]*[:=][ \t]*)(?!(?:#{AUTH_SCHEME}[ \t]+)?\[FILTERED\])(#{AUTH_SCHEME}[ \t]+)?#{HEADER_VALUE}/
+
+    # Schema nudo (`Bearer <token>` senza il nome dell'header) seguito da qualcosa che ha la forma
+    # di una credenziale: qui la guardia di prosa serve, la parola "bearer" ricorre nei messaggi.
+    AUTH_CREDENTIAL = /(\b#{AUTH_SCHEME}[ \t]+)#{NOT_PROSE}#{CREDENTIAL_TOKEN}/
+
     STRING_LITERAL = /'(?:[^']|'')*'/
     NUMERIC_LITERAL = /\b\d+(?:\.\d+)?\b/
 
@@ -51,10 +98,16 @@ module CloseYourIt
       sql.to_s.gsub(STRING_LITERAL, "?").gsub(NUMERIC_LITERAL, "?")
     end
 
+    # Regola integrata (schemi di autenticazione) PRIMA dei pattern utente: le due protezioni si
+    # sommano, la prima non è disattivabile — privacy-by-default (CYRB-23).
     def scrub_message(message)
       return message if message.nil?
 
-      @configuration.scrub_message_patterns.reduce(message.to_s) do |acc, pattern|
+      redacted = message.to_s
+                        .gsub(AUTH_HEADER, "\\1\\2#{FILTERED}")
+                        .gsub(AUTH_CREDENTIAL, "\\1#{FILTERED}")
+
+      @configuration.scrub_message_patterns.reduce(redacted) do |acc, pattern|
         acc.gsub(pattern, FILTERED)
       end
     end

data/lib/closeyourit/transport.rb

@@ -15,6 +15,11 @@ module CloseYourIt
     # Ri-POSTiamo a Location preservando metodo + body, così l'evento non si perde in silenzio.
     MAX_REDIRECTS = 2
 
+    # Durata massima di UNA send_event: apertura + lettura, ripetute a ogni redirect seguito. È il
+    # tetto che il drain di fine vita deve poter aspettare, altrimenti abbandona un invio ancora sano
+    # (CYRB-24).
+    MAX_REQUEST_SECONDS = (OPEN_TIMEOUT + READ_TIMEOUT) * (MAX_REDIRECTS + 1)
+
     # Un timeout di rete (apertura o lettura) è un fallimento d'invio speciale: lo isoliamo dai non-2xx
     # e dagli altri errori di rete perché segnala tipicamente problemi di connettività (CYRB-12).
     TIMEOUT_ERRORS = [ Net::OpenTimeout, Net::ReadTimeout, Timeout::Error ].freeze
@@ -91,12 +96,28 @@ module CloseYourIt
       target.relative? ? current + target : target
     end
 
-    # Il Bearer va ri-inviato solo se il redirect resta sullo stesso host (o la sua variante www) e
-    # senza downgrade https→http: evita di consegnare il segreto d'ingest a un host non fidato.
+    # Il Bearer va ri-inviato solo se il redirect resta sull'autorità dell'endpoint configurato:
+    # stesso host (o la sua variante www), stessa porta effettiva e senza downgrade https→http.
+    # La porta fa parte del confine di fiducia (CYRB-22): sullo stesso server una porta diversa è
+    # un servizio distinto, che non deve ricevere il segreto d'ingest.
     def same_authority?(origin, target)
       return false if origin.scheme == "https" && target.scheme != "https"
+      return false unless canonical_host(origin) == canonical_host(target)
+
+      origin.port == target.port || canonical_upgrade?(origin, target)
+    end
+
+    # Un endpoint configurato in `http` che redirige a `https` resta fidato: la porta cambia solo
+    # perché cambia lo schema (80 → 443), non perché punti a un servizio su porta non standard.
+    def canonical_upgrade?(origin, target)
+      origin.scheme == "http" && target.scheme == "https" &&
+        origin.port == origin.default_port && target.port == target.default_port
+    end
 
-      origin.host.to_s.sub(/\Awww\./, "") == target.host.to_s.sub(/\Awww\./, "")
+    # Una porta esplicita pari alla default (`:443` su https) equivale a ometterla: `URI#port` la
+    # normalizza già, qui resta solo da neutralizzare la variante www dell'host canonico.
+    def canonical_host(uri)
+      uri.host.to_s.sub(/\Awww\./, "")
     end
 
     # Estrae " R…: messaggio" dall'envelope d'errore del backend, così il dev vede il codice d'errore

data/lib/closeyourit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CloseYourIt
-  VERSION = "0.9.3"
+  VERSION = "0.10.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: closeyourit-ruby
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.10.0
 platform: ruby
 authors:
 - Alessio Bussolari