Skip to content

Releases

Nidus 1.2.0

Choose a tag to compare

@vicotrbb vicotrbb released this 09 Oct 02:48
005e06a

Nidus 1.2.0 releases the complete remote main history through PR #41 as one coordinated cohort of 25 packages.

  • Share route normalization, parameter extraction, and operation identifier helpers across HTTP, OpenAPI, and CLI code while preserving their existing output and error contracts.
  • Consolidate SQLx adapter telemetry and derive the equivalent CacheConfig default.
  • Preserve Provider, Pipe<Input>, prelude exports, HTTP response module, and concrete middleware types for minor-version compatibility.
  • Update locked rustls to 0.23.45 and its required dependencies for RUSTSEC-2026-0285.

Install with nidus = { package = "nidus-rs", version = "1.2.0", features = ["http"] }. Install the CLI with cargo install cargo-nidus --version 1.2.0.

The annotated tag identifies source commit 005e06a3fc504fc4cf97d98f88fb5c6be2f12de2. The release passed 647 workspace tests, strict Clippy, formatting, rustdoc, feature-matrix checks, dependency policy and audit, all 25 package verifications, fresh artifact consumers, and compatibility checks for all 23 supported library targets against 1.1.0. GitHub CI also passed live service integration tests.

Release documentation · Merged PR · Publication workflow

The attached checksum manifest verifies all published package archives against the official registry checksums and clean tagged source archives, including Git provenance. The publication workflow verifies all package versions, docs.rs pages, and fresh public-registry consumer applications.

Nidus 1.1.0

Choose a tag to compare

@vicotrbb vicotrbb released this 09 Sep 14:45

Nidus 1.1.0

Nidus 1.1.0 is the coordinated minor release of all 25 framework packages. It includes the complete main history through the technical white-paper publication, together with managed applications, shared composition and cancellation-safe metrics. The candidate validation report records the pre-release proofs and their scope.

Managed applications and shared composition

ApplicationPlan provides one graph and provider composition path for production HTTP applications, workers and module-based tests. Explicit overrides apply before asynchronous initialization. Typed initializer metadata and Resource declarations make ownership and replacement visible; opaque legacy initializers remain supported.

The additive managed API owns startup, serving tasks and shutdown. It reports lifecycle state, closes task admission during draining, joins accepted tasks before resource cleanup, and returns a shared structured shutdown report. Startup failures roll back initialized resources in reverse order. Caller cancellation and dropping the last managed owner request cleanup through the supervisor.

Managed HTTP serving preserves streaming-body ownership through graceful drain or forced connection cancellation. TestApp::from_managed retains the same application container and supervises in-memory request bodies. See managed applications for usage, lifecycle policy and migration examples.

Existing unmanaged APIs remain available. Managed cancellation is cooperative: blocking callbacks and futures that never yield cannot be forcibly terminated safely. Resource initialization must clean up its own partial failure, and externally supplied overrides remain externally owned.

Cancellation-safe HTTP metrics

Metrics account for requests cancelled before their first poll, during a pending inner call, or during unwinding. nidus_http_cancelled_requests_total records cancellations separately from responses and inner errors; the in-flight gauge returns to zero on every terminal path. Existing hooks remain source compatible through a default cancellation callback.

Response metrics finish when a response becomes available, including its headers, rather than when a streaming body finishes. The managed server still retains ownership until the body completes or its connection is cancelled.

Integration and release verification

The OTLP exporter enters its captured Tokio runtime while polling HTTP export operations from the SDK batch thread. CockroachDB example decoding uses the database's integer width. The locked h2 dependency includes the RUSTSEC-2026-0258 fix. Local MySQL readiness waits for authenticated TCP connections.

Release packaging now verifies all 25 crates in one Cargo invocation, allowing Cargo to resolve the unpublished cohort through its temporary registry. Clean consumer checks pin the requested version, reject workspace paths, and exercise staged archives, the packaged CLI and both standalone examples.

The candidate adds task-admission stress, streaming ownership, composition-cancellation, partial-startup failure, last-owner drop and mixed metrics conservation proofs. The validation report distinguishes passing evidence from limitations and records the controlled performance comparison, dependency checks and Linux environment.

Compatibility and installation

The coordinated crate version is 1.1.0, using Rust 1.96 and edition 2024. Generated projects take their dependency version from the CLI package version. Applications can select nidus-rs = "1.1.0" (usually aliased to nidus) and the matching integration crates.

The technical white paper is included in the repository and linked from the website. Registry, documentation and deployment availability are verified separately during the coordinated release.

Release provenance

This minor release includes the complete main history through commit b57e124de38163bdd9f4c4cdc2683ecff912010f, including the merged technical white-paper publication. All 25 publishable packages use version 1.1.0.

All changes since v1.0.17.

Nidus v1.0.16

Choose a tag to compare

@vicotrbb vicotrbb released this 27 Jul 17:27

Release 1.0.16

Nidus 1.0.16 is a public-API-compatible reliability, performance, and
compile-surface patch containing every change merged to main since 1.0.15.

Runtime reliability

  • Bounded event queues now remove the oldest payload under the queue lock but
    destroy it only after releasing the lock. Slow, reentrant, and panicking
    destructors can no longer unnecessarily extend or poison the mutation
    critical section.
  • Provider registrars and async initializers now run in validated
    dependency-first order. Imported providers are available before their
    importers without changing the deterministic name order returned by
    ModuleGraph::modules().
  • Explicit feature modules may share one recursively typed dependency without
    producing a false DuplicateModule error. The shared provider and initializer
    execute once; caller-supplied duplicate definitions still fail.
  • Framework-owned fallback rate-limit identities now borrow their static value
    instead of allocating a temporary String. Opposite-order benchmark results
    did not establish a stable request-latency percentage, so the claim is limited
    to the deterministic allocation removal.

Focused performance work

  • Prometheus exposition now writes directly into one output buffer, streams
    label escaping, and reuses fixed label storage. Confirmation benchmarks for
    1, 10, and 100 admitted lifecycle series improved by 83.29%-87.28%.
  • Health readiness borrows registered check names and callbacks through
    serialization instead of cloning them for every response. The final
    eight-check confirmation improved by 15.84%-17.22%; an earlier noisy repeat
    remains documented, so no production latency guarantee is made.
  • Typed configuration lookup now traverses path segments while constructing the
    same diagnostic label once. Paired opposite-order comparisons improved a
    six-segment typed lookup by 31.17%-37.61%.

These are focused in-process benchmarks. They do not establish application
throughput, process RSS, availability, or p95/p99 latency.

Feature and safety hygiene

  • SQLite is no longer selected by PostgreSQL-only SQLx adapter builds. The
    normal dependency graph drops from 149 to 142 unique packages.
  • tower-http and its compression dependencies are no longer selected by the
    core-only facade. That graph drops from 53 to 33 unique packages.
  • Clean-build timing changed with execution order and does not support a
    compile-time speed claim; the retained result is the deterministic dependency
    and compile-surface reduction.
  • Cargo resolver 3 now aligns dependency selection with the edition-2024/MSRV
    workspace policy.
  • All framework, workspace-harness, and cargo-nidus crate roots forbid unsafe
    Rust, turning the existing safe-only implementation into a compiler-enforced
    invariant.
  • Feature-matrix checks use --locked, and controller/injectable macro
    expansion shares one private parser while preserving the complete trybuild
    diagnostic contract.

Documentation and proof

  • Native Tower timeout layers are documented as returning raw timeout errors;
    applications can map them with HandleErrorLayer, while
    timeout_response_layer remains the Nidus HTTP 408 option.
  • Async observed-job examples now show the observer, job, queue, runner, and
    execution lifecycle together.
  • New focused tests cover destructor reentrancy and panic recovery, typed-path
    edge cases, dependency-first startup, shared typed subgraphs, explicit
    duplicate diagnostics, feature isolation, and request-scoped extraction.

The release candidate is checked with workspace formatting, warnings-denied
Clippy, all-feature tests and doctests, isolated locked feature combinations,
rustdoc warnings as errors, dependency and RustSec policies, semver checks for
every publishable library, package file-list preflights, website verification,
benchmark-harness compilation, fuzz-target compilation, and standalone
external examples.

After publication, verify all 25 registry artifacts, docs.rs pages, and the two
standalone external examples against crates.io with:

bash scripts/verify-published-release.sh 1.0.16

Nidus v1.0.15

Choose a tag to compare

@vicotrbb vicotrbb released this 21 Jul 18:32

Release 1.0.15

Nidus 1.0.15 is a public-API-compatible patch release focused on dependency,
CI automation, macro compatibility, and security-scanning maintenance.

Compatible dependency and automation updates

  • Compatible Rust dependencies were refreshed, including Criterion 0.8,
    Redis 1.4, Tokio 1.53, Sentry 0.48.5, and current patch releases across the
    workspace.
  • Pinned GitHub Actions were updated to their current release commits for
    checkout, caching, Node setup, artifact upload, and OpenSSF Scorecard.
  • The fuzz lockfile now records the current Nidus workspace version, and an
    unused direct dependency was removed from the durable SQLx jobs adapter.

Syn 3 macro compatibility

  • Internal macro parsing now uses Syn 3 while keeping Nidus's generated API and
    route contracts unchanged.
  • Route receiver validation was adapted to Syn's receiver representation and
    now has focused regression coverage proving that route methods accept only
    shared &self receivers, rejecting by-value, mutable, and typed receivers.

Security-scanning policy

  • The reviewed RUSTSEC-2023-0071 non-applicability for SQLx 0.8.6's MySQL
    public-key password encryption is mirrored in an expiring OSV Scanner entry.
    The independent RustSec gate still verifies that sqlx-mysql is the only
    reverse dependency before accepting the exception.
  • Dependabot continues to accept patch and security updates while deferring
    SQLx, async-nats, and tower-http version transitions that would change
    foreign types exposed by Nidus 1.x public APIs.

Verification boundary

The release candidate is checked with workspace formatting, warnings-denied
Clippy, all-feature tests and doctests, isolated feature combinations, live
service adapters, rustdoc warnings as errors, dependency and RustSec policies,
OSV Scanner, semver checks for every publishable library, package file-list
preflights, website verification, benchmark-harness compilation, fuzz-target
compilation, SBOM and coverage generation, and standalone external examples.

After publication, verify all 25 registry artifacts, docs.rs pages, and the two
standalone external examples against crates.io with:

bash scripts/verify-published-release.sh 1.0.15

Nidus v1.0.14

Choose a tag to compare

@vicotrbb vicotrbb released this 20 Jul 14:09

Release 1.0.14

Nidus 1.0.14 is a public-API-compatible patch release focused on removing
avoidable allocation and cloning from typed configuration reads and lifecycle
startup.

Typed configuration reads

  • Typed top-level, nested, and whole-document reads now deserialize directly
    from the stored serde_json::Value instead of cloning the complete value
    first.
  • Required nested reads resolve their path once rather than rebuilding the same
    owned path inside a second lookup.
  • Public method signatures, owned output types, error variants, and repeated
    read behavior are unchanged. Focused tests prove that borrowed deserialization
    does not consume or mutate the stored configuration.

Two paired 150-sample Criterion comparisons, run in opposite execution orders
against the exact 1.0.13 source commit, classified the 128-service
configuration row as 86.04%-86.74% faster. These are isolated in-memory
microbenchmarks, not application-throughput guarantees.

Lifecycle startup bookkeeping

  • Sequential startup no longer allocates a vector containing every successful
    hook index solely for failure rollback.
  • When hook n fails, the existing sequential contract means hooks 0..n
    completed; rollback now traverses that exact range in reverse.
  • Expanded regression coverage preserves reverse-order shutdown for multiple
    successful hooks followed by a failure.

Two paired 150-sample Criterion comparisons, also run in opposite execution
orders, classified the 32-hook startup row as 18.48%-21.65% faster. Hooks that
perform substantial application work may see a much smaller relative effect.

Verification boundary

The release candidate is checked with workspace formatting, warnings-denied
Clippy, all-feature tests, rustdoc warnings as errors, dependency policy and
RustSec audits, semver checks for every publishable library, package file-list
preflights, website verification, benchmark-harness compilation, and standalone
external examples using temporary local patches.

After publication, verify all 25 registry artifacts, docs.rs pages, and the two
standalone external examples against crates.io with:

bash scripts/verify-published-release.sh 1.0.14

Nidus v1.0.13

Choose a tag to compare

@vicotrbb vicotrbb released this 18 Jul 06:35

Release 1.0.13

Nidus 1.0.13 is a public-API-compatible patch release focused on reducing
framework-owned work in dependency injection, readiness checks, event and job
dispatch, middleware, and structured logging while tightening HTTP and CLI
behavior.

DI and startup efficiency

  • Module validation now specializes empty and single-name metadata, moves owned
    names into graph indexes once, borrows graph-owned names during cycle checks,
    and allocates ambiguity lists only when multiple exporters exist.
  • Initialized singleton state no longer retains a second strong Arc; the
    existing OnceLock remains the authoritative fast-path cache.
  • Exact duplicate, cycle, ambiguity, nested-resolution, teardown, retry, panic,
    and concurrent-initialization behavior remains covered by focused tests.

Runtime hot paths

  • Readiness checks are polled concurrently in the request future instead of
    spawning one Tokio task per check. Timeouts, panic-to-down mapping,
    cancellation, and deterministic response ordering are preserved.
  • One-subscriber event publication no longer allocates a temporary collector or
    clones the event. Additional subscribers still receive ordered clones.
  • Observed event and job attributes now share immutable storage until explicit
    enrichment requires copy-on-write ownership.
  • Logging redaction lookup normalizes configured names once and performs
    allocation-free case-insensitive binary search at request time.
  • Request-ID and rate-limit middleware borrow configuration during synchronous
    policy work instead of cloning the complete configuration per request.

The retained Criterion results are isolated microbenchmarks documented in
docs/performance.md; they are not end-to-end throughput guarantees. Repeated
comparisons classified the changed rows as improvements, while experiments that
regressed controls or failed to reproduce were reverted.

HTTP, security, and CLI correctness

  • Request-scoped extraction failures no longer expose provider type names or
    factory details to clients; full diagnostics remain server-side.
  • Bearer authentication schemes are matched case-insensitively.
  • without_body_limit disables both declared-length and streaming body caps.
  • Error-envelope body replacement removes stale content length, encoding, and
    range headers while retaining unrelated response metadata.
  • Integration-envelope traceparent validation accepts valid future-version
    extensions while keeping version 00 exact and rejecting malformed or
    oversized values.
  • cargo nidus routes and cargo nidus openapi can associate uniquely named
    controllers and route implementations split across source files, while
    ambiguous short names fail with an actionable diagnostic.
  • #[nidus::main] documentation now matches the macro's existing support for
    named async functions with arguments and explains the nested-runtime boundary.

Verification boundary

The release candidate is checked with workspace formatting, warnings-denied
Clippy, all-feature tests, rustdoc warnings as errors, dependency policy and
RustSec audits, semver checks for all publishable crates, package file-list
preflights, website verification, benchmark harness compilation, and standalone
external examples using temporary local patches.

After publication, verify all 25 registry artifacts, docs.rs pages, and the two
standalone external examples against crates.io with:

bash scripts/verify-published-release.sh 1.0.13

Nidus v1.0.12

Choose a tag to compare

@vicotrbb vicotrbb released this 15 Jul 20:27

Release 1.0.12

Nidus 1.0.12 is a public-API-compatible patch release focused on faster request
paths, stricter runtime behavior, and stronger reproducible performance proof.

Request-path efficiency

  • Successful responses no longer allocate error-envelope path and request-ID
    strings, and panic isolation uses a concrete future instead of boxing every
    request.
  • Guard route labels, trusted-proxy lists, and Prometheus labels share immutable
    storage instead of cloning repeated strings. Request context also reuses the
    request ID as its default correlation ID.
  • Health routes prebuild immutable state and abort unfinished checks when a
    request is cancelled. OpenAPI fixed methods avoid owned-string allocation,
    and unnamespaced Moka reads and invalidations avoid temporary cache keys.

Runtime hardening

  • Trusted-proxy identity now walks all X-Forwarded-For fields from the connected
    peer toward the first untrusted hop, preventing attacker-controlled leftmost
    values from selecting a rate-limit identity.
  • SQLite and PostgreSQL readiness failures no longer expose driver details in
    public health responses.
  • Lifecycle tracing spans are active only while their asynchronous hook future
    is being polled, preventing unrelated work from inheriting lifecycle context.

CLI discovery

The routes, graph, and OpenAPI inspection commands now use one deterministic,
recursive source walker under src. This matches generated and feature-oriented
layouts and avoids treating valid OpenAPI examples in source text as malformed
attributes.

Homelab benchmark

The release includes a new paced end-to-end campaign comparing the exact
v1.0.4 tag with the 1.0.12 candidate across ping, users, projects, events, and
mixed workloads. Throughput remained effectively flat or slightly higher in
all five profiles. The mixed profile improved average latency by 16.89% and p95
latency by 8.89%.

All Nidus candidate and control groups passed the declared repeatability gates,
with 0% HTTP failures and 100% checks. The overall cross-framework campaign is
published as qualified rather than strictly accepted because Spring ping
average-latency CV reached 15.58% against its 15% threshold. No samples were
discarded and no threshold changed.

The benchmarked source is commit c0b6d82;
subsequent changes before release are documentation and release metadata only.

Verification boundary

The release candidate is checked with workspace formatting, strict Clippy,
all-feature tests, rustdoc warnings as errors, dependency policy and RustSec
audits, semver checks, package file-list preflights, website verification, and
standalone external examples using temporary local patches.

After publication, verify all 25 registry artifacts, docs.rs pages, and the two
standalone external examples against crates.io with:

bash scripts/verify-published-release.sh 1.0.12

Nidus v1.0.11

Choose a tag to compare

@vicotrbb vicotrbb released this 13 Jul 04:59

Release 1.0.11

Nidus 1.0.11 is a public-API-compatible patch release focused on measurable
OpenAPI construction efficiency and more reliable application shutdown.

OpenAPI allocation reduction

OpenAPI path normalization and operation-ID rendering now write directly into
one pre-sized String. The previous implementation created a temporary
Vec<String> and allocated per segment.

The same 100-route document construction and rendering benchmark was measured
before and after the change on one aarch64-apple-darwin machine with
rustc 1.96.0, 150 samples, a two-second warm-up, and a five-second measurement
window:

cargo bench --bench request_lifecycle -- 'nidus 100-route openapi document render' --warm-up-time 2 --measurement-time 5 --sample-size 150 --save-baseline pre_elite_20260712
cargo bench --bench request_lifecycle -- 'nidus 100-route openapi document render' --warm-up-time 2 --measurement-time 5 --sample-size 150 --baseline pre_elite_20260712

The saved baseline measured 341.66-351.44 us. The confirming implementation
run measured 280.76-283.64 us; Criterion reported an 18.40%-20.56%
improvement with p = 0.00. This result is a local document-build
microbenchmark, not an HTTP throughput guarantee.

Lifecycle shutdown reliability

Application shutdown now attempts every registered hook in reverse order even
when a hook fails. After all cleanup callbacks have run, the existing Result
API returns the first failure in shutdown order. This prevents one failing
adapter from skipping unrelated resource cleanup without changing the public
method signature or successful shutdown behavior.

Focused tests preserve path normalization, stable operation IDs, reverse-order
shutdown, and first-error reporting:

cargo test -p nidus-openapi path::tests
cargo test -p nidus-core --test lifecycle lifecycle_runner_attempts_remaining_shutdown_hooks_after_failure

Verification boundary

The release candidate is checked with workspace formatting, strict Clippy,
all-feature unit and integration tests, rustdoc warnings as errors, dependency
policy and RustSec audits, semver checks, package file-list preflights, the
request-lifecycle benchmark suite, and standalone external examples using
temporary local patches.

After publication, verify all 25 registry artifacts, docs.rs pages, and the two
standalone external examples against crates.io with:

bash scripts/verify-published-release.sh 1.0.11

Nidus v1.0.1

Choose a tag to compare

@vicotrbb vicotrbb released this 13 Jul 05:19

Historical release backfilled from the repository’s original v1.0.1 commit and changelog.

  • Release hygiene and package-proof improvements.
  • Public documentation updates for installation, crate selection, starter workflow, and supported versions.
  • Starter project improvements for a small module, controller, and service learning path.
  • CI package verification aligned with the publish workflow.

Nidus v1.0.10

Choose a tag to compare

@vicotrbb vicotrbb released this 11 Jul 21:36

Release 1.0.10

Nidus 1.0.10 adds a first-party integration ecosystem without adding vendor
clients to the nidus-rs facade. Existing 1.0 APIs remain available, and each
new adapter is installed separately.

Architecture

  • nidus-integrations owns only bounded envelopes, correlation, lifecycle
    state, health, and redaction-safe telemetry composition.
  • Redis, Kafka, NATS/JetStream, RabbitMQ, SQS, OpenTelemetry, Sentry, and
    SQLx-backed durable jobs are separate crates that expose their native clients.
  • Kafka partitions and offsets, JetStream consumers, RabbitMQ topology, and
    SQS visibility receipts remain backend-specific APIs rather than a generic
    queue facade.

Data and durable work

  • SQLx MySQL uses rustls/native roots and requires VERIFY_IDENTITY outside an
    explicit loopback development connection.
  • CockroachDB v26.2.0 is tested with generated certificates and
    sslmode=verify-full. Transaction retries are bounded, use full jitter, and
    retry only SQLSTATE 40001; ambiguous 40003 results are returned.
  • Durable jobs are persisted and at-least-once. They include scheduling,
    enqueue idempotency, attempt-fenced leases, heartbeats, retries, cancellation,
    recovery, acknowledgements, indexed DLQs, and bounded graceful shutdown.

Messaging and telemetry

  • Kafka uses delivery reports, idempotent producer defaults, manual consumer
    commits, and read_committed isolation.
  • Core NATS remains at-most-once; JetStream publishing waits for persistence
    acknowledgement. RabbitMQ publishing uses mandatory persistent messages and
    broker confirms. Standard SQS remains at-least-once.
  • OpenTelemetry uses the official SDK, bounded batching, W3C propagation,
    OTLP/gRPC or OTLP/HTTP over rustls, and explicit flush/shutdown.
  • Sentry owns initialization and restoration, isolated Tower request hubs,
    matched-route transactions, tracing/error/panic integrations, redaction,
    deduplication, and graceful flushing.

Verification boundary

The release candidate is checked with strict workspace formatting, Clippy,
tests, rustdoc, isolated feature builds, real pinned service tests, dependency
policy and RustSec audits, semver checks against 1.0.9, package file-list
preflights, and Criterion integration hot-path comparisons. The real-service
harness proves cleanup on success, failure, injected Rust panic, and
interruption.

After publishing the crates in dependency order, verify registry artifacts and
docs.rs pages with:

bash scripts/verify-published-release.sh 1.0.10