Stratara.ServiceDefaults 4.4.1

• net10.0

  • Destructurama.Attributed (>= 5.3.0)
  • Microsoft.Extensions.Http.Resilience (>= 10.9.0)
  • Microsoft.Extensions.ServiceDiscovery (>= 10.9.0)
  • OpenTelemetry.Exporter.OpenTelemetryProtocol (>= 1.18.0)
  • OpenTelemetry.Extensions.Hosting (>= 1.18.0)
  • OpenTelemetry.Instrumentation.EntityFrameworkCore (>= 1.18.0-beta.1)
  • OpenTelemetry.Instrumentation.Http (>= 1.18.0)
  • OpenTelemetry.Instrumentation.Runtime (>= 1.18.0)
  • RabbitMQ.Client.OpenTelemetry (>= 1.0.0-rc.2)
  • Serilog.Extensions.Hosting (>= 10.0.0)
  • Serilog.Formatting.Compact (>= 3.0.0)
  • Serilog.Settings.Configuration (>= 10.0.1)
  • Serilog.Sinks.Async (>= 2.1.0)
  • Serilog.Sinks.Console (>= 6.1.1)
  • Serilog.Sinks.File (>= 7.0.0)
  • Serilog.Sinks.OpenTelemetry (>= 4.2.0)
  • Stratara.Shared (>= 4.4.1)

A release about errors that were not errors. Where two writers insert the same row at once — two
deliveries forgetting a deleted tenant, two activations writing a partition's first checkpoint, two
hosts importing one API key — the framework already recovered, but EF Core had logged the losing
statement at Error first; on PostgreSQL and SQLite the insert now skips a row that is already there.
And a RabbitMQ bus whose broker went away first no longer reports a warning for every subscription it
stops, nor a failed handler for a message it merely could not acknowledge. No migration and no
configuration change is needed.

### Fixed

- **Forgetting a deleted tenant leaves no error in the log when two deliveries race.** A tenant's two
 deletion facts arrive in two bundles, so two deliveries of one projection can record the same tenant
 at once. The losing insert was caught and the tenant recorded all the same, but EF Core had already
 logged the failed statement at Error (`20102` and `10000`), so a customer deletion could leave two
 errors in a projection worker's log. On PostgreSQL and SQLite the tenants are now recorded with an
 insert that skips a row already there; on other providers the store still retries, and EF Core still
 logs the statement that lost.
- **A projection checkpoint's first write, and an API key two hosts import at once, leave no error in
 the log.** Two activations of one reader that overlap during a failover can both write a partition's
 first checkpoint, and hosts that seed the same key as they boot import it at once. The writer whose
 insert lost recovered — it took the other's checkpoint over, or adopted the other's key — but EF Core
 had already logged the failed statement at Error. On PostgreSQL and SQLite the insert now skips a row
 that is already there, as the record of forgotten tenants does; a checkpoint that another writer
 inserted and removed again before it could be taken over is refused with an
 `InvalidOperationException`. An import takes that path only where it is the only write on its
 context, and then writes the key and its membership in one transaction of its own, outside
 `SaveChanges` and its interceptors. An import on a context with unsaved changes or inside a
 transaction of the caller's saves through `SaveChanges` as before, and so does a table a consumer
 widened with columns the row does not carry, and every other provider: there the writer still
 recovers, and EF Core still logs the statement that lost.
- **A RabbitMQ subscription whose broker is already gone stops without a warning.** When a stack stops
 its broker before its hosts, a stopping subscription's cancel met a connection that had already
 closed, or that closed while the cancel waited for its reply, and every subscription of every host
 logged `108_107` at Warning — new in 4.4.0, which made a subscription cancel its consumer before it
 closes. A closed connection has no consumer left to cancel, which is where the stop was going, so
 this is now logged at Debug as `108_007` (`LogEvents.Messaging.SubscriptionAlreadyClosed`). A cancel
 that fails while the connection is still up still warns.
- **A handler that completes after the broker went away is no longer reported as failed.** Its
 acknowledgement met a closed channel, and the RabbitMQ bus logged `108_101` at Error although the
 handler had succeeded, then tried to reject the message on the same closed channel. It now logs
 `108_008` (`LogEvents.Messaging.MessageNotSettledChannelClosed`) at Information: the message could
 not be settled, and the broker delivers it again.