chronos-ruby 0.9.0.pre.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84266b3c93fc92c15268d44e3625762f471c9cf99fa0523b6f5d883f846906e4
-  data.tar.gz: bf3d2c641bbb7f117a1c9c76519fa756057f72108d899cb64d86e2eeff305423
+  metadata.gz: 3fc9daff111666fdf7309797c5f8aa81a639c8f59ea1733be48740b9aea6b247
+  data.tar.gz: a8d7cd786b233078e5516e3d1ce0c92b986d045ebd4d8c29a7d9cd80ae75fb93
 SHA512:
-  metadata.gz: 9b54a3aef38f706677794b39740558586d9c69f083a3c2b3f2dc6ea20e3b60f2fe84765eb61a44fe2f230a03c03dcb27047cdd7a1853b14fc805fcb914d7cfb8
-  data.tar.gz: 2f915f461e658f93269d35e52f6d728ff32ef90a4a6ac765a6b92194a1fc53b06ca5350b2bc34c8d84197bf2263d523ead9a62ada46edbd9ae46363d3de27e05
+  metadata.gz: 1f60a09480aa5766676d673579ffe1b5b007d044881fc9b1f70f672c414ddf7e1a014cc63eaeee8ee6f63fa7261aa5dc92f8f9b1cc6089898ecf015d1940a83c
+  data.tar.gz: '08342c5a665004cbfa9fec52164f86e82d003b3d587bf931ae220c44ec4188c91141852e424f726f55a7b7d5dec4592190dc7cef9dc6c4e05f0eec8255bd32b4'

data/CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes are documented here. The project follows Semantic Versioning
 
 ## [Unreleased]
 
+## [1.0.0] - 2026-07-29
+
+### Added
+
+- stable legacy release gates for Ruby 2.2.10 through 2.6.10, Rails 4.2/5.2, Sidekiq 4/5, documentation, repeatable comparison, and fake-endpoint load validation;
+- the remaining mandatory module documents and ADRs for feature detection, context storage, sampling, and future OpenTelemetry interoperability.
+
+### Changed
+
+- promoted the reviewed public API and protocol v1 implementation from `0.9.0.pre.4` to `1.0.0`;
+- release publishing now accepts `v1.*` tags and cannot publish until every legacy compatibility and release-readiness job succeeds;
+- compatibility status is now `Supported` only for the exact runtime/framework combinations covered by green release gates.
+
+### Security
+
+- stable artifacts continue to use RubyGems Trusted Publishing, SHA-256 checksums, SPDX SBOMs, strict payload privacy contracts, and dependency auditing;
+- package signing remains deferred until a trusted signing-key lifecycle is available.
+
 ## [0.9.0.pre.4] - 2026-07-22
 
 ### Added

data/README.md

@@ -1,73 +1,73 @@
 # Chronos Ruby
 
-Chronos Ruby is the framework-independent client for sending Ruby application errors and bounded telemetry to Chronos. Version 0.9 adds synchronous deploy tracking and bounded release correlation across every event.
+Chronos Ruby 1.0.0 é o agente independente de framework para enviar exceções e telemetria limitada de aplicações Ruby ao Chronos. Esta é a linha estável legado, compatível com o protocolo v1 e voltada a Ruby 2.2.10–2.6.
 
-## What the gem collects
+## O que a gem coleta
 
-Version 0.9 can collect:
+A versão 1.0 pode coletar:
 
-- exception class, message, structured backtrace, and chained causes;
-- timestamp, severity, tags, and an optional fingerprint;
-- application-supplied context, parameters, session, and user fields;
-- Ruby version, engine, platform, process ID, opaque thread ID, and hostname;
-- application version, environment, and service name.
-- Rack method, normalized route, status, duration, request ID, host, query-free path, optional user agent, controller/action, response size, trace ID, and already-parsed parameters when the middleware is used;
-- bounded breadcrumbs explicitly supplied by the application or integration.
-- release, revision, deploy ID, environment, service, region, and instance correlation;
-- explicit bounded deployment metadata supplied through the public API or integration.
+- classe, mensagem, backtrace estruturado e causas encadeadas da exceção;
+- timestamp, severidade, tags e fingerprint opcional;
+- contexto, parâmetros, sessão e usuário fornecidos pela aplicação;
+- versão, engine e plataforma Ruby, PID, thread opaca e hostname;
+- ambiente, serviço, versão da aplicação, release, revision, deploy ID, região e instância;
+- método, rota normalizada, status, duração e breakdown de requests Rack/Rails;
+- SQL normalizado sem literais/binds e sinais heurísticos de desempenho;
+- jobs Sidekiq/Active Job, cache, HTTP externo explicitamente instrumentado e dependências carregadas;
+- breadcrumbs limitados fornecidos pela aplicação ou por integrações.
 
-See [Data collected](docs/data-collected.md) for the complete field table.
+Veja a tabela completa em [Dados coletados](docs/data-collected.md).
 
-## What is not collected by default
+## O que não é coletado por padrão
 
-Chronos Ruby does not inspect environment variables, request/response bodies, cookies, Authorization headers, source code, database contents, lockfiles, or gem paths. Dependency reporting reads only already loaded gem names and versions once per agent. Application-supplied fields are recursively sanitized, but applications should still avoid sending unnecessary personal, health, financial, or authentication data.
+A gem não varre variáveis de ambiente, sistema de arquivos ou lockfiles e não lê bodies HTTP, cookies, headers de autorização, conteúdo de e-mail, SQL bruto, binds, valores de cache ou código-fonte. O inventário de dependências contém somente nomes e versões já carregados, uma vez por agente. A aplicação continua responsável por minimização e base legal dos dados enviados.
 
-## Supported Ruby and Rails versions
+## Versões Ruby e Rails suportadas
 
-Version 0.x targets Ruby 2.2.10 through Ruby 2.6. Version 0.5 provides best-effort Rails 4.2 through 5.2 integration through public framework APIs and feature detection. All supported combinations must pass dedicated CI before being listed as supported.
+A versão 1.0.0 suporta Ruby puro e Rack em Ruby 2.2.10, 2.3.8, 2.4.10, 2.5.9 e 2.6.10. As combinações Rails validadas são Rails 4.2 com Ruby 2.2.10/2.3.8 e Rails 5.2 com Ruby 2.5.9/2.6.10. Sidekiq 4.2.10 com Ruby 2.2.10 e Sidekiq 5.2.10 com Ruby 2.5.9 também possuem gates dedicados.
 
-See [Compatibility](docs/compatibility.md).
+Rubies e frameworks antigos estão fora do suporte de segurança de seus mantenedores. A Chronos oferece compatibilidade técnica, não manutenção de segurança do runtime. Veja [Compatibilidade](docs/compatibility.md).
 
-## Plain Ruby installation
+## Instalação em Ruby puro
 
-The current public build is a pre-release. Add its exact version to the application's `Gemfile`:
+Obrigatório: adicione a versão estável ao `Gemfile`.
 
 ```ruby
-gem "chronos-ruby", "0.9.0.pre.4"
+gem "chronos-ruby", "~> 1.0.0"
 ```
 
-Install with a Bundler version compatible with the application. For the oldest supported runtime:
+Em runtimes antigos, use Bundler compatível:
 
 ```bash
 gem install bundler -v 1.17.3
 bundle _1.17.3_ install
 ```
 
-Without Bundler:
+Sem Bundler:
 
 ```bash
-gem install chronos-ruby --pre
+gem install chronos-ruby -v 1.0.0
 ```
 
-## Rails installation
+## Instalação em Rails
 
-Version 0.5 exposes Rails support explicitly, keeping Rails and ActiveSupport out of plain Ruby applications:
+Obrigatório: carregue a integração Rails explicitamente para manter Rails/ActiveSupport fora de aplicações Ruby puras.
 
 ```ruby
-gem "chronos-ruby", "0.9.0.pre.4", :require => "chronos/rails"
+gem "chronos-ruby", "~> 1.0.0", :require => "chronos/rails"
 ```
 
-Generate the initializer with:
+Gere o initializer:
 
 ```bash
 rails generate chronos:install
 ```
 
-The Railtie installs the Rack middleware and notification subscribers idempotently. Automatic integration is disabled in test and console by default and can be controlled with `rails_enabled`, `rails_capture_in_test`, `rails_capture_in_console`, and `rails_capture_user_agent`. See [Rails 4.2 and 5.2 integration](docs/modules/rails-legacy.md).
+A Versão 0.5 introduziu Railtie, middleware e subscribers idempotentes por APIs públicas e feature detection. A coleta automática fica desativada em test e console por padrão. Veja [Rails legado](docs/modules/rails-legacy.md).
 
-## Minimum configuration
+## Configuração mínima
 
-`project_id`, `project_key`, and an HTTPS `host` are required while the agent is enabled:
+Obrigatório quando o agente está habilitado: `project_id`, `project_key` e `host` HTTPS. Recomendado: definir ambiente e serviço explicitamente.
 
 ```ruby
 require "chronos"
@@ -82,43 +82,28 @@ Chronos.configure do |config|
 end
 ```
 
-HTTPS verification is enabled by default. HTTP requires explicitly setting `ssl_verify = false` and should only be used with a local test server.
-
-## Verify the Chronos integration
-
-After configuring the application, Rails projects can verify credentials and end-to-end ingestion with:
+TLS é verificado por padrão. HTTP exige `ssl_verify = false` explicitamente e deve ser limitado a endpoints locais de teste. Depois de configurar, valide credenciais e ingestão:
 
 ```bash
 bundle exec rake chronos:verify_integration
 ```
 
-The task sends one synthetic exception identified as an integration verification and prints one JSON object. It exits with status `0` only when Chronos confirms valid credentials and receipt of the correlated event; configuration, authentication, inactive-project, network, protocol, rate-limit, and receiver failures exit nonzero with safe guidance.
-
-Plain Ruby Rakefiles can install the same task explicitly after loading their configuration:
+O task envia uma exceção sintética identificada e só retorna código `0` após uma resposta v1 correlacionada. Em Ruby puro, instale o task com `require "chronos/rake_tasks"` e `Chronos::RakeTasks.install`; por código, use `Chronos.verify_integration`. Veja [Verificação da integração](docs/modules/integration-verification.md).
 
-```ruby
-require "chronos"
-# Chronos.configure { |config| ... }
-require "chronos/rake_tasks"
-Chronos::RakeTasks.install
-```
+## Captura automática
 
-Ruby code may call `result = Chronos.verify_integration`, inspect `result.success?`, and serialize `result.to_h` or `result.to_json`. The result contains only bounded contract fields; it never exposes `project_key`, raw server responses, stack traces, source paths, or receiver internals. See [Integration verification](docs/modules/integration-verification.md).
-
-## Automatic capture
-
-Rack applications can capture unhandled exceptions automatically and preserve the application error semantics:
+Opcional em Rack: instale o middleware. Ele notifica exceções não tratadas, preserva a mesma exceção para a aplicação e não consome bodies.
 
 ```ruby
 use Chronos::Integrations::Rack::Middleware,
     :include_user_agent => false
 ```
 
-The middleware notifies asynchronously and re-raises the same exception. It never reads the request body, raw query string, cookies, authorization headers, or response body. See [Rack integration and context](docs/modules/rack-context.md).
+Em Rails, o Railtie instala middleware e subscribers uma única vez. Veja [Monitoramento de requests](docs/modules/request-monitoring.md).
 
-## Manual capture
+## Captura manual
 
-Asynchronous capture is recommended for application code:
+Recomendado no fluxo da aplicação: captura assíncrona.
 
 ```ruby
 begin
@@ -129,27 +114,27 @@ rescue StandardError => error
 end
 ```
 
-Synchronous capture waits for the HTTP result and is useful in scripts or controlled shutdown paths:
+Opcional para scripts e shutdown controlado: captura síncrona.
 
 ```ruby
 delivered = Chronos.notify_sync(RuntimeError.new("import failed"))
 ```
 
-Both methods return `false` instead of allowing an internal agent error to escape.
+Falhas internas retornam `false` e não escapam para o fluxo principal.
 
-## User context
+## Contexto de usuário
 
-User data is opt-in and must contain only values your application is allowed to send:
+Contexto de usuário é opt-in. Envie somente campos necessários e autorizados:
 
 ```ruby
 Chronos.notify(error, :user => {"id" => "customer-42", "role" => "operator"})
 ```
 
-Version 0.4 sanitizes this context before delivery and before it can enter retry storage. Data minimization remains the application's responsibility.
+O valor é limitado e sanitizado, mas a minimização continua sendo responsabilidade da aplicação. Veja [Contexto de execução](docs/modules/context.md).
 
 ## Breadcrumbs
 
-Breadcrumbs use a fixed circular buffer scoped to the current execution:
+Breadcrumbs formam um buffer circular delimitado no escopo atual:
 
 ```ruby
 Chronos.add_breadcrumb(
@@ -159,35 +144,25 @@ Chronos.add_breadcrumb(
 )
 ```
 
-No log, SQL, HTTP, cache, job, request body, or response body payload is collected automatically. Unknown categories become `custom`, and metadata is bounded and sanitized before queueing.
+A gem não transforma logs, SQL ou bodies em breadcrumbs brutos. Veja [Breadcrumbs](docs/modules/breadcrumbs.md).
 
-## Filters and LGPD
+## Filtros e LGPD
 
-Version 0.4 recursively redacts sensitive keys and detects Bearer tokens, JWTs, e-mail addresses, CPF, CNPJ, and valid payment-card candidates in free text. IPv4 addresses are anonymized by default. Applications can add blocklist matchers, hash selected identifiers, or install custom filters:
+A gem bloqueia chaves sensíveis e detecta Bearer tokens, JWTs, e-mails, CPF, CNPJ e candidatos válidos a cartão. IPv4 é anonimizado por padrão. Opcionalmente, amplie a blocklist, aplique hash irreversível ou filtros próprios:
 
 ```ruby
 Chronos.configure do |config|
-  # required options omitted
   config.blocklist_keys += [:medical_record, /bank_account/i]
   config.hash_keys += [:customer_id]
   config.filters << proc { |key, value| key.to_s == "internal_reference" ? "[REMOVED]" : value }
 end
 ```
 
-Sanitization runs before queueing and transport. See [Privacy and LGPD](docs/privacy-lgpd.md) for behavior, limitations, health and financial examples, and a payload audit procedure.
+Sanitização ocorre antes de fila, retry e backlog. Veja [Privacidade e LGPD](docs/privacy-lgpd.md).
 
 ## Ignore rules
 
-Entire environments can be ignored:
-
-```ruby
-Chronos.configure do |config|
-  # required options omitted
-  config.ignored_environments = ["development", "test"]
-end
-```
-
-Version `0.9.0.pre.2` adds bounded local rules after configuration:
+Ambientes inteiros podem ser ignorados na configuração. A versão `0.9.0.pre.2` introduziu regras locais limitadas, preservadas na API estável:
 
 ```ruby
 Chronos.ignore_if do |notice|
@@ -195,17 +170,14 @@ Chronos.ignore_if do |notice|
 end
 ```
 
-Rules receive an immutable normalized notice, run before serialization/queueing, and must return exactly `true` to discard. The default limit is 20 and the hard configurable maximum is 100. A failing rule is contained. See [Bounded local ignore rules](docs/modules/ignore-rules.md).
+A regra recebe um notice normalizado e imutável, e somente `true` descarta. Falhas do callback são contidas. Veja [Ignore rules](docs/modules/ignore-rules.md).
 
-## Performance monitoring
+## Monitoramento de performance
 
-Version 0.7 aggregates request, query, and job observations into bounded `metric_batch` events. Groups include count, error count/rate, total/min/max/average duration, fixed histogram buckets, status counts, and component breakdown. Percentiles are calculated in the SaaS without retaining every local duration.
-
-SQL comments and literal values are removed before a bounded normalized query and SHA-256 fingerprint are produced. Binds are never read. Slow, repeated, possible N+1, long-transaction, connection-error, and deadlock signals are heuristic and require server-side confirmation. Group count, active trace count, fingerprints per trace, histogram buckets, and batch size all have fixed limits. See [Essential APM aggregation](docs/modules/apm-aggregation.md).
+A Versão 0.7 introduziu agregação local de requests, queries e jobs em `metric_batch`; a Versão 0.8 adicionou HTTP externo. Grupos possuem contagem, erro, duração, histograma, status e breakdown limitados. Percentis são calculados no SaaS.
 
 ```ruby
 Chronos.configure do |config|
-  # required connection settings omitted
   config.apm_enabled = true
   config.apm_max_groups = 200
   config.apm_flush_count = 100
@@ -216,42 +188,22 @@ Chronos.configure do |config|
 end
 ```
 
-## Sidekiq and Active Job
-
-Version `0.6.0.pre.1` adds optional Sidekiq 4/5 middleware:
-
-```ruby
-gem "sidekiq", "~> 5.0"
-gem "chronos-ruby", "0.9.0.pre.4", :require => "chronos/sidekiq"
-```
-
-The client middleware propagates only trace/request identifiers in a versioned Sidekiq-envelope field and never changes worker arguments. The server records class, queue, JID, retry count, duration, calculable queue latency, bounded arguments/tags, status, and error class. Values pass through the shared sanitizer before delivery. Failed jobs are notified once and the original exception is re-raised. See [Sidekiq 4/5 legacy integration](docs/modules/sidekiq-legacy.md).
+SQL bruto e binds não são lidos. Sinais de query lenta, repetição, possível N+1, transação longa, conexão e deadlock são heurísticos. Veja [APM](docs/modules/apm-aggregation.md), [Requests](docs/modules/request-monitoring.md) e [SQL](docs/modules/sql-monitoring.md).
 
-When Active Job is available, the Rails integration propagates only bounded trace/request identifiers in a namespaced serialized field without changing job arguments. It records adapter, job/provider IDs, class, queue, attempts, duration, status, and error class, and captures a supplied failure once. See [Active Job legacy integration](docs/modules/active-job.md).
+## Sidekiq e Active Job
 
-## External HTTP, cache, and dependencies
-
-Version 0.8 instruments only explicitly selected `Net::HTTP` connection objects, avoiding a global monkey patch:
+A versão `0.6.0.pre.1` introduziu middleware Sidekiq 4/5; a API estável mantém o require explícito:
 
 ```ruby
-Chronos.configure do |config|
-  # required connection settings omitted
-  config.external_http_enabled = true
-  config.external_http_trace_headers = true
-end
-
-http = Net::HTTP.new("payments.example.com", 443)
-http.use_ssl = true
-Chronos.instrument_net_http(http)
+gem "sidekiq", "~> 5.0"
+gem "chronos-ruby", "~> 1.0.0", :require => "chronos/sidekiq"
 ```
 
-The wrapper records only sanitized host, method, status, duration, timeout, connection-error flag, and error class. It propagates `X-Chronos-Trace-ID` and `X-Chronos-Request-ID` when available and never reads URL path/query, Authorization, request body, response body, or error message.
-
-Rails cache telemetry omits raw keys by default. Set `cache_key_mode = :sha256` to emit a project-scoped hash; `:none` is the default. Dependency reporting is enabled by default, reads at most 100 already loaded gem specs, and emits one independent `dependencies` event per agent. Set `dependency_reporting = false` to disable it. See [External HTTP](docs/modules/external-http.md), [Cache observability](docs/modules/cache-observability.md), and [Dependency inventory](docs/modules/dependencies.md).
+O envelope de contexto não altera argumentos públicos e contém somente IDs limitados de trace/request. Active Job usa um campo serializado com namespace (`chronos_context`) e hooks públicos. Erros aninhados são deduplicados e reerguidos. Veja [Sidekiq legado](docs/modules/sidekiq-legacy.md), [Active Job](docs/modules/active-job.md) e [Jobs](docs/modules/job-monitoring.md).
 
 ## Deploy tracking
 
-Version 0.9 sends deployment metadata synchronously and adds a bounded correlation block to every event:
+A Versão 0.9 introduziu deploy síncrono e correlação fixa em todos os eventos:
 
 ```ruby
 Chronos.notify_deploy(
@@ -263,55 +215,35 @@ Chronos.notify_deploy(
 )
 ```
 
-Configure `app_version`, `revision`, `deploy_id`, `environment`, `service_name`, `region`, and `instance_id` in each newly deployed process so subsequent telemetry carries the same release identity. The gem never scans environment variables or Git automatically.
+Configure release/revision/deploy na inicialização de cada novo processo. A gem não lê Git ou variáveis automaticamente. Capistrano é opcional; Kamal e GitHub Actions usam exemplos em `examples/deploy/`. Veja [Deploys](docs/modules/deploys.md).
 
-Optional Capistrano support loads through `chronos/capistrano`. Manual, Kamal-command, and GitHub Actions examples share the explicit deploy command under `examples/deploy/`. See [Deploy tracking and release correlation](docs/modules/deploy-tracking.md).
+## Fila assíncrona
 
-## Asynchronous queue
-
-The queue has a fixed capacity and drops the newest event when full. Worker threads are created lazily after the first accepted event. The default capacity is 100 events with one worker.
+A fila tem capacidade fixa, descarta o evento mais novo quando cheia e cria workers somente após a primeira captura aceita.
 
 ```mermaid
 flowchart LR
-  E[Exception] --> N[Notice builder]
-  N --> P[Privacy sanitizer]
-  P --> S[Safe bounded serializer]
-  S --> D[Delivery pipeline]
-  D --> Q[Bounded queue]
-  Q --> W[Fixed worker pool]
-  W --> R[Retry and circuit breaker]
-  R --> H[Net::HTTP transport]
-  R --> B[Bounded memory backlog]
+  E[Exceção ou telemetria] --> N[Normalização]
+  N --> P[Sanitização]
+  P --> S[Serialização limitada]
+  S --> D[Pipeline de entrega]
+  D --> Q[Fila limitada]
+  Q --> W[Workers fixos]
+  W --> H[Net::HTTP]
+  W --> B[Backlog em memória]
 ```
 
-Use `Chronos.flush(timeout)` to wait for accepted events and `Chronos.close(timeout)` during shutdown. Workers are recreated after a process fork.
-
-## Retry and backlog
-
-The resilience layer introduced in version 0.3 retries network errors, HTTP `408`, `429`, and `5xx` responses with exponential backoff, bounded jitter, and a finite attempt count. Other `4xx` responses are permanent and are not retried. A circuit breaker pauses requests after repeated failures, preventing retry storms.
-
-After retries are exhausted, the already sanitized `SerializedEvent` may enter a fixed-capacity memory backlog. The backlog drops new items when full, is lost when the process exits, and never writes to disk. A later successful half-open probe drains backlog items as new events arrive.
-
-The SaaS may return a JSON policy in the bounded `X-Chronos-Remote-Configuration` response header. Only sampling rate, enabled event types, a lower payload limit, exact ignored fingerprints, send interval, and kill switch are accepted. Remote values cannot change the host, project credentials, TLS, local maximums, code, or regular expressions. See [Retry and backlog](docs/modules/retry-backlog.md) and [Remote configuration](docs/modules/remote-configuration.md).
+Use `Chronos.flush(timeout)` antes de encerrar e `Chronos.close(timeout)` no shutdown. Workers são recriados após fork. Veja [Fila assíncrona](docs/modules/async-queue.md).
 
-## How it works internally
+## Retry e backlog
 
-The code follows hexagonal boundaries:
+Retry cobre erros de rede, HTTP `408`, `429` e `5xx`, com backoff exponencial, jitter e tentativas limitadas. Outros `4xx` são permanentes. Circuit breaker reduz tempestades de retry.
 
-- `Chronos::Core` contains immutable notices, sanitization, and safe normalization;
-- `Chronos::Application` coordinates capture;
-- `Chronos::Application::DeliveryPipeline` owns bounded retry and remote policy;
-- `Chronos::Ports` defines delivery behavior;
-- `Chronos::Adapters` implements Net::HTTP delivery and thread-local context;
-- `Chronos::Integrations::Rack` implements optional automatic Rack capture;
-- `Chronos::Rails` implements the optional Railtie, installer, generator, and public-notification adapters;
-- `Chronos::Internal` owns bounded queueing, workers, and defensive logging.
+O backlog guarda somente eventos já sanitizados/serializados, possui capacidade fixa, vive em memória e é perdido no encerramento. Configuração remota aceita apenas sampling, tipos habilitados, limite menor de payload, fingerprints exatas, intervalo e kill switch; nunca altera host, credenciais, TLS ou executa código. Veja [Retry e backlog](docs/modules/retry-backlog.md), [Sampling](docs/modules/sampling.md) e [Configuração remota](docs/modules/remote-configuration.md).
 
-The core has no dependency on Rails, Rack, Sidekiq, or ActiveSupport. See [Architecture](docs/architecture.md).
+## Configuração por ambiente
 
-## Environment-specific configuration
-
-Configuration values are explicit; the gem never scans the process environment. Read only the variables your application chooses:
+A gem não varre o ambiente. Leia somente variáveis escolhidas pela aplicação:
 
 ```ruby
 Chronos.configure do |config|
@@ -322,102 +254,69 @@ Chronos.configure do |config|
   config.enabled = ENV["CHRONOS_ENABLED"] != "false"
   config.queue_size = 100
   config.workers = 1
-  config.timeout = 5.0
-  config.open_timeout = 2.0
   config.max_retries = 3
-  config.retry_base_interval = 0.5
-  config.retry_max_interval = 30.0
-  config.retry_jitter = 0.25
   config.backlog_size = 100
-  config.circuit_failure_threshold = 5
-  config.circuit_reset_timeout = 30.0
   config.remote_configuration = true
-  config.context_store = :thread_local
-  config.breadcrumb_capacity = 20
-  config.breadcrumb_max_bytes = 2048
   config.apm_enabled = true
-  config.apm_max_groups = 200
-  config.apm_flush_count = 100
   config.external_http_enabled = false
   config.cache_key_mode = :none
   config.dependency_reporting = true
   config.app_version = ENV["APP_VERSION"]
   config.revision = ENV["GIT_SHA"]
   config.deploy_id = ENV["DEPLOY_ID"]
-  config.region = ENV["REGION"]
-  config.instance_id = ENV["INSTANCE_ID"]
 end
 ```
 
-All options are documented in [Configuration](docs/configuration.md).
+Todas as opções, defaults e limites estão em [Configuração](docs/configuration.md).
 
 ## Troubleshooting
 
-Configuration errors are raised during `Chronos.configure`. Capture and delivery errors are contained and optionally reported to the configured logger. Verify credentials, HTTPS certificates, timeouts, and `Chronos.flush` results. See [Troubleshooting](docs/troubleshooting.md).
+Erros de configuração são levantados durante `Chronos.configure`; falhas de captura/entrega são contidas e podem ir ao logger seguro. Confirme TLS, credenciais, timeouts e retorno de `flush`. Consulte [Troubleshooting](docs/troubleshooting.md).
 
 ## Benchmark
 
-Run the version 0.9 benchmarks with:
+O gate estável executa comparação Rack repetível e carga contra endpoint fake:
 
 ```bash
-bundle _1.17.3_ exec ruby benchmarks/capture_exception.rb
-bundle _1.17.3_ exec ruby benchmarks/serialization.rb
-bundle _1.17.3_ exec ruby benchmarks/filtering.rb
-bundle _1.17.3_ exec ruby benchmarks/queue.rb
-bundle _1.17.3_ exec ruby benchmarks/retry_backlog.rb
-bundle _1.17.3_ exec ruby benchmarks/request_overhead.rb
-bundle _1.17.3_ exec ruby benchmarks/rails_notifications.rb
-bundle _1.17.3_ exec ruby benchmarks/sidekiq_middleware.rb
-bundle _1.17.3_ exec ruby benchmarks/apm_aggregation.rb
-bundle _1.17.3_ exec ruby benchmarks/external_http.rb
-bundle _1.17.3_ exec ruby benchmarks/correlation.rb
+ITERATIONS=50000 WARMUP=5000 SAMPLES=7 bundle _1.17.3_ exec ruby benchmarks/comparative.rb
+ITERATIONS=500 bundle _1.17.3_ exec ruby benchmarks/fake_endpoint_load.rb
 ```
 
-Results depend on runtime, hardware, and payload. No performance comparison is claimed until repeatable measurements are published.
+Resultados dependem de runtime e hardware. Não há alegação genérica de superioridade; registre CPU, SO, Ruby, commit, warmup, amostras, mediana e dispersão. Outros benchmarks ficam em `benchmarks/` e estão descritos em [Performance](docs/performance.md).
 
-## Migration from Airbrake
+## Migração do Airbrake
 
-An Airbrake migration guide will be added before the legacy 1.0 release. Version 0.9 does not claim API compatibility or automatic replacement.
+Migre por etapas e mantenha os dois agentes juntos somente durante a validação, evitando duplicidade prolongada. Callbacks e notices não são API-compatíveis e devem ser traduzidos/testados explicitamente. Consulte o [guia de migração do Airbrake](docs/migration-from-airbrake.md).
 
-## Local development
+## Desenvolvimento local
 
-Clone the repository, install Bundler 1.17.3, and run setup:
+Instale Bundler 1.17.3 e as dependências:
 
 ```bash
 gem install bundler -v 1.17.3
 bin/setup
 ```
 
-Open an interactive console:
-
-```bash
-bin/console
-```
-
-Install the current source locally:
-
-```bash
-bundle _1.17.3_ exec rake install
-```
+Use `bin/console` para inspeção e `bundle _1.17.3_ exec rake install` para instalar a fonte localmente. A arquitetura hexagonal está descrita em [Arquitetura](docs/architecture.md).
 
-## Tests
+## Testes
 
-Run the complete suite on the current Ruby:
+Execute suíte e lint no runtime atual:
 
 ```bash
 bundle _1.17.3_ exec rake
 ```
 
-The legacy CI matrix covers Ruby 2.2.10, 2.3.8, 2.4.10, 2.5.9, and 2.6.10. Network integration tests use a local fake HTTP server.
+A matriz CI cobre Ruby 2.2.10–2.6.10, aplicações Rails 4.2/5.2 e Sidekiq 4/5. O workflow de release repete toda a matriz, documentação, benchmark comparativo e carga antes de publicar.
 
-## Contributing
+## Contribuição
 
-Open an issue before introducing a new public API or dependency. Every public class requires YARD documentation, tests, module documentation, and compatibility evidence. See [CONTRIBUTING.md](CONTRIBUTING.md).
+Abra uma issue antes de adicionar API pública ou dependência. Classes públicas precisam de YARD, testes, documentação de módulo e evidência de compatibilidade. Veja [CONTRIBUTING.md](CONTRIBUTING.md).
 
-## Security
+## Segurança
 
-Never include credentials in event context or logs. Report vulnerabilities privately according to [SECURITY.md](SECURITY.md). Ruby 2.2 through 2.6 are end-of-life; Chronos provides technical compatibility, not runtime security maintenance.
+Nunca inclua credenciais no contexto. Releases usam Trusted Publishing, checksum SHA-256 e SBOM; dependências passam por auditoria. Reporte vulnerabilidades pelo canal privado de [SECURITY.md](SECURITY.md).
 
-## License
+## Licença
 
-Chronos Ruby is distributed under the terms of the MIT License. See [LICENSE.txt](LICENSE.txt).
+Chronos Ruby é distribuída sob a licença MIT. Veja [LICENSE.txt](LICENSE.txt).

data/docs/adr/ADR-007-feature-detection.md

@@ -0,0 +1,25 @@
+# ADR-007 — Feature detection nas integrações
+
+## Status
+
+Aceito para 1.0.
+
+## Contexto
+
+Rails 4.2/5.2, Active Job e Sidekiq 4/5 expõem conjuntos diferentes de constantes e hooks. Comparar apenas números de versão cria falsos positivos em instalações parciais.
+
+## Decisão
+
+Integrações opcionais verificam a presença da biblioteca e das APIs públicas necessárias antes de instalar middleware, subscribers ou extensões. A instalação é idempotente e não exige Zeitwerk.
+
+## Alternativas
+
+Branches por versão e uso de APIs privadas foram rejeitados por fragilidade e custo de manutenção.
+
+## Consequências positivas
+
+O núcleo permanece carregável em Ruby puro e combinações validadas compartilham adapters menores.
+
+## Consequências negativas
+
+Cada caminho detectado exige contrato e aplicação de exemplo; uma biblioteca que imite parcialmente a API pode precisar de tratamento dedicado.

data/docs/adr/ADR-008-context-store.md

@@ -0,0 +1,25 @@
+# ADR-008 — Context store por runtime
+
+## Status
+
+Aceito para 1.0 legado.
+
+## Contexto
+
+Requests e jobs concorrentes não podem compartilhar usuário, parâmetros, breadcrumbs ou trace ID, mas Ruby 2.2 não oferece uma estratégia fiber-local moderna uniforme.
+
+## Decisão
+
+Definir uma porta de context store e usar armazenamento thread-local na linha 0.x/1.0 legado. Todo escopo restaura o valor anterior e limpa em `ensure`; somente IDs permitidos atravessam processos.
+
+## Alternativas
+
+Estado global foi rejeitado por vazamento entre execuções. Fiber local foi adiado para a linha moderna.
+
+## Consequências positivas
+
+O isolamento é testável e o núcleo não depende da primitiva concreta.
+
+## Consequências negativas
+
+Threads e fibers criadas pela aplicação exigem propagação explícita; adapters futuros precisam preservar a mesma porta.

data/docs/adr/ADR-009-sampling.md

@@ -0,0 +1,25 @@
+# ADR-009 — Sampling limitado localmente
+
+## Status
+
+Aceito para 1.0.
+
+## Contexto
+
+O agente precisa controlar volume durante carga alta e aceitar redução remota sem permitir expansão inesperada da coleta.
+
+## Decisão
+
+Usar `sampling_rate` local como teto. Configuração remota pode somente reduzir a taxa, desabilitar tipos ou ativar kill switch. As opções são allowlisted, limitadas e nunca incluem código/regex.
+
+## Alternativas
+
+Sampling exclusivamente no servidor desperdiça transporte. Sampling remoto sem teto local foi rejeitado por privacidade e previsibilidade.
+
+## Consequências positivas
+
+O operador conserva controle e a decisão ocorre antes de HTTP/retry.
+
+## Consequências negativas
+
+Sampling uniforme pode perder eventos raros; análises devem considerar a taxa efetiva.

data/docs/adr/ADR-010-opentelemetry-interoperability.md

@@ -0,0 +1,25 @@
+# ADR-010 — Interoperabilidade futura com OpenTelemetry
+
+## Status
+
+Adiado; limite aceito para 1.0 legado.
+
+## Contexto
+
+O Chronos precisa correlacionar trace/request sem duplicar SDKs ou impor dependências modernas a Ruby 2.2–2.6.
+
+## Decisão
+
+Manter IDs de correlação e portas independentes do fornecedor na 1.0. Não depender de OpenTelemetry nem instalar instrumentação global na linha legado. Uma ponte opcional será projetada na linha transitional/modern e deverá traduzir somente campos permitidos.
+
+## Alternativas
+
+Adicionar o SDK como dependência obrigatória foi rejeitado por incompatibilidade e overhead. Copiar spans completos foi rejeitado por cardinalidade e privacidade.
+
+## Consequências positivas
+
+O protocolo v1 permanece estável e aplicações legadas não recebem novas dependências.
+
+## Consequências negativas
+
+Não há propagação automática com ecossistemas OpenTelemetry na 1.0; integrações futuras exigirão contrato e matriz próprios.

data/docs/adr/ADR-018-pre-1.0-hardening.md

@@ -1,9 +1,13 @@
 # ADR-018: Pre-1.0 hardening gates
 
+## Status
+
+Concluído pela versão 1.0.0.
+
 ## Decision
 
-Keep the release at `0.9.0.pre.2` while any mandatory 1.0 evidence remains external or incomplete. Add bounded local ignore rules, Active Job envelope propagation, real Sidekiq compatibility jobs, repeatable comparative/load benchmarks, and explicit release/security policies.
+Keep the release in prerelease while any mandatory 1.0 evidence remains external or incomplete. Promote only after bounded local ignore rules, Active Job envelope propagation, real Sidekiq compatibility jobs, repeatable comparative/load benchmarks, and explicit release/security policies are present and green.
 
 ## Consequences
 
-The stable API is not promised before the full legacy matrix passes. Active Job gains one namespaced serialized field without changing arguments. Application callbacks remain bounded in count but their execution cost belongs to the application. Package checksums are used until a trusted signing lifecycle is available.
+The complete candidate matrix passed before the 1.0 promotion. Active Job has one namespaced serialized field without changing arguments. Application callbacks remain bounded in count but their execution cost belongs to the application. Trusted Publishing, package checksums and SBOMs are used until a trusted signing lifecycle is available.

data/docs/compatibility.md

@@ -1,36 +1,43 @@
 # Compatibility
 
-Chronos Ruby 0.x is the legacy line. Technical compatibility does not make an end-of-life Ruby or Rails release secure.
+Chronos Ruby 1.0 is the stable legacy line. Technical compatibility does not make an end-of-life Ruby, Rails, Rack, or Sidekiq release secure.
 
-| Ruby | Rails integration | Status | Evidence |
-|---|---|---|---|
-| 2.2.10 | Rails 4.2 | Best effort | Core CI, Rails 4.2 example, dedicated smoke gate |
-| 2.3.8 | Rails 4.2 / 5.0 | Best effort | Core CI and feature-detection contract; dedicated app gate incomplete |
-| 2.4.10 | Rails 4.2 / 5.0 | Best effort | Core CI and feature-detection contract; dedicated app gate incomplete |
-| 2.5.9 | Rails 5.2 | Best effort | Core CI, Rails 5.2 example, dedicated smoke gate |
-| 2.6.10 | Rails 5.2 | Best effort | Core CI and feature-detection contract; dedicated app gate incomplete |
-| 2.7 and newer | None in 0.x | Unsupported | Belongs to transitional or modern lines |
-
-| Ruby | Sidekiq integration | Status | Evidence |
-|---|---|---|---|
-| 2.2.10 | Sidekiq 4.2.10 | Best effort | Unit/integration contracts and dedicated real-gem Docker job |
-| 2.5.9 | Sidekiq 5.2.10 | Best effort | Unit/integration contracts and dedicated real-gem Docker job |
+## Core and Rack
 
-Version 0.5 includes Rails 4.2 and 5.2 applications plus a dedicated matrix, but this document conservatively keeps the combinations at `Best effort` until all release-gate evidence, including fake-server payload validation, is green. Rails 5.0 uses the same feature-detected public APIs but does not yet have its own example application.
+| Ruby | Status | Evidence |
+|---|---|---|
+| 2.2.10 | Supported | Full unit, integration, contract, Rack, concurrency, fork, transport, privacy, and lint gate |
+| 2.3.8 | Supported | Same dedicated Docker gate |
+| 2.4.10 | Supported | Same dedicated Docker gate |
+| 2.5.9 | Supported | Same dedicated Docker gate |
+| 2.6.10 | Supported | Same dedicated Docker gate |
+| 2.7 and newer | Unsupported in 1.x legacy | Belongs to the transitional or modern lines |
 
-Version `0.9.0.pre.2` adds dedicated Sidekiq 4.2.10 and 5.2.10 real-gem jobs. Status remains `Best effort` until both external jobs pass on the release candidate.
+## Rails
 
-Active Job propagation uses the standard `serialize`, `deserialize`, and `perform_now` extension points with a namespaced bounded field. Rails 4.2/5.2 example jobs and unit contracts provide evidence; the complete external matrix must still pass before stable support is declared.
+| Ruby | Rails | Status | Evidence |
+|---|---|---|---|
+| 2.2.10 | 4.2 | Supported | Real application boot, successful/error request, SQL, view, cache, Active Job, mailer, fake endpoint, flush, and shutdown |
+| 2.3.8 | 4.2 | Supported | Same dedicated application gate |
+| 2.5.9 | 5.2 | Supported | Same dedicated application gate |
+| 2.6.10 | 5.2 | Supported | Same dedicated application gate |
+| Other Ruby/Rails pairs | — | Unsupported | No complete release gate; feature detection alone is not a support claim |
 
-Version `0.7.0.pre.1` keeps the same Ruby/Rails matrix and implements APM aggregation without modern concurrency or SQL-parser dependencies. Its compatibility remains `Best effort` until request/SQL/job aggregate payloads pass the dedicated fake-server gates for every listed runtime.
+## Sidekiq
+
+| Ruby | Sidekiq | Status | Evidence |
+|---|---|---|---|
+| 2.2.10 | 4.2.10 | Supported | Real-gem client/server middleware smoke with context, success/failure, and deduplication |
+| 2.5.9 | 5.2.10 | Supported | Same dedicated application gate |
+| Other Ruby/Sidekiq pairs | — | Unsupported | No complete release gate |
 
-Version `0.8.0.pre.1` uses per-object `Module#prepend`, legacy `Net::HTTP`, standard-library SHA-256, and loaded-spec feature detection. It adds no runtime dependency and keeps the same matrix. Outbound HTTP, cache, and dependency gates must pass every listed runtime before support is promoted.
+Active Job uses the public `serialize`, `deserialize`, and `perform_now` extension points with a bounded namespaced field. Support follows the validated Rails pairs above. Adapters that bypass these hooks require their own evidence.
 
-Version `0.9.0.pre.1` adds only standard-library URI/SecureRandom processing, bounded hashes, and the existing synchronous delivery path. Capistrano is optional and feature-detected; Kamal and GitHub Actions integrations are commands/examples. The Ruby/Rails matrix remains unchanged and `Best effort` until deploy/correlation payload gates pass every listed runtime.
+The release workflow repeats every supported pair before publishing. The green candidate evidence that permitted the 1.0 promotion is recorded in [Version 1.0 readiness](release-1.0-readiness.md).
 
 Status meanings:
 
-- Supported: the complete required compatibility gate passes.
-- Best effort: intended to work, but the complete gate has not passed yet.
+- Supported: every mandatory compatibility gate for the exact pair passes.
+- Best effort: intended to work but missing a complete gate; no 1.0 pair is advertised this way.
 - Deprecated: still tested while removal is planned.
-- Unsupported: outside this release line.
+- Unsupported: outside the tested 1.0 contract.

data/docs/deprecation-policy.md

@@ -4,4 +4,4 @@ After `1.0.0`, a public API scheduled for removal remains available for at least
 
 Warnings are emitted at most once per process through the configured safe logger and must not include application payloads. Security fixes, behavior that can expose secrets, and upstream runtime incompatibilities may require faster action; the security advisory and changelog must explain the exception. Ruby/Rails support changes are recorded in `docs/compatibility.md` before removal.
 
-Prereleases may revise APIs without the full stable window, but every incompatible revision must remain explicit. Version `0.9.0.pre.2` introduces no removal.
+Prereleases may revise APIs without the full stable window, but every incompatible revision must remain explicit. Version `1.0.0` starts the stable deprecation window and introduces no removal.

data/docs/migration-from-airbrake.md

@@ -1,6 +1,6 @@
 # Migration from Airbrake
 
-Version `0.9.0.pre.2` provides a staged migration path. Run both agents only long enough to compare delivery, then remove Airbrake to avoid duplicate reports and overhead.
+Version `1.0.0` provides a staged migration path. Run both agents only long enough to compare delivery, then remove Airbrake to avoid duplicate reports and overhead.
 
 | Airbrake concept | Chronos equivalent |
 |---|---|

data/docs/modules/breadcrumbs.md

@@ -0,0 +1,23 @@
+# Breadcrumbs
+
+## Problema e limite
+
+Breadcrumbs preservam uma trilha curta do fluxo que antecedeu uma falha. Não são logs, tracing completo ou armazenamento de payloads brutos.
+
+## Fluxo e classes
+
+`Chronos.add_breadcrumb` normaliza a categoria e os metadados em `Chronos::Core::Breadcrumb`. `BreadcrumbBuffer` mantém um anel de capacidade fixa no context store. O `NoticeBuilder` copia a fotografia atual; sanitizer e serializer aplicam novamente limites antes da entrega.
+
+## Extensão, riscos e exemplo
+
+Integrações podem registrar apenas categorias conhecidas e metadados de baixa cardinalidade. Mensagens e metadados continuam sendo dados da aplicação e podem conter informação pessoal se o chamador ignorar minimização.
+
+```ruby
+Chronos.add_breadcrumb(
+  :category => "custom",
+  :message => "invoice queued",
+  :metadata => {"provider" => "example"}
+)
+```
+
+Os limites e a herança por captura são testados em `spec/unit/core/breadcrumb_spec.rb`, `spec/unit/agent_spec.rb` e nos specs de Rack.

data/docs/modules/context.md

@@ -0,0 +1,21 @@
+# Contexto de execução
+
+## Problema e limite
+
+O contexto relaciona uma exceção ou métrica ao request/job atual sem criar dependência do núcleo com Rack, Rails ou Sidekiq. Ele guarda somente valores delimitados e não é um repositório de estado da aplicação.
+
+## Fluxo e classes
+
+`Chronos::Ports::ContextStore` define `get`, `set`, `clear` e `with_context`. Na linha legado, `Chronos::Adapters::ThreadLocalContextStore` isola o valor por thread. A fachada combina o contexto explícito com o escopo atual; o serializer sanitiza e limita tudo antes da fila. Rack limpa o escopo em `ensure`, enquanto Sidekiq e Active Job propagam apenas `trace_id` e `request_id`.
+
+## Extensão, riscos e exemplo
+
+Um adaptador alternativo pode ser configurado quando implementar a porta completa. Ele precisa restaurar escopos aninhados e garantir limpeza após exceções. Thread local não acompanha automaticamente fibers ou threads criadas pela aplicação; nesses casos, propague somente os identificadores permitidos.
+
+```ruby
+Chronos.with_context("trace_id" => "trace-42", "request_id" => "request-7") do
+  Chronos.notify(RuntimeError.new("failure"))
+end
+```
+
+Os contratos estão em `spec/unit/ports/context_store_spec.rb`, `spec/unit/adapters/thread_local_context_store_spec.rb` e `spec/integration/rack_middleware_concurrency_spec.rb`.

data/docs/modules/deploys.md

@@ -0,0 +1,23 @@
+# Deploys
+
+## Problema e limite
+
+Deploys criam o marco temporal usado para comparar erros e desempenho antes/depois de uma release. A gem informa o evento; reconciliação e análise pertencem ao SaaS.
+
+## Fluxo e classes
+
+`Chronos.notify_deploy` passa atributos explícitos a `Core::DeployNormalizer`, sanitiza o evento e usa entrega síncrona com idempotência. `CorrelationContext` copia release, revision, deploy ID, ambiente, serviço, região e instância para todos os envelopes. Uma entrega bem-sucedida libera um novo snapshot de dependências.
+
+## Extensão, riscos e exemplo
+
+Capistrano possui hook opcional; Kamal e GitHub Actions usam comandos documentados. A gem não lê Git nem variáveis automaticamente. O retorno `false` deve ser tratado conforme a política de deploy da aplicação.
+
+```ruby
+Chronos.notify_deploy(
+  :environment => "production",
+  :revision => ENV["GIT_SHA"],
+  :version => ENV["APP_VERSION"]
+)
+```
+
+Veja `spec/unit/core/deploy_normalizer_spec.rb`, `spec/unit/integrations/capistrano_spec.rb` e `spec/integration/deploy_delivery_spec.rb`.

data/docs/modules/job-monitoring.md

@@ -0,0 +1,22 @@
+# Monitoramento de jobs
+
+## Problema e limite
+
+Jobs precisam manter correlação entre enqueue e execução e registrar duração/falha sem abrir threads ou conexões por job. A versão 1.0 cobre Sidekiq 4/5 e Active Job disponível em Rails 4.2/5.2; Resque e Delayed Job permanecem fora do escopo estável.
+
+## Fluxo e classes
+
+O middleware Sidekiq injeta um envelope Chronos separado dos argumentos públicos. O servidor restaura contexto, mede fila/execução e deduplica exceções aninhadas. A integração Active Job usa os hooks públicos de serialização e `perform_now`. As observações seguem para `ApmAggregator` e as exceções para o notice pipeline.
+
+## Extensão, riscos e exemplo
+
+Adapters que substituem hooks públicos exigem testes próprios. Argumentos Sidekiq são limitados e sanitizados, mas a aplicação deve evitar segredos e dados pessoais desnecessários.
+
+```ruby
+require "chronos/sidekiq"
+Sidekiq.configure_server do |config|
+  config.server_middleware { |chain| chain.add Chronos::Integrations::Sidekiq::ServerMiddleware }
+end
+```
+
+Veja `spec/unit/integrations/sidekiq_spec.rb`, `spec/unit/integrations/active_job_spec.rb` e `spec/integration/sidekiq_delivery_spec.rb`.

data/docs/modules/request-monitoring.md

@@ -0,0 +1,20 @@
+# Monitoramento de requests
+
+## Problema e limite
+
+Requests Rack/Rails alimentam métricas de duração, status e breakdown com dimensões limitadas. O módulo não lê bodies, cookies, autorização ou query string bruta.
+
+## Fluxo e classes
+
+O middleware Rack cria contexto isolado e mede o request. Subscribers Rails enriquecem controller/action e evitam duplicação. `CaptureTelemetry` envia a observação a `ApmAggregator`; por padrão ela integra um `metric_batch`, e com APM desativado vira evento individual sanitizado.
+
+## Extensão, riscos e exemplo
+
+Rotas devem ser normalizadas para evitar cardinalidade por ID. Aplicações Rack podem fornecer um normalizador por meio dos campos já aceitos, sem incluir parâmetros sensíveis.
+
+```ruby
+use Chronos::Integrations::Rack::Middleware,
+    :include_user_agent => false
+```
+
+Veja `spec/integration/rack_middleware_spec.rb`, `spec/integration/rack_middleware_concurrency_spec.rb` e `spec/integration/apm_aggregation_delivery_spec.rb`.

data/docs/modules/runtime-metrics.md

@@ -0,0 +1,22 @@
+# Informações de runtime
+
+## Problema e limite
+
+O agente identifica o runtime necessário para diagnóstico e inventário sem varrer o ambiente, o sistema de arquivos ou conexões da aplicação. A versão 1.0 não implementa profiling nem coleta contínua de CPU/RSS.
+
+## Fluxo e classes
+
+`Chronos::Core::RuntimeInfo` produz engine, versão, plataforma, PID, thread opaca e hostname permitido. `DependencyReporter` adiciona versões já carregadas de Ruby, Rails, servidor, adaptador de banco e Sidekiq em um evento separado e limitado, no máximo uma vez por agente e após deploy bem-sucedido.
+
+## Extensão, riscos e exemplo
+
+Aplicações podem configurar versão, release, região e instância explicitamente. Hostname, IDs de processo e inventário podem ser dados pessoais ou revelar topologia; desative `dependency_reporting` quando a finalidade não justificar a coleta.
+
+```ruby
+Chronos.configure do |config|
+  config.dependency_reporting = false
+  config.app_version = "2026.07.29"
+end
+```
+
+Veja `spec/unit/core/runtime_info_spec.rb`, `spec/unit/application/dependency_reporter_spec.rb` e `spec/integration/dependency_delivery_spec.rb`.

data/docs/modules/sampling.md

@@ -0,0 +1,22 @@
+# Sampling
+
+## Problema e limite
+
+Sampling reduz volume de eventos sem permitir que o servidor amplie a coleta decidida localmente. Ele não substitui quotas no receptor e não deve ser usado para esconder falhas do agente.
+
+## Fluxo e classes
+
+`Chronos::Configuration` valida `sampling_rate` entre `0.0` e `1.0`. `Chronos::Application::RemoteConfiguration` calcula o limite efetivo, que nunca excede o valor local, e `DeliveryPipeline` decide antes do transporte. Deploys e verificações explícitas usam seus próprios caminhos síncronos e não são descartados pelo sampling comum.
+
+## Extensão, riscos e exemplo
+
+O gerador aleatório pode ser injetado nos objetos internos para testes determinísticos; a API pública expõe somente a taxa. Taxas baixas podem ocultar eventos raros e não garantem amostragem estatística estratificada.
+
+```ruby
+Chronos.configure do |config|
+  config.sampling_rate = 0.25
+  config.remote_configuration = true
+end
+```
+
+O comportamento é coberto por `spec/unit/application/remote_configuration_spec.rb`, `spec/unit/application/delivery_pipeline_spec.rb` e `spec/integration/deploy_delivery_spec.rb`.

data/docs/modules/sidekiq-legacy.md

@@ -4,7 +4,7 @@ Version `0.6.0.pre.1` starts the legacy jobs line with optional Sidekiq 4 and 5
 
 ```ruby
 gem "sidekiq", "~> 5.0"
-gem "chronos-ruby", "0.9.0.pre.4", :require => "chronos/sidekiq"
+gem "chronos-ruby", "~> 1.0.0", :require => "chronos/sidekiq"
 ```
 
 `chronos/sidekiq` installs middleware through the public `configure_client` and `configure_server` APIs. It does nothing when Sidekiq is unavailable, and the core gem never requires Sidekiq. Installation adds no Chronos thread or Redis/database connection per job; delivery continues through the agent's existing fixed worker pool.

data/docs/modules/sql-monitoring.md

@@ -0,0 +1,22 @@
+# Monitoramento SQL
+
+## Problema e limite
+
+O monitoramento SQL mede operação, tabela e duração sem transmitir SQL bruto ou binds. Sinais locais de lentidão, repetição, possível N+1, transação longa, conexão e deadlock são diagnósticos heurísticos.
+
+## Fluxo e classes
+
+`Rails::NotificationsSubscriber` extrai somente campos permitidos. `Core::SqlNormalizer` remove comentários e literais, limita identificadores e calcula fingerprint SHA-256. `ApmAggregator` mantém grupos e fingerprints por trace com capacidades fixas, então drena lotes pelo pipeline comum.
+
+## Extensão, riscos e exemplo
+
+Thresholds podem ser configurados, mas dimensões de alta cardinalidade não devem ser adicionadas. Nomes de schema, tabela e coluna ainda podem revelar domínio e precisam de avaliação LGPD.
+
+```ruby
+Chronos.configure do |config|
+  config.apm_slow_query_threshold_ms = 500.0
+  config.apm_n_plus_one_threshold = 5
+end
+```
+
+Veja `spec/unit/core/sql_normalizer_spec.rb`, `spec/unit/application/apm_aggregator_spec.rb` e `spec/integration/rails_telemetry_delivery_spec.rb`.

data/docs/performance.md

@@ -1,6 +1,6 @@
 # Performance
 
-Performance is a functional requirement, but version 0.9 makes no unverified speed claim.
+Performance is a functional requirement, but version 1.0 makes no unverified speed claim.
 
 Current controls:
 
@@ -29,7 +29,7 @@ Current controls:
 
 Run the scripts under `benchmarks/` and record Ruby version, operating system, CPU, warmup, iteration count, median, and dispersion before publishing results. `benchmarks/filtering.rb` measures privacy filtering, `benchmarks/retry_backlog.rb` measures fixed-memory outage behavior, `benchmarks/request_overhead.rb` compares Rack-protocol calls, and `benchmarks/rails_notifications.rb` isolates subscriber normalization overhead.
 
-## Version 0.9.0.pre.4 release gates
+## Version 1.0.0 release gates
 
 `benchmarks/comparative.rb` compares the same successful Rack fixture without and with Chronos instrumentation. It performs configurable warmup, at least three samples, and reports median plus median absolute deviation. `benchmarks/fake_endpoint_load.rb` sends asynchronous exception events to a local TCP endpoint, verifies the v1 schema marker, ensures the secret key is absent from every payload, and fails on loss, rejection, invalid payload, or timeout.
 
@@ -40,6 +40,17 @@ ITERATIONS=500 bundle exec ruby benchmarks/fake_endpoint_load.rb
 
 Results are environment-specific evidence, not a general speed claim. Record CPU, OS, Ruby, gem commit, and environment variables with any published result. Airbrake comparison remains optional and must use a legally compatible, equivalent sanitized payload on the same supported runtime.
 
+### Stable candidate measurement
+
+The 1.0 candidate was measured on 2026-07-29 on an Apple Silicon arm64 host running macOS 26.6, with Ruby 2.2.10 executing as x86_64. The working tree was based on commit `ce7c67852dd39406f514499b0347a67c5b09bb8c` plus the 1.0 release changes. This is release-gate evidence for this environment, not a universal performance claim.
+
+| Gate | Configuration | Result |
+|---|---|---|
+| Rack comparison | 1,000 warmup calls, 10,000 calls/sample, 5 samples | direct median 0.016036 s (MAD 0.000187); Chronos median 0.482321 s (MAD 0.016988); median incremental work 46.628 µs/request |
+| Fake endpoint load | 500 asynchronous exceptions, 2 workers, queue 500 | 500/500 accepted and received, zero invalid/secret-bearing payloads, 1.444941 s, 346.03 events/s |
+
+The release workflow repeats both gates on the tag. It does not enforce a cross-hardware timing threshold; correctness, bounded delivery, complete receipt, privacy and repeatability are hard failures, while timing regressions are reviewed with the recorded environment.
+
 ## Version 0.5 Rails subscriber benchmark
 
 Run:

data/docs/protocol-v1.md

@@ -1,6 +1,6 @@
 # Protocol v1 stability
 
-The schemas under `contracts/` are the source of truth for protocol v1. Version `0.9.0.pre.4` keeps `schema_version: "1.0"` and treats every required field, enum value, privacy exclusion, and maximum as a compatibility contract.
+The schemas under `contracts/` are the source of truth for protocol v1. Version `1.0.0` freezes `schema_version: "1.0"` and treats every required field, enum value, privacy exclusion, and maximum as a compatibility contract.
 
 Compatible changes may add optional bounded fields or new event types accepted by the server. Removing or renaming a field, changing its type/meaning, weakening a bound, or making an optional field required needs a new protocol major schema. Authentication remains outside the JSON payload. Contract tests and `script/verify_docs` must pass before a release.
 

data/docs/release-1.0-readiness.md

@@ -1,18 +1,20 @@
-# Version 1.0 readiness
+# Version 1.0 release evidence
 
-Version `0.9.0.pre.4` is a hardening release, not the stable release. The local suite, lint, documentation verifier, build, load test, and comparative benchmark are required evidence. The release can advance to `1.0.0` only after the GitHub Actions matrix is green for every declared legacy Ruby/framework/job combination.
+Version `1.0.0` is the first stable legacy release. Promotion was based on the complete candidate commit `ce7c67852dd39406f514499b0347a67c5b09bb8c`; future tags must pass the same gates again inside the release workflow before publishing.
 
-| Gate | State in pre.4 |
-|---|---|
-| Ruby pure, Rack, Rails 4.2/5.2 | Implemented; external legacy matrix must pass |
-| Sidekiq 4/5 real gems | Dedicated Docker matrix added; must pass |
-| Active Job metadata/error/context | Implemented and contract-tested |
-| filters, bounded ignore rules, context, breadcrumbs | Implemented and documented |
-| request/SQL/job APM, deploy, retry/backlog, remote configuration | Implemented and contract-tested |
-| payload fixture privacy | Contract-tested |
-| public API/options/protocol review | Documented; final review required |
-| Airbrake migration, SemVer, deprecation, security review | Added in pre.2 |
-| fake endpoint load and repeatable comparison | Executable gates added |
-| package signing | Not currently feasible; protected secret plus checksum is the interim control |
+| Gate | Evidence for the candidate | Enforcement for the tag |
+|---|---|---|
+| Ruby 2.2.10–2.6.10 | [Legacy CI: success](https://github.com/antoniojefferson/chronos-ruby/actions/runs/29891291304) | `legacy-core` matrix |
+| Rails 4.2/5.2 applications | [Legacy Rails CI: success](https://github.com/antoniojefferson/chronos-ruby/actions/runs/29891291287) | `legacy-rails` matrix |
+| Sidekiq 4/5 real gems | [Legacy Sidekiq CI: success](https://github.com/antoniojefferson/chronos-ruby/actions/runs/29891291327) | `legacy-sidekiq` matrix |
+| Documentation and package | [Repository checks: success](https://github.com/antoniojefferson/chronos-ruby/actions/runs/29891291350) | `release-readiness` plus publish build |
+| Dependency audit | [Security: success](https://github.com/antoniojefferson/chronos-ruby/actions/runs/30251211355) | scheduled and pull-request security workflow |
+| Unit/integration/contracts/lint | 179 examples, 0 failures; 197 files, 0 offenses on Ruby 2.2.10 | every core matrix job |
+| Payload privacy | Contract tests reject secrets in payload and retry backlog | every core matrix job and fake-endpoint load gate |
+| API/options/protocol | Public facade, configuration table, v1 schemas, SemVer and deprecation policy reviewed | documentation verifier and contract suite |
+| Airbrake migration | Staged migration and rollback guide | documentation verifier |
+| Load and repeatable comparison | Local bounded fake endpoint plus median/MAD Rack comparison | `release-readiness` job |
+| Security/release artifacts | Security review, Trusted Publishing, SHA-256 and SPDX SBOM | publish job after all dependencies pass |
+| Package signing | Not currently feasible without a trusted key lifecycle | documented residual control: OIDC publishing, checksum and SBOM |
 
-Do not change compatibility status from `Best effort` or create a `v1.0.0` tag until all external jobs and the dependency audit pass without skips.
+`publish` depends on all four release jobs. A failed or skipped supported runtime/framework/job pair, documentation check, comparison, or load test prevents RubyGems publication.

data/docs/security-review.md

@@ -1,6 +1,6 @@
-# Security review for 0.9.0.pre.4
+# Security review for 1.0.0
 
-Review date: 2026-07-22. Scope: capture, serialization, transport, integration verification, remote configuration, framework/job integrations, release workflow, examples, and fixtures.
+Review date: 2026-07-29. Scope: capture, serialization, transport, integration verification, remote configuration, framework/job integrations, stable release workflow, examples, and fixtures.
 
 Verified by contracts and implementation review:
 
@@ -14,4 +14,4 @@ Verified by contracts and implementation review:
 - fixture privacy is enforced by contract tests and dependency advisories are checked by the security workflow.
 - integration verification accepts only a strict correlated response and never exposes raw receiver bodies, credentials, stack traces, paths, SQL, or internal architecture.
 
-Residual risks: supported Ruby/Rails versions are end-of-life; in-memory backlog is lost at exit; application filters/ignore rules execute application code; project identifiers and documented job IDs may be personal data in some deployments; package signing is not enabled because no trusted certificate/key lifecycle exists. Release artifacts should use protected environments and published SHA-256 checksums until signing can be operated safely.
+Residual risks: supported Ruby/Rails versions are end-of-life; in-memory backlog is lost at exit; application filters/ignore rules execute application code; project identifiers and documented job IDs may be personal data in some deployments; package signing is not enabled because no trusted certificate/key lifecycle exists. Stable artifacts use a protected environment, Trusted Publishing, SHA-256 checksums and SPDX SBOMs until signing can be operated safely.

data/lib/chronos/version.rb

@@ -1,4 +1,4 @@
 module Chronos
   # Current version of the legacy Chronos Ruby agent.
-  VERSION = "0.9.0.pre.4".freeze
+  VERSION = "1.0.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chronos-ruby
 version: !ruby/object:Gem::Version
-  version: 0.9.0.pre.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Antonio Jefferson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-22 00:00:00.000000000 Z
+date: 2026-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -113,6 +113,10 @@ files:
 - docs/adr/ADR-004-bounded-queue.md
 - docs/adr/ADR-005-sanitize-before-backlog.md
 - docs/adr/ADR-006-versioned-event-contract.md
+- docs/adr/ADR-007-feature-detection.md
+- docs/adr/ADR-008-context-store.md
+- docs/adr/ADR-009-sampling.md
+- docs/adr/ADR-010-opentelemetry-interoperability.md
 - docs/adr/ADR-011-bounded-resilience-and-remote-control.md
 - docs/adr/ADR-012-rack-context-isolation.md
 - docs/adr/ADR-013-legacy-rails-notifications.md
@@ -131,21 +135,29 @@ files:
 - docs/modules/active-job.md
 - docs/modules/apm-aggregation.md
 - docs/modules/async-queue.md
+- docs/modules/breadcrumbs.md
 - docs/modules/cache-observability.md
 - docs/modules/configuration.md
+- docs/modules/context.md
 - docs/modules/dependencies.md
 - docs/modules/deploy-tracking.md
+- docs/modules/deploys.md
 - docs/modules/external-http.md
 - docs/modules/ignore-rules.md
 - docs/modules/integration-verification.md
+- docs/modules/job-monitoring.md
 - docs/modules/notice-pipeline.md
 - docs/modules/rack-context.md
 - docs/modules/rails-legacy.md
 - docs/modules/remote-configuration.md
+- docs/modules/request-monitoring.md
 - docs/modules/retry-backlog.md
+- docs/modules/runtime-metrics.md
+- docs/modules/sampling.md
 - docs/modules/sanitization.md
 - docs/modules/serialization.md
 - docs/modules/sidekiq-legacy.md
+- docs/modules/sql-monitoring.md
 - docs/modules/telemetry-events.md
 - docs/modules/transport.md
 - docs/performance.md
@@ -247,9 +259,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.4.22
 signing_key: