Julewire

Julewire is an execution-scoped structured logging toolkit for Ruby.

It is not a logger skin. Core owns record shape, context, propagation, processors, summaries, health, and synchronous output contracts. Integrations map Rails, Active Job, Karafka, GCP, Semantic Logger, and Ractor edges onto that core without depending on each other.

Julewire.configure do |config|
  config.destinations.use(:default, output: $stdout)
end

Julewire.with_execution(type: :request, id: "req-1") do
  Julewire.context.add(tenant_id: "acme")
  Julewire.summary.increment(:db_queries)
  Julewire.measure(:render) do
    Julewire.emit("handled", event: "orders.show", order_id: 123)
  end
end

Records are newline JSON by default. Framework gems add request/job/message lifecycles, structured events, propagation carriers, and provider formatting.

The normal Rails API setup is:

gem "julewire-rails"
gem "julewire-active_job"
gem "julewire-gcp"
gem "julewire-redaction"
gem "julewire-semantic_logger"

Then wire one destination and the filtering policy:

Julewire.configure do |config|
  config.processors.prepend(
    :rails_parameter_filter,
    Rails.application.config.filter_parameters
  )

  config.destinations.use(
    :semantic_logger,
    formatter: Julewire::GCP::Formatter.new(project_id: "my-project"),
    io: $stdout
  )
end

Rails hash event payloads are filtered by Rails before subscribers see them. Whole-record filtering for logger payloads and optional captured fields is a Julewire processor decision.

julewire tail renders newline JSON logs as compact console text. Provider gems can register their own decoders, so GCP-shaped Kubernetes logs can be tailed without core knowing the GCP wire shape:

kubectl logs -f deploy/my-app | julewire tail --format gcp --raw-invalid -

julewire transcode reads one registered format and writes another:

kubectl logs deploy/my-app | julewire transcode --from gcp --to core --raw-invalid -

See gems/core/docs/tail.md for the full CLI surface.

Julewire records are split into field bags:

• context: queryable facts copied onto records and summaries; propagates.
• carry: hidden forwarding metadata; propagates.
• attributes: emitted integration/application namespaces.
• neutral: provider-neutral formatter coordination facts.
• summary: final counters, timings, and completion facts.
• labels: operator-safe routing/grouping metadata.
• metrics: numeric measurements such as duration.

The core serializer bounds depth, arrays, hashes, strings, cycles, invalid encoding, non-finite numerics, and exception shapes. It is a safety layer, not a privacy layer; redaction is explicit processor policy.

This is a monorepo with independently-packaged gems under gems/. CI is path-filtered by gem; Codecov uses per-gem carryforward flags so partial runs do not pretend untouched gems went dark.

Each gem owns its test task:

cd gems/core
COVERAGE=true bundle exec rake

The root Rakefile can orchestrate all gem tasks from a Ruby environment with the gem bundles installed. Rails Appraisal suites live in gems/rails; the Ractor gem runs on Ruby 4.0 only.

MIT. Each packaged gem includes its own LICENSE.txt; the repository-level license is LICENSE.txt.