From 7877054119713522e2b674deab520925f1a6bb11 Mon Sep 17 00:00:00 2001 From: Matthew DeVenny Date: Mon, 20 Jul 2026 14:08:24 -0700 Subject: [PATCH 1/4] #39 Add OpenTelemetry Signed-off-by: Matthew DeVenny --- README.md | 104 +++++ src/NatsDistributedCache/NatsCache.cs | 203 ++++++--- .../NatsCacheOperationScope.cs | 226 ++++++++++ src/NatsDistributedCache/NatsCacheOptions.cs | 12 + .../NatsCacheTelemetry.cs | 166 ++++++++ .../NatsCacheTelemetryNames.cs | 43 ++ .../NatsCacheTelemetryOptions.cs | 23 + .../NatsDistributedCache.csproj | 4 + .../NatsDistributedCacheExtensions.cs | 8 + .../packages.linux-arm64.lock.json | 17 +- .../packages.linux-x64.lock.json | 17 +- .../packages.osx-arm64.lock.json | 17 +- .../packages.win-x64.lock.json | 17 +- .../packages.linux-arm64.lock.json | 3 +- .../packages.linux-x64.lock.json | 3 +- .../packages.osx-arm64.lock.json | 3 +- .../packages.win-x64.lock.json | 3 +- test/IntegrationTests/Cache/TelemetryTests.cs | 395 ++++++++++++++++++ test/IntegrationTests/IntegrationTests.csproj | 2 + test/IntegrationTests/TestBase.cs | 11 + .../packages.linux-arm64.lock.json | 17 + .../packages.linux-x64.lock.json | 17 + .../packages.osx-arm64.lock.json | 17 + .../packages.win-x64.lock.json | 17 + .../Diagnostics/RecordingActivityListener.cs | 65 +++ test/TestUtils/packages.linux-arm64.lock.json | 3 +- test/TestUtils/packages.linux-x64.lock.json | 3 +- test/TestUtils/packages.osx-arm64.lock.json | 3 +- test/TestUtils/packages.win-x64.lock.json | 3 +- test/UnitTests/Cache/TelemetryUnitTests.cs | 373 +++++++++++++++++ test/UnitTests/UnitTests.csproj | 4 + test/UnitTests/packages.linux-arm64.lock.json | 186 ++++++++- test/UnitTests/packages.linux-x64.lock.json | 186 ++++++++- test/UnitTests/packages.osx-arm64.lock.json | 186 ++++++++- test/UnitTests/packages.win-x64.lock.json | 186 ++++++++- .../Benchmarks/packages.linux-arm64.lock.json | 3 +- util/Benchmarks/packages.linux-x64.lock.json | 3 +- util/Benchmarks/packages.osx-arm64.lock.json | 3 +- util/Benchmarks/packages.win-x64.lock.json | 3 +- util/ReadmeExample/DistributedCache.cs | 7 + 40 files changed, 2402 insertions(+), 160 deletions(-) create mode 100644 src/NatsDistributedCache/NatsCacheOperationScope.cs create mode 100644 src/NatsDistributedCache/NatsCacheTelemetry.cs create mode 100644 src/NatsDistributedCache/NatsCacheTelemetryNames.cs create mode 100644 src/NatsDistributedCache/NatsCacheTelemetryOptions.cs create mode 100644 test/IntegrationTests/Cache/TelemetryTests.cs create mode 100644 test/TestUtils/Services/Diagnostics/RecordingActivityListener.cs create mode 100644 test/UnitTests/Cache/TelemetryUnitTests.cs diff --git a/README.md b/README.md index cc07377..d0f92ee 100644 --- a/README.md +++ b/README.md @@ -185,7 +185,111 @@ or is otherwise corrupt — the read is treated as a **cache miss** rather than Upgrading is therefore seamless in a rolling deployment: a node never deletes an entry it cannot read, so it cannot discard entries written by a newer node still being rolled out. +## Telemetry + +Metrics and traces are emitted through `System.Diagnostics.Metrics` and `System.Diagnostics.ActivitySource`. +**This package takes no dependency on OpenTelemetry.** Nothing is measured, timed, or allocated until a +listener subscribes, so registering the names below is the opt-in: + +```csharp +builder.Services.AddOpenTelemetry() + .WithMetrics(metrics => metrics.AddMeter(NatsCacheTelemetryNames.MeterName)) + .WithTracing(tracing => tracing.AddSource(NatsCacheTelemetryNames.ActivitySourceName)); +``` + +Both resolve to `CodeCargo.Nats.DistributedCache`. They are compile-time constants, so referencing them +does not initialize the meter. + +### Instruments + +| Name | Type | Unit | Description | +| --- | --- | --- | --- | +| `nats.cache.operation.duration` | Histogram<double> | `s` | Duration of cache operations | +| `nats.cache.misses` | Counter<long> | `{miss}` | Read misses, by reason | + +There is no separate hits/operations counter: the histogram's count already gives operation rate, hit +ratio, and error rate via the `nats.cache.result` tag. + +| Tag | Applies to | Values | +| --- | --- | --- | +| `nats.cache.operation` | both | `get`, `set`, `refresh`, `remove` | +| `nats.cache.bucket` | both | The configured `BucketName` | +| `nats.cache.result` | duration | `hit`, `miss`, `ok`, `error`, `cancelled` | +| `error.type` | duration | Exception type name; present only when `result=error` | +| `nats.cache.miss.reason` | misses | see below | + +`nats.cache.bucket` is one value per cache instance, so it adds no meaningful cardinality while keeping +two caches in the same process distinguishable. Spans carry the same tags, plus the optional +`nats.cache.key`. + +| Miss reason | Meaning | +| --- | --- | +| `not_found` | Key absent, or already reaped by the NATS TTL. The ordinary miss. | +| `expired` | Absolute expiration reached; the entry was evicted by this read. | +| `undeserializable` | Legacy or corrupt envelope (see [Cache Entry Format and Upgrades](#cache-entry-format-and-upgrades)). A sustained rate means a format migration has not drained. | +| `revision_conflict` | Lost an optimistic-concurrency race while refreshing a sliding expiration. A sustained rate means key contention. | + +### Example queries + +```promql +# Hit ratio. Both selectors must filter on the same operation — leaving it off the numerator would +# fold refresh hits into a denominator that counts only gets, producing a ratio above 1. +sum(rate(nats_cache_operation_duration_count{nats_cache_operation="get",nats_cache_result="hit"}[5m])) + / sum(rate(nats_cache_operation_duration_count{nats_cache_operation="get"}[5m])) + +# p99 latency by operation +histogram_quantile(0.99, sum by (le, nats_cache_operation) + (rate(nats_cache_operation_duration_bucket[5m]))) +``` + +### Notes + +- **Cache keys are never recorded on metrics.** Set `options.Telemetry.RecordCacheKeys = true` to add the + key to *spans* as `nats.cache.key`; it defaults to `false` because keys commonly embed user or tenant + identifiers. +- **`TryGet` failures report `result=error`, not `result=miss`.** The read failed rather than finding + nothing, and conflating the two would make an outage look like a cold cache. The observed miss rate a + caller experiences is `miss + error`. +- **`TryGet` reports as `operation=get`.** The `IBufferWriter` overload is a zero-copy detail, not a + different cache operation, so hit ratio covers all read paths. +- **Cancellation of the caller's own token is `result=cancelled`, not an error**, so shutdown-time + cancellation does not trigger error alerts. An `OperationCanceledException` raised for any other reason — + a NATS request timeout, for example — is reported as `result=error`, matching how the same event is + logged, so genuine failures are never hidden behind the cancellation filter. +- An `ArgumentOutOfRangeException` from an invalid expiration passed to `Set` is not counted — that + operation never reaches NATS. +- A miss leaves the span status `Unset`. Only genuine failures set `Error`. +- **Naming:** there is no stable OpenTelemetry semantic convention for caches, so `nats.cache.*` is a + library-scoped prefix. `db.client.*` was rejected because NATS KV has no registered `db.system.name` + value and cache traffic would pollute database dashboards. If OTel later stabilizes a cache convention + it can be adopted alongside these names without breaking existing dashboards. + +### Interaction with `HybridCache` + +`nats.cache.*` measures **only the L2 (NATS) layer**. An L1 in-process hit produces no measurement at all, +so the hit ratio above is the hit ratio *of reads that reached NATS*, not of application cache lookups. + +`Microsoft.Extensions.Caching.Hybrid` (10.7.0) reports its own combined L1+L2 telemetry through +`EventCounters` on `HybridCacheEventSource`, not through a `Meter` — so `AddMeter("Microsoft.Extensions.Caching.Hybrid")` +yields nothing, and an `EventListener` is required for the L1 view. + +`NATS.Client.Core` publishes its own `ActivitySource` for messaging spans; those nest beneath the cache +spans when both sources are subscribed. + +### Tuning + +Omit `AddMeter`/`AddSource` to disable metrics or tracing independently. To keep hit-ratio data while +dropping the more expensive histogram: + +```csharp +metrics.AddView(NatsCacheTelemetryNames.OperationDurationInstrumentName, MetricStreamConfiguration.Drop); +``` + +The `nats.cache.misses` counter continues to record when the histogram is dropped. + ## Additional Resources * [ASP.NET Core Hybrid Cache Documentation](https://learn.microsoft.com/en-us/aspnet/core/performance/caching/hybrid?view=aspnetcore-10.0) * [NATS .NET Client Documentation](https://nats-io.github.io/nats.net/api/NATS.Client.Core.NatsOpts.html) +* [.NET Metrics Documentation](https://learn.microsoft.com/en-us/dotnet/core/diagnostics/metrics) +* [OpenTelemetry .NET Documentation](https://opentelemetry.io/docs/languages/dotnet/) diff --git a/src/NatsDistributedCache/NatsCache.cs b/src/NatsDistributedCache/NatsCache.cs index 82e8d19..18eecea 100644 --- a/src/NatsDistributedCache/NatsCache.cs +++ b/src/NatsDistributedCache/NatsCache.cs @@ -1,4 +1,5 @@ using System.Buffers; +using System.Diagnostics.Metrics; using Microsoft.Extensions.Caching.Distributed; using Microsoft.Extensions.Logging; using Microsoft.Extensions.Logging.Abstractions; @@ -44,6 +45,7 @@ public partial class NatsCache : IBufferDistributedCache private readonly string _keyPrefix; private readonly ILogger _logger; private readonly INatsConnection _natsConnection; + private readonly Lazy _telemetry; private Lazy> _lazyKvStore; public NatsCache( @@ -65,6 +67,14 @@ public NatsCache( _natsConnection = natsConnection; _logger = logger ?? NullLogger.Instance; _keyEncoder = keyEncoder ?? new NatsCacheKeyEncoder(); + + // Built lazily because the factory reads MeterFactory, an init-only property that is assigned after + // this constructor body runs. Lazy (rather than a ??= on a volatile field) so a startup race cannot + // create a second set of Instruments that get published to listeners but never recorded to. + var recordCacheKeys = options.Telemetry.RecordCacheKeys; + _telemetry = new Lazy( + () => new NatsCacheTelemetry(MeterFactory, _bucketName, recordCacheKeys), + LazyThreadSafetyMode.ExecutionAndPublication); } // The clock used for all expiration calculations. Defaults to TimeProvider.System; the DI @@ -72,6 +82,14 @@ public NatsCache( // (for example, FakeTimeProvider in tests). Injected via init to keep the constructor unchanged. internal TimeProvider TimeProvider { get; init; } = TimeProvider.System; + // The IMeterFactory used to create the cache's Meter, resolved from DI when present. Injected via init + // (like TimeProvider above) to keep the public constructor unchanged. When absent — direct construction, + // or a container without AddMetrics() — telemetry falls back to a process-wide static Meter of the same + // name, so subscribers see identical instruments either way. + internal IMeterFactory? MeterFactory { get; init; } + + private NatsCacheTelemetry Telemetry => _telemetry.Value; + /// public void Set(string key, byte[] value, DistributedCacheEntryOptions options) => SetAsync(key, value, options).GetAwaiter().GetResult(); @@ -83,9 +101,16 @@ public async Task SetAsync( DistributedCacheEntryOptions options, CancellationToken token = default) { + // GetTtl throws ArgumentOutOfRangeException for caller-supplied bad expirations. The scope opens + // after it deliberately: that is a caller bug that never reaches NATS, so counting it would fire the + // error-rate alert on an operation that was never attempted and inject a ~0s latency sample. var ttl = GetTtl(options); var entry = CreateCacheEntry(value, options); + // The single terminal implementation for all four Set entry points. Set(byte[]), Set(ReadOnlySequence), + // and SetAsync(ReadOnlySequence) delegate here and are deliberately left uninstrumented, so the + // three-deep Set(ReadOnlySequence) chain still records exactly one measurement. + var scope = NatsCacheOperationScope.Start(Telemetry, TimeProvider, CacheOperation.Set, key, token); try { var kvStore = await GetKvStore().ConfigureAwait(false); @@ -97,9 +122,14 @@ public async Task SetAsync( } catch (Exception ex) { + scope.SetError(ex); LogException(ex); throw; } + finally + { + scope.Complete(); + } } /// @@ -123,15 +153,25 @@ public async ValueTask SetAsync( /// public async Task RemoveAsync(string key, CancellationToken token = default) { + // Instrumented here rather than in RemoveCoreAsync, which is also called from GetAndRefreshAsync's + // absolute-expiry eviction path. Instrumenting the core would emit a phantom operation=remove for + // every expired read — inflating remove rate and nesting a bogus remove span inside a get. The + // eviction's latency correctly lands inside the enclosing get instead, because the caller waited. + var scope = NatsCacheOperationScope.Start(Telemetry, TimeProvider, CacheOperation.Remove, key, token); try { await RemoveCoreAsync(key, null, token).ConfigureAwait(false); } catch (Exception ex) { + scope.SetError(ex); LogException(ex); throw; } + finally + { + scope.Complete(); + } } /// @@ -142,7 +182,7 @@ public async Task RefreshAsync(string key, CancellationToken token = default) { try { - await GetAndRefreshAsync(key, token).ConfigureAwait(false); + await GetAndRefreshAsync(key, CacheOperation.Refresh, token).ConfigureAwait(false); } catch (Exception ex) { @@ -159,7 +199,7 @@ public async Task RefreshAsync(string key, CancellationToken token = default) { try { - return await GetAndRefreshAsync(key, token).ConfigureAwait(false); + return await GetAndRefreshAsync(key, CacheOperation.Get, token).ConfigureAwait(false); } catch (Exception ex) { @@ -180,7 +220,10 @@ public async ValueTask TryGetAsync( { try { - var result = await GetAndRefreshAsync(key, token).ConfigureAwait(false); + // Reports as operation=get, not a distinct operation: the IBufferWriter overload is a zero-copy + // detail, and merging it keeps hit ratio computed over all read paths — which matters because + // HybridCache drives its L2 reads exclusively through this method. + var result = await GetAndRefreshAsync(key, CacheOperation.Get, token).ConfigureAwait(false); if (result != null) { destination.Write(result); @@ -402,89 +445,113 @@ private Lazy> CreateLazyKvStore() => private Task GetKvStore() => _lazyKvStore.Value; - private async Task GetAndRefreshAsync(string key, CancellationToken token) + // The shared read core for Get, TryGet, and Refresh (and their sync overloads). Instrumented here + // rather than in the three public methods so that TryGetAsync's swallowed failures are still recorded + // as errors — the scope closes before the exception reaches TryGetAsync's catch — and so no read path + // can be counted twice. + private async Task GetAndRefreshAsync(string key, CacheOperation operation, CancellationToken token) { - var encodedKey = GetEncodedKey(key); - var kvStore = await GetKvStore().ConfigureAwait(false); + var scope = NatsCacheOperationScope.Start(Telemetry, TimeProvider, operation, key, token); try { - var natsResult = await kvStore - .TryGetEntryAsync(encodedKey, serializer: CacheEntrySerializer, cancellationToken: token) - .ConfigureAwait(false); - if (!natsResult.Success) + // GetKvStore is inside the scope so first-use connect and bucket-creation failures are recorded + // as errors too. This does not change which exceptions propagate. + var encodedKey = GetEncodedKey(key); + var kvStore = await GetKvStore().ConfigureAwait(false); + try { - return null; - } + var natsResult = await kvStore + .TryGetEntryAsync(encodedKey, serializer: CacheEntrySerializer, cancellationToken: token) + .ConfigureAwait(false); + if (!natsResult.Success) + { + scope.SetMiss(CacheMissReason.NotFound); + return null; + } - var kvEntry = natsResult.Value; - if (kvEntry.Value == null) - { - // Present entry whose bytes we cannot deserialize: a legacy JSON envelope from a - // pre-binary release, or genuine corruption. Intended behavior is to treat it as a - // cache miss and leave the entry in place. It self-heals when the key is next written - // (Set overwrites unconditionally), and any TTL'd entry is reaped by NATS. We - // deliberately do not evict it (an older node must not delete entries written in a - // newer format during a rolling deploy) nor throw (a cache should degrade to a miss, - // not fail the caller's operation). Logged at Debug to aid diagnosis without flooding - // logs during a JSON->binary migration, when every legacy key transiently lands here. - LogUndeserializableEntry(key); - return null; - } + var kvEntry = natsResult.Value; + if (kvEntry.Value == null) + { + // Present entry whose bytes we cannot deserialize: a legacy JSON envelope from a + // pre-binary release, or genuine corruption. Intended behavior is to treat it as a + // cache miss and leave the entry in place. It self-heals when the key is next written + // (Set overwrites unconditionally), and any TTL'd entry is reaped by NATS. We + // deliberately do not evict it (an older node must not delete entries written in a + // newer format during a rolling deploy) nor throw (a cache should degrade to a miss, + // not fail the caller's operation). Logged at Debug to aid diagnosis without flooding + // logs during a JSON->binary migration, when every legacy key transiently lands here. + LogUndeserializableEntry(key); + scope.SetMiss(CacheMissReason.Undeserializable); + return null; + } + + // Check absolute expiration + if (IsAbsolutelyExpired(kvEntry.Value)) + { + // NatsKVWrongLastRevisionException is caught below + var natsDeleteOpts = new NatsKVDeleteOpts { Revision = kvEntry.Revision }; + await RemoveCoreAsync(key, natsDeleteOpts, token).ConfigureAwait(false); + scope.SetMiss(CacheMissReason.Expired); + return null; + } - // Check absolute expiration - if (IsAbsolutelyExpired(kvEntry.Value)) + await UpdateEntryExpirationAsync(kvEntry).ConfigureAwait(false); + scope.SetHit(); + return kvEntry.Value.Data; + } + catch (NatsKVWrongLastRevisionException) { - // NatsKVWrongLastRevisionException is caught below - var natsDeleteOpts = new NatsKVDeleteOpts { Revision = kvEntry.Revision }; - await RemoveCoreAsync(key, natsDeleteOpts, token).ConfigureAwait(false); + // Someone else updated it; that's fine, we'll get the latest version next time + scope.SetMiss(CacheMissReason.RevisionConflict); return null; } - await UpdateEntryExpirationAsync(kvEntry).ConfigureAwait(false); - return kvEntry.Value.Data; - } - catch (NatsKVWrongLastRevisionException) - { - // Someone else updated it; that's fine, we'll get the latest version next time - return null; - } - - // Local Functions - async Task UpdateEntryExpirationAsync(NatsKVEntry kvEntry) - { - if (kvEntry.Value?.SlidingExpirationTicks == null) + // Local Functions + async Task UpdateEntryExpirationAsync(NatsKVEntry kvEntry) { - return; - } - - // If we have a sliding expiration, use it as the TTL - var ttl = TimeSpan.FromTicks(kvEntry.Value.SlidingExpirationTicks.Value); + if (kvEntry.Value?.SlidingExpirationTicks == null) + { + return; + } - // If we also have an absolute expiration, make sure we don't exceed it - if (kvEntry.Value.AbsoluteExpiration != null) - { - var remainingTime = kvEntry.Value.AbsoluteExpiration.Value - TimeProvider.GetUtcNow(); + // If we have a sliding expiration, use it as the TTL + var ttl = TimeSpan.FromTicks(kvEntry.Value.SlidingExpirationTicks.Value); - // Use the minimum of sliding window or remaining absolute time - if (remainingTime > TimeSpan.Zero && remainingTime < ttl) + // If we also have an absolute expiration, make sure we don't exceed it + if (kvEntry.Value.AbsoluteExpiration != null) { - ttl = remainingTime; + var remainingTime = kvEntry.Value.AbsoluteExpiration.Value - TimeProvider.GetUtcNow(); + + // Use the minimum of sliding window or remaining absolute time + if (remainingTime > TimeSpan.Zero && remainingTime < ttl) + { + ttl = remainingTime; + } } - } - if (ttl > TimeSpan.Zero) - { - // Use optimistic concurrency control with the last revision - // todo: remove cast after https://github.com/nats-io/nats.net/pull/852 is released - await kvStore.UpdateWithTtlAsync( - encodedKey, - kvEntry.Value, - kvEntry.Revision, - ttl, - serializer: CacheEntrySerializer, - cancellationToken: token).ConfigureAwait(false); + if (ttl > TimeSpan.Zero) + { + // Use optimistic concurrency control with the last revision + // todo: remove cast after https://github.com/nats-io/nats.net/pull/852 is released + await kvStore.UpdateWithTtlAsync( + encodedKey, + kvEntry.Value, + kvEntry.Revision, + ttl, + serializer: CacheEntrySerializer, + cancellationToken: token).ConfigureAwait(false); + } } } + catch (Exception ex) + { + scope.SetError(ex); + throw; + } + finally + { + scope.Complete(); + } } private async Task RemoveCoreAsync( diff --git a/src/NatsDistributedCache/NatsCacheOperationScope.cs b/src/NatsDistributedCache/NatsCacheOperationScope.cs new file mode 100644 index 0000000..c2391c3 --- /dev/null +++ b/src/NatsDistributedCache/NatsCacheOperationScope.cs @@ -0,0 +1,226 @@ +using System.Diagnostics; + +namespace CodeCargo.Nats.DistributedCache; + +// Measures one logical cache operation, emitting a duration histogram sample, a misses counter increment, +// and a client span. +// +// A plain (non-ref) mutable struct so it can live as a local across awaits: it is hoisted into the async +// state machine that is already heap-allocated for these methods, rather than allocating on its own. +// +// Completed via an explicit try/finally { scope.Complete(); } rather than IDisposable + using, because the +// struct is mutated by SetHit/SetMiss/SetError and `using` on a struct has by-value capture semantics that +// are easy to get subtly wrong. +internal struct NatsCacheOperationScope +{ + private NatsCacheTelemetry? _telemetry; + private Activity? _activity; + private TimeProvider? _timeProvider; + private CancellationToken _token; + private bool _durationEnabled; + private long _startTimestamp; + private string _operation; + private string _result; + private string? _missReason; + private string? _errorType; + + // Opens a scope. When nothing is listening this is two volatile field reads and a zeroed struct: no + // timestamp, no TagList, no Activity, no allocation. Taking the timestamp only when the histogram is + // enabled is the load-bearing detail — Stopwatch.GetTimestamp() is a ~15-25ns clock_gettime call and + // would otherwise dominate the disabled path. + // + // The caller's token is captured so SetError can tell cooperative cancellation apart from a failure + // that merely surfaced as an OperationCanceledException (see SetError). + internal static NatsCacheOperationScope Start( + NatsCacheTelemetry telemetry, + TimeProvider timeProvider, + CacheOperation operation, + string key, + CancellationToken token) + { + var scope = default(NatsCacheOperationScope); + + // Gated on either instrument, not just the histogram: dropping the duration histogram via an OTel + // View is a documented way to cut cost, and doing so must not silently take the misses counter + // with it. The timestamp is still taken only for the histogram (see below). + var durationEnabled = telemetry.OperationDuration.Enabled; + var metricsEnabled = durationEnabled || telemetry.Misses.Enabled; + var activity = NatsCacheTelemetry.ActivitySource.HasListeners() + ? NatsCacheTelemetry.ActivitySource.StartActivity( + telemetry.SpanName(operation), + ActivityKind.Client) + : null; + + if (!metricsEnabled && activity is null) + { + return scope; + } + + scope._telemetry = telemetry; + scope._timeProvider = timeProvider; + scope._token = token; + scope._operation = TelemetryTags.Name(operation); + scope._result = TelemetryTags.ResultOk; + scope._activity = activity; + + // A dedicated flag rather than testing the timestamp against zero: a TimeProvider is caller-supplied + // (NatsCache resolves one from DI), and one whose clock origin is zero would make a legitimate + // timestamp indistinguishable from "never taken", silently dropping every duration sample. + scope._durationEnabled = durationEnabled; + scope._startTimestamp = durationEnabled ? timeProvider.GetTimestamp() : 0L; + + if (activity is { IsAllDataRequested: true }) + { + activity.SetTag(TelemetryTags.Operation, scope._operation); + activity.SetTag(TelemetryTags.Bucket, telemetry.BucketName); + + // Span attribute only, and opt-in: cache keys routinely embed user or tenant identifiers. The + // key is never applied to metrics under any setting — it is an unbounded dimension. + if (telemetry.RecordCacheKeys) + { + activity.SetTag(TelemetryTags.Key, key); + } + } + + return scope; + } + + internal void SetHit() => _result = TelemetryTags.ResultHit; + + internal void SetMiss(CacheMissReason reason) + { + _result = TelemetryTags.ResultMiss; + _missReason = TelemetryTags.Name(reason); + } + + internal void SetError(Exception exception) + { + // Only the caller's own cancellation is reported as `cancelled`; everything else is an error, even + // when it surfaces as an OperationCanceledException. NATS request timeouts and internal token + // cancellations arrive as TaskCanceledException with the caller's token unsignalled, and those are + // genuine failures — TryGetAsync already draws this exact line with `when + // (token.IsCancellationRequested)` before logging the rest at Warning. Classifying them as + // `cancelled` would hide real outages from the error rate, because callers are told they can + // exclude `cancelled` from alerting. + if (exception is OperationCanceledException && _token.IsCancellationRequested) + { + _result = TelemetryTags.ResultCancelled; + return; + } + + _result = TelemetryTags.ResultError; + _errorType = exception.GetType().FullName ?? exception.GetType().Name; + } + + internal void Complete() + { + if (_telemetry is null) + { + return; + } + + // Telemetry must never break the operation it measures. Complete() is always called from a finally + // block, so an exception escaping here would replace the in-flight cache exception with a bogus one + // — or fail an operation that actually succeeded. Meter and ActivitySource invoke listener callbacks + // (exporters, third-party listeners) without guarding them, so a badly-behaved subscriber really can + // throw into this frame. Each stage is isolated so one failing subscriber cannot suppress the other. + try + { + RecordMetrics(); + } + catch (Exception) + { + // Swallowed by design; see above. Our own faults here are caught by the telemetry test suite. + } + + try + { + StopActivity(); + } + catch (Exception) + { + // Swallowed by design; see above. + } + } + + private void RecordMetrics() + { + if (_durationEnabled) + { + var tags = default(TagList); + tags.Add(TelemetryTags.Operation, _operation); + tags.Add(TelemetryTags.Bucket, _telemetry!.BucketName); + tags.Add(TelemetryTags.Result, _result); + if (_errorType is not null) + { + tags.Add(TelemetryTags.ErrorType, _errorType); + } + + // TagList holds 8 tags inline, so at 4 it never spills to an array, and every value is an + // interned const string or the cache's own bucket name, so passing them as object? never boxes. + _telemetry.OperationDuration.Record(_timeProvider!.GetElapsedTime(_startTimestamp).TotalSeconds, in tags); + } + + // Recorded independently of the histogram above, so subscribing to only the misses counter (or + // dropping the histogram with a View) still yields miss data. Add on a disabled instrument is a + // cheap no-op, so no extra guard is needed. + // + // The reason dimension lives on this counter and never on the histogram: a 4-valued tag would + // multiply the histogram's bucket arrays by 4 for a dimension nobody correlates with latency. + if (_missReason is not null) + { + var missTags = default(TagList); + missTags.Add(TelemetryTags.Operation, _operation); + missTags.Add(TelemetryTags.Bucket, _telemetry!.BucketName); + missTags.Add(TelemetryTags.MissReason, _missReason); + _telemetry.Misses.Add(1, in missTags); + } + } + + private void StopActivity() + { + if (_activity is null) + { + return; + } + + try + { + if (_activity.IsAllDataRequested) + { + _activity.SetTag(TelemetryTags.Result, _result); + if (_missReason is not null) + { + _activity.SetTag(TelemetryTags.MissReason, _missReason); + } + + if (_errorType is not null) + { + _activity.SetTag(TelemetryTags.ErrorType, _errorType); + + // Error status only on a genuine failure. A miss is a normal outcome and stays Unset — + // marking misses as errors makes every cold cache look like an outage in Jaeger/Tempo. + // Ok is never set; that is the caller's call to make, not a library's. + _activity.SetStatus(ActivityStatusCode.Error, _errorType); + } + } + } + catch (Exception) + { + // Tagging failed; the activity must still be stopped below. + } + + try + { + _activity.Dispose(); + } + catch (Exception) + { + // Activity.Stop notifies ActivityStopped subscribers *before* restoring Activity.Current, so a + // throwing subscriber leaves Current pointing at the activity we just stopped. Every later span + // on this execution context would then be parented under a finished span, and the leak persists + // for the lifetime of the async flow. Restore the parent ourselves. + Activity.Current = _activity.Parent; + } + } +} diff --git a/src/NatsDistributedCache/NatsCacheOptions.cs b/src/NatsDistributedCache/NatsCacheOptions.cs index 67e95b8..798fd7a 100644 --- a/src/NatsDistributedCache/NatsCacheOptions.cs +++ b/src/NatsDistributedCache/NatsCacheOptions.cs @@ -57,6 +57,18 @@ public class NatsCacheOptions : IOptions /// public Func? ConfigureBucketOnCreate { get; set; } + /// + /// Telemetry configuration. Metrics and traces are inert until a listener subscribes to the meter or + /// activity source named by , so these options tune what is + /// emitted rather than whether telemetry is enabled. + /// + /// + /// Get-only so it can never be null: configure it in place + /// (options.Telemetry.RecordCacheKeys = true). Configuration binding populates get-only + /// complex properties by binding into the existing instance, so Bind still works. + /// + public NatsCacheTelemetryOptions Telemetry { get; } = new(); + NatsCacheOptions IOptions.Value => this; } } diff --git a/src/NatsDistributedCache/NatsCacheTelemetry.cs b/src/NatsDistributedCache/NatsCacheTelemetry.cs new file mode 100644 index 0000000..74c297b --- /dev/null +++ b/src/NatsDistributedCache/NatsCacheTelemetry.cs @@ -0,0 +1,166 @@ +using System.Diagnostics; +using System.Diagnostics.Metrics; + +namespace CodeCargo.Nats.DistributedCache; + +// The logical cache operation a telemetry scope covers. Deliberately coarser than the public API surface: +// every read path (Get, TryGet, and their sync overloads) reports as Get, so hit ratio is computed over +// all reads. TryGet's IBufferWriter overload is a zero-copy detail, not a different cache operation. +internal enum CacheOperation +{ + Get, + Set, + Refresh, + Remove, +} + +// Why a read returned no data. A closed set of four values, one per `return null` site in +// GetAndRefreshAsync, so it is safe as a metric dimension. Never derived from data or exception text. +internal enum CacheMissReason +{ + NotFound, + Expired, + Undeserializable, + RevisionConflict, +} + +// Every tag key and tag value, as compile-time constants. Keeping them all in one place means metric +// cardinality is provable by inspecting this class, and no string is allocated at record time. +internal static class TelemetryTags +{ + internal const string Operation = "nats.cache.operation"; + internal const string Result = "nats.cache.result"; + internal const string MissReason = "nats.cache.miss.reason"; + internal const string Bucket = "nats.cache.bucket"; + internal const string Key = "nats.cache.key"; + + // The stable OpenTelemetry registry attribute, deliberately reused rather than namespaced under + // nats.cache.* so standard cross-library error drilldowns work against our data unmodified. + internal const string ErrorType = "error.type"; + + internal const string OperationGet = "get"; + internal const string OperationSet = "set"; + internal const string OperationRefresh = "refresh"; + internal const string OperationRemove = "remove"; + + internal const string ResultHit = "hit"; + internal const string ResultMiss = "miss"; + internal const string ResultOk = "ok"; + internal const string ResultError = "error"; + internal const string ResultCancelled = "cancelled"; + + internal const string MissReasonNotFound = "not_found"; + internal const string MissReasonExpired = "expired"; + internal const string MissReasonUndeserializable = "undeserializable"; + internal const string MissReasonRevisionConflict = "revision_conflict"; + + // Every member is listed explicitly and the fallback throws rather than returning a plausible value: + // a silent default would let a newly added CacheOperation be mislabelled as an existing one, which is + // invisible in a dashboard. The `_` arm exists only to satisfy exhaustiveness checking. + internal static string Name(CacheOperation operation) => operation switch + { + CacheOperation.Get => OperationGet, + CacheOperation.Set => OperationSet, + CacheOperation.Refresh => OperationRefresh, + CacheOperation.Remove => OperationRemove, + _ => throw new ArgumentOutOfRangeException(nameof(operation), operation, null), + }; + + internal static string Name(CacheMissReason reason) => reason switch + { + CacheMissReason.NotFound => MissReasonNotFound, + CacheMissReason.Expired => MissReasonExpired, + CacheMissReason.Undeserializable => MissReasonUndeserializable, + CacheMissReason.RevisionConflict => MissReasonRevisionConflict, + _ => throw new ArgumentOutOfRangeException(nameof(reason), reason, null), + }; +} + +// Per-cache-instance instrument bundle. +// +// Instrument naming: there is no stable OpenTelemetry semantic convention for caches, so nats.cache.* is a +// library-scoped prefix (the pattern FusionCache uses with fusioncache.*). db.client.* was considered and +// rejected: NATS KV has no registered db.system.name value, the DB conventions cannot express a cache +// hit/miss, and emitting it would merge cache traffic into every user's database dashboards and SLOs. A +// bare cache.* was rejected as squatting on a namespace OTel may later stabilize with different semantics. +// Either convention can be added alongside nats.cache.* later without breaking existing dashboards. +internal sealed class NatsCacheTelemetry +{ + // Instrumentation scope version reported to listeners. Must be declared before the fields below, whose + // initializers consume it — static field initializers run in textual order. + internal static readonly string TelemetryVersion = + typeof(NatsCacheTelemetry).Assembly.GetName().Version?.ToString() ?? "0.0.0"; + + // The ActivitySource is static while the Meter is per-instance, and that asymmetry is deliberate. + // There is no IActivitySourceFactory in the BCL, and traces have no aggregation-identity problem: an + // ActivityListener filters by source *name* and each Activity is sampled and exported independently. + // Metrics do — MeterProvider aggregates by meter identity, so two hosts in one process need distinct + // Meter instances to avoid cross-contamination. Please don't "fix" this into symmetry. + internal static readonly ActivitySource ActivitySource = + new(NatsCacheTelemetryNames.ActivitySourceName, TelemetryVersion); + + // Fallback for direct (non-DI) construction, and for DI containers without AddMetrics(). Process-wide + // and never disposed; subscribers cannot distinguish it from a factory-created meter of the same name. + private static readonly Meter SharedMeter = new(NatsCacheTelemetryNames.MeterName, TelemetryVersion); + + private readonly string _getSpanName; + private readonly string _setSpanName; + private readonly string _refreshSpanName; + private readonly string _removeSpanName; + + internal NatsCacheTelemetry(IMeterFactory? meterFactory, string bucketName, bool recordCacheKeys) + { + // Never disposed either way: a factory-created meter is owned by the container, and the shared one + // lives for the process. This is what keeps NatsCache out of IDisposable. + // + // IMeterFactory.Create caches by name+version, so two NatsCache instances sharing a container get + // the same Meter and each register their own Instrument objects under the same identity. That is + // benign: consumers aggregate by instrument identity plus tags, and every instrument here carries + // nats.cache.bucket, so the two caches still resolve to distinct series. + var meter = meterFactory?.Create(NatsCacheTelemetryNames.MeterName, TelemetryVersion) ?? SharedMeter; + + BucketName = bucketName; + RecordCacheKeys = recordCacheKeys; + + OperationDuration = meter.CreateHistogram( + NatsCacheTelemetryNames.OperationDurationInstrumentName, + unit: "s", + description: "Duration of NATS distributed cache operations."); + + // No companion operations counter: the histogram's count already yields operation rate, hit ratio, + // and error rate via the result tag, and a counter duplicating a histogram's count is an OTel + // anti-pattern (the HTTP semantic conventions deleted exactly such a counter). + Misses = meter.CreateCounter( + NatsCacheTelemetryNames.MissesInstrumentName, + unit: "{miss}", + description: "Number of NATS distributed cache read misses, by reason."); + + // Span names are precomputed per instance so the traced path allocates no strings. Passed to + // StartActivity rather than assigned to DisplayName afterwards, because samplers see the name given + // to StartActivity. + _getSpanName = $"{TelemetryTags.OperationGet} {bucketName}"; + _setSpanName = $"{TelemetryTags.OperationSet} {bucketName}"; + _refreshSpanName = $"{TelemetryTags.OperationRefresh} {bucketName}"; + _removeSpanName = $"{TelemetryTags.OperationRemove} {bucketName}"; + } + + internal Histogram OperationDuration { get; } + + internal Counter Misses { get; } + + internal string BucketName { get; } + + internal bool RecordCacheKeys { get; } + + // Resolved by a switch rather than indexing an array by enum ordinal: a positional array silently + // mislabels every span if a CacheOperation member is ever inserted or reordered, and it would drift + // out of sync with TelemetryTags.Name, which supplies the matching metric tag. + internal string SpanName(CacheOperation operation) => operation switch + { + CacheOperation.Get => _getSpanName, + CacheOperation.Set => _setSpanName, + CacheOperation.Refresh => _refreshSpanName, + CacheOperation.Remove => _removeSpanName, + _ => throw new ArgumentOutOfRangeException(nameof(operation), operation, null), + }; +} diff --git a/src/NatsDistributedCache/NatsCacheTelemetryNames.cs b/src/NatsDistributedCache/NatsCacheTelemetryNames.cs new file mode 100644 index 0000000..433648d --- /dev/null +++ b/src/NatsDistributedCache/NatsCacheTelemetryNames.cs @@ -0,0 +1,43 @@ +namespace CodeCargo.Nats.DistributedCache; + +/// +/// Well-known meter, activity source, and instrument names emitted by . +/// +/// +/// +/// Telemetry is emitted through System.Diagnostics.Metrics and System.Diagnostics.ActivitySource +/// only; this package takes no dependency on OpenTelemetry. Nothing is measured, timed, or allocated until a +/// listener subscribes, so registering these names is the opt-in: +/// +/// +/// builder.Services.AddOpenTelemetry() +/// .WithMetrics(metrics => metrics.AddMeter(NatsCacheTelemetryNames.MeterName)) +/// .WithTracing(tracing => tracing.AddSource(NatsCacheTelemetryNames.ActivitySourceName)); +/// +/// +/// These are compile-time constants, so referencing them does not initialize the meter. +/// +/// +public static class NatsCacheTelemetryNames +{ + /// + /// Name of the Meter that publishes the cache instruments. Pass to AddMeter. + /// + public const string MeterName = "CodeCargo.Nats.DistributedCache"; + + /// + /// Name of the ActivitySource that publishes cache spans. Pass to AddSource. + /// + public const string ActivitySourceName = "CodeCargo.Nats.DistributedCache"; + + /// + /// Histogram of cache operation durations, in seconds. Its count also yields operation rate, hit ratio, + /// and error rate via the nats.cache.result tag. + /// + public const string OperationDurationInstrumentName = "nats.cache.operation.duration"; + + /// + /// Counter of cache read misses, broken down by nats.cache.miss.reason. + /// + public const string MissesInstrumentName = "nats.cache.misses"; +} diff --git a/src/NatsDistributedCache/NatsCacheTelemetryOptions.cs b/src/NatsDistributedCache/NatsCacheTelemetryOptions.cs new file mode 100644 index 0000000..d3e3e51 --- /dev/null +++ b/src/NatsDistributedCache/NatsCacheTelemetryOptions.cs @@ -0,0 +1,23 @@ +namespace CodeCargo.Nats.DistributedCache; + +/// +/// Telemetry configuration for . +/// +/// +/// Telemetry is inert until a listener subscribes to the meter or activity source named by +/// ; these options only tune what is emitted once something is +/// listening, they are not the opt-in switch. +/// +public class NatsCacheTelemetryOptions +{ + /// + /// When , the unencoded cache key is added to cache spans as the + /// nats.cache.key attribute. Defaults to . + /// + /// + /// Cache keys frequently embed user, tenant, or session identifiers, so they are omitted by default. + /// This setting affects spans only — the key is never applied to metrics under any setting, because + /// it is an unbounded dimension that would break metric cardinality. + /// + public bool RecordCacheKeys { get; set; } +} diff --git a/src/NatsDistributedCache/NatsDistributedCache.csproj b/src/NatsDistributedCache/NatsDistributedCache.csproj index 02772af..3420a02 100644 --- a/src/NatsDistributedCache/NatsDistributedCache.csproj +++ b/src/NatsDistributedCache/NatsDistributedCache.csproj @@ -32,6 +32,10 @@ + + diff --git a/src/NatsDistributedCache/NatsDistributedCacheExtensions.cs b/src/NatsDistributedCache/NatsDistributedCacheExtensions.cs index f4196c9..fff7e0a 100644 --- a/src/NatsDistributedCache/NatsDistributedCacheExtensions.cs +++ b/src/NatsDistributedCache/NatsDistributedCacheExtensions.cs @@ -1,3 +1,4 @@ +using System.Diagnostics.Metrics; using Microsoft.Extensions.Caching.Distributed; using Microsoft.Extensions.Caching.Hybrid; using Microsoft.Extensions.DependencyInjection; @@ -39,9 +40,16 @@ public static IServiceCollection AddNatsDistributedCache( var keyEncoder = sp.GetService(); var timeProvider = sp.GetService(); + // GetService, not GetRequiredService: IMeterFactory is registered by AddMetrics(), which the + // Generic Host and AddOpenTelemetry().WithMetrics(...) call for you but a bare ServiceCollection + // does not. Requiring it would break every non-Host consumer; NatsCache falls back to a + // process-wide static Meter of the same name when this is null. + var meterFactory = sp.GetService(); + return new NatsCache(optionsAccessor, natsConnection, logger: logger, keyEncoder: keyEncoder) { TimeProvider = timeProvider ?? TimeProvider.System, + MeterFactory = meterFactory, }; }); diff --git a/src/NatsDistributedCache/packages.linux-arm64.lock.json b/src/NatsDistributedCache/packages.linux-arm64.lock.json index 6732dfa..91ac3b8 100644 --- a/src/NatsDistributedCache/packages.linux-arm64.lock.json +++ b/src/NatsDistributedCache/packages.linux-arm64.lock.json @@ -59,6 +59,12 @@ "StyleCop.Analyzers.Unstable": "1.2.0.556" } }, + "System.Diagnostics.DiagnosticSource": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "VzIU41Sb23Em98hDQc71LPwKTC72xkiG7lpCZaIkf84jBJW+ViaKPa24qqR4FPmj1N4vDWilzs6Dq5Om8aFj+Q==" + }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", "resolved": "10.0.300", @@ -181,6 +187,12 @@ "StyleCop.Analyzers.Unstable": "1.2.0.556" } }, + "System.Diagnostics.DiagnosticSource": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "VzIU41Sb23Em98hDQc71LPwKTC72xkiG7lpCZaIkf84jBJW+ViaKPa24qqR4FPmj1N4vDWilzs6Dq5Om8aFj+Q==" + }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", "resolved": "10.0.300", @@ -239,11 +251,6 @@ "resolved": "1.2.0.556", "contentHash": "zvn9Mqs/ox/83cpYPignI8hJEM2A93s2HkHs8HYMOAQW0PkampyoErAiIyKxgTLqbbad29HX/shv/6LGSjPJNQ==" }, - "System.Diagnostics.DiagnosticSource": { - "type": "Transitive", - "resolved": "10.0.9", - "contentHash": "VzIU41Sb23Em98hDQc71LPwKTC72xkiG7lpCZaIkf84jBJW+ViaKPa24qqR4FPmj1N4vDWilzs6Dq5Om8aFj+Q==" - }, "System.IO.Hashing": { "type": "Transitive", "resolved": "10.0.8", diff --git a/src/NatsDistributedCache/packages.linux-x64.lock.json b/src/NatsDistributedCache/packages.linux-x64.lock.json index 6732dfa..91ac3b8 100644 --- a/src/NatsDistributedCache/packages.linux-x64.lock.json +++ b/src/NatsDistributedCache/packages.linux-x64.lock.json @@ -59,6 +59,12 @@ "StyleCop.Analyzers.Unstable": "1.2.0.556" } }, + "System.Diagnostics.DiagnosticSource": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "VzIU41Sb23Em98hDQc71LPwKTC72xkiG7lpCZaIkf84jBJW+ViaKPa24qqR4FPmj1N4vDWilzs6Dq5Om8aFj+Q==" + }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", "resolved": "10.0.300", @@ -181,6 +187,12 @@ "StyleCop.Analyzers.Unstable": "1.2.0.556" } }, + "System.Diagnostics.DiagnosticSource": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "VzIU41Sb23Em98hDQc71LPwKTC72xkiG7lpCZaIkf84jBJW+ViaKPa24qqR4FPmj1N4vDWilzs6Dq5Om8aFj+Q==" + }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", "resolved": "10.0.300", @@ -239,11 +251,6 @@ "resolved": "1.2.0.556", "contentHash": "zvn9Mqs/ox/83cpYPignI8hJEM2A93s2HkHs8HYMOAQW0PkampyoErAiIyKxgTLqbbad29HX/shv/6LGSjPJNQ==" }, - "System.Diagnostics.DiagnosticSource": { - "type": "Transitive", - "resolved": "10.0.9", - "contentHash": "VzIU41Sb23Em98hDQc71LPwKTC72xkiG7lpCZaIkf84jBJW+ViaKPa24qqR4FPmj1N4vDWilzs6Dq5Om8aFj+Q==" - }, "System.IO.Hashing": { "type": "Transitive", "resolved": "10.0.8", diff --git a/src/NatsDistributedCache/packages.osx-arm64.lock.json b/src/NatsDistributedCache/packages.osx-arm64.lock.json index 6732dfa..91ac3b8 100644 --- a/src/NatsDistributedCache/packages.osx-arm64.lock.json +++ b/src/NatsDistributedCache/packages.osx-arm64.lock.json @@ -59,6 +59,12 @@ "StyleCop.Analyzers.Unstable": "1.2.0.556" } }, + "System.Diagnostics.DiagnosticSource": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "VzIU41Sb23Em98hDQc71LPwKTC72xkiG7lpCZaIkf84jBJW+ViaKPa24qqR4FPmj1N4vDWilzs6Dq5Om8aFj+Q==" + }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", "resolved": "10.0.300", @@ -181,6 +187,12 @@ "StyleCop.Analyzers.Unstable": "1.2.0.556" } }, + "System.Diagnostics.DiagnosticSource": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "VzIU41Sb23Em98hDQc71LPwKTC72xkiG7lpCZaIkf84jBJW+ViaKPa24qqR4FPmj1N4vDWilzs6Dq5Om8aFj+Q==" + }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", "resolved": "10.0.300", @@ -239,11 +251,6 @@ "resolved": "1.2.0.556", "contentHash": "zvn9Mqs/ox/83cpYPignI8hJEM2A93s2HkHs8HYMOAQW0PkampyoErAiIyKxgTLqbbad29HX/shv/6LGSjPJNQ==" }, - "System.Diagnostics.DiagnosticSource": { - "type": "Transitive", - "resolved": "10.0.9", - "contentHash": "VzIU41Sb23Em98hDQc71LPwKTC72xkiG7lpCZaIkf84jBJW+ViaKPa24qqR4FPmj1N4vDWilzs6Dq5Om8aFj+Q==" - }, "System.IO.Hashing": { "type": "Transitive", "resolved": "10.0.8", diff --git a/src/NatsDistributedCache/packages.win-x64.lock.json b/src/NatsDistributedCache/packages.win-x64.lock.json index 6732dfa..91ac3b8 100644 --- a/src/NatsDistributedCache/packages.win-x64.lock.json +++ b/src/NatsDistributedCache/packages.win-x64.lock.json @@ -59,6 +59,12 @@ "StyleCop.Analyzers.Unstable": "1.2.0.556" } }, + "System.Diagnostics.DiagnosticSource": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "VzIU41Sb23Em98hDQc71LPwKTC72xkiG7lpCZaIkf84jBJW+ViaKPa24qqR4FPmj1N4vDWilzs6Dq5Om8aFj+Q==" + }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", "resolved": "10.0.300", @@ -181,6 +187,12 @@ "StyleCop.Analyzers.Unstable": "1.2.0.556" } }, + "System.Diagnostics.DiagnosticSource": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "VzIU41Sb23Em98hDQc71LPwKTC72xkiG7lpCZaIkf84jBJW+ViaKPa24qqR4FPmj1N4vDWilzs6Dq5Om8aFj+Q==" + }, "Microsoft.Build.Tasks.Git": { "type": "Transitive", "resolved": "10.0.300", @@ -239,11 +251,6 @@ "resolved": "1.2.0.556", "contentHash": "zvn9Mqs/ox/83cpYPignI8hJEM2A93s2HkHs8HYMOAQW0PkampyoErAiIyKxgTLqbbad29HX/shv/6LGSjPJNQ==" }, - "System.Diagnostics.DiagnosticSource": { - "type": "Transitive", - "resolved": "10.0.9", - "contentHash": "VzIU41Sb23Em98hDQc71LPwKTC72xkiG7lpCZaIkf84jBJW+ViaKPa24qqR4FPmj1N4vDWilzs6Dq5Om8aFj+Q==" - }, "System.IO.Hashing": { "type": "Transitive", "resolved": "10.0.8", diff --git a/src/NatsHybridCacheExtensions/packages.linux-arm64.lock.json b/src/NatsHybridCacheExtensions/packages.linux-arm64.lock.json index 24977fc..ae7d0ba 100644 --- a/src/NatsHybridCacheExtensions/packages.linux-arm64.lock.json +++ b/src/NatsHybridCacheExtensions/packages.linux-arm64.lock.json @@ -309,7 +309,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } } diff --git a/src/NatsHybridCacheExtensions/packages.linux-x64.lock.json b/src/NatsHybridCacheExtensions/packages.linux-x64.lock.json index 24977fc..ae7d0ba 100644 --- a/src/NatsHybridCacheExtensions/packages.linux-x64.lock.json +++ b/src/NatsHybridCacheExtensions/packages.linux-x64.lock.json @@ -309,7 +309,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } } diff --git a/src/NatsHybridCacheExtensions/packages.osx-arm64.lock.json b/src/NatsHybridCacheExtensions/packages.osx-arm64.lock.json index 24977fc..ae7d0ba 100644 --- a/src/NatsHybridCacheExtensions/packages.osx-arm64.lock.json +++ b/src/NatsHybridCacheExtensions/packages.osx-arm64.lock.json @@ -309,7 +309,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } } diff --git a/src/NatsHybridCacheExtensions/packages.win-x64.lock.json b/src/NatsHybridCacheExtensions/packages.win-x64.lock.json index 24977fc..ae7d0ba 100644 --- a/src/NatsHybridCacheExtensions/packages.win-x64.lock.json +++ b/src/NatsHybridCacheExtensions/packages.win-x64.lock.json @@ -309,7 +309,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } } diff --git a/test/IntegrationTests/Cache/TelemetryTests.cs b/test/IntegrationTests/Cache/TelemetryTests.cs new file mode 100644 index 0000000..58aeca3 --- /dev/null +++ b/test/IntegrationTests/Cache/TelemetryTests.cs @@ -0,0 +1,395 @@ +using System.Buffers; +using System.Diagnostics; +using System.Diagnostics.Metrics; +using System.Text; +using CodeCargo.Nats.DistributedCache.TestUtils; +using CodeCargo.Nats.DistributedCache.TestUtils.Services.Diagnostics; +using CodeCargo.Nats.DistributedCache.TestUtils.Services.Logging; +using Microsoft.Extensions.Caching.Distributed; +using Microsoft.Extensions.Caching.Hybrid; +using Microsoft.Extensions.Diagnostics.Metrics.Testing; +using Microsoft.Extensions.Options; +using Microsoft.Extensions.Time.Testing; +using NATS.Net; + +namespace CodeCargo.Nats.DistributedCache.IntegrationTests.Cache; + +public class TelemetryTests : TestBase +{ + // A legacy JSON envelope from a pre-binary release: the first byte is '{' (0x7B), which never matches + // the binary FormatVersion, so the serializer returns null and the read is an undeserializable miss. + private static readonly byte[] LegacyJsonEntry = + Encoding.UTF8.GetBytes("{\"absexp\":null,\"sldexp\":null,\"data\":\"AQID\"}"); + + // Held explicitly rather than captured from a primary constructor parameter: capturing a value that is + // also passed to the base constructor warns under CS9107, and CI builds with warnings as errors. + private readonly NatsIntegrationFixture _fixture; + + public TelemetryTests(NatsIntegrationFixture fixture) + : base(fixture) => + _fixture = fixture; + + [Fact] + public async Task SetGetRemoveGetEmitsExpectedResultSequence() + { + var key = MethodKey(); + using var duration = CreateDurationCollector(); + using var misses = CreateMissesCollector(); + var token = TestContext.Current.CancellationToken; + + await DistributedCache.SetAsync(key, [1, 2, 3], new DistributedCacheEntryOptions(), token); + Assert.NotNull(await DistributedCache.GetAsync(key, token)); + await DistributedCache.RemoveAsync(key, token); + Assert.Null(await DistributedCache.GetAsync(key, token)); + + var results = duration.GetMeasurementSnapshot() + .Select(m => (Operation: m.Tags["nats.cache.operation"], Result: m.Tags["nats.cache.result"])) + .ToArray(); + Assert.Equal( + [("set", "ok"), ("get", "hit"), ("remove", "ok"), ("get", "miss")], + results); + + // Every duration sample is a real elapsed time in seconds, not a zero or a millisecond count. + Assert.All(duration.GetMeasurementSnapshot(), m => Assert.InRange(m.Value, 0d, 60d)); + + // The trailing miss is attributed to an absent key, and the hit contributes nothing to the counter. + var miss = Assert.Single(misses.GetMeasurementSnapshot()); + Assert.Equal(1, miss.Value); + Assert.Equal("get", miss.Tags["nats.cache.operation"]); + Assert.Equal("not_found", miss.Tags["nats.cache.miss.reason"]); + } + + [Fact] + public async Task ExpiredEntryReadTagsMissReasonExpiredAndRecordsNoRemoveOperation() + { + var key = MethodKey(); + var timeProvider = new FakeTimeProvider(); + await using var provider = BuildProvider(timeProvider); + var cache = provider.GetRequiredService(); + var meterFactory = provider.GetRequiredService(); + var token = TestContext.Current.CancellationToken; + + // A five-minute absolute expiration gives the NATS entry a five-minute real-time TTL, then the + // cache's own clock jumps past it. The entry is therefore still present in the bucket but + // absolutely expired, which is the only way to reach the `expired` branch deterministically. + await cache.SetAsync( + key, + [1, 2, 3], + new DistributedCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMinutes(5)), + token); + + using var duration = CreateDurationCollector(meterFactory); + using var misses = CreateMissesCollector(meterFactory); + timeProvider.Advance(TimeSpan.FromMinutes(10)); + + Assert.Null(await cache.GetAsync(key, token)); + + var miss = Assert.Single(misses.GetMeasurementSnapshot()); + Assert.Equal("expired", miss.Tags["nats.cache.miss.reason"]); + + // Regression guard for the seam choice: reading an absolutely-expired entry evicts it via + // RemoveCoreAsync, which is deliberately NOT instrumented. If instrumentation ever moves down to + // the core, every expired read would emit a phantom operation=remove, inflating remove rate and + // nesting a bogus remove span inside the get. + var measurement = Assert.Single(duration.GetMeasurementSnapshot()); + Assert.Equal("get", measurement.Tags["nats.cache.operation"]); + Assert.Equal("miss", measurement.Tags["nats.cache.result"]); + } + + [Fact] + public async Task UndeserializableEntryTagsMissReasonUndeserializable() + { + var key = MethodKey(); + var cache = CreateDirectCache(); + await WriteRawEntryAsync(key, LegacyJsonEntry); + using var misses = CreateFallbackMissesCollector(); + + Assert.Null(await cache.GetAsync(key, TestContext.Current.CancellationToken)); + + // Distinguishes a legacy/corrupt envelope from an absent key, which is the signal operators need + // to tell whether a JSON->binary rollout has drained. + var miss = Assert.Single(misses.GetMeasurementSnapshot()); + Assert.Equal("undeserializable", miss.Tags["nats.cache.miss.reason"]); + } + + [Fact] + public async Task BufferOverloadsRecordExactlyOneMeasurementEach() + { + var key = MethodKey(); + var bufferCache = (IBufferDistributedCache)DistributedCache; + using var duration = CreateDurationCollector(); + var token = TestContext.Current.CancellationToken; + + // These are precisely the two overloads HybridCache drives, and the two most at risk of double + // counting: Set(ReadOnlySequence) is three delegations deep, and TryGetAsync wraps the read core. + await bufferCache.SetAsync( + key, + new ReadOnlySequence(new byte[] { 1, 2, 3 }), + new DistributedCacheEntryOptions(), + token); + + var destination = new ArrayBufferWriter(); + Assert.True(await bufferCache.TryGetAsync(key, destination, token)); + + var results = duration.GetMeasurementSnapshot() + .Select(m => (Operation: m.Tags["nats.cache.operation"], Result: m.Tags["nats.cache.result"])) + .ToArray(); + Assert.Equal([("set", "ok"), ("get", "hit")], results); + } + + [Fact] + public void SyncOverloadsRecordExactlyOneMeasurementEach() + { + var key = MethodKey(); + using var duration = CreateDurationCollector(); + + // The sync wrappers delegate to the async implementations rather than carrying their own + // instrumentation, so each must still produce exactly one measurement. + DistributedCache.Set(key, [1, 2, 3], new DistributedCacheEntryOptions()); + Assert.NotNull(DistributedCache.Get(key)); + DistributedCache.Refresh(key); + DistributedCache.Remove(key); + + var results = duration.GetMeasurementSnapshot() + .Select(m => (Operation: m.Tags["nats.cache.operation"], Result: m.Tags["nats.cache.result"])) + .ToArray(); + Assert.Equal([("set", "ok"), ("get", "hit"), ("refresh", "hit"), ("remove", "ok")], results); + } + + [Fact] + public async Task SwallowedTryGetFailureRecordsErrorNotMiss() + { + var cache = CreateFailingCache(); + var destination = new ArrayBufferWriter(); + using var duration = CreateFallbackDurationCollector(); + using var misses = CreateFallbackMissesCollector(); + + Assert.False(await cache.TryGetAsync(MethodKey(), destination, TestContext.Current.CancellationToken)); + + // TryGet swallows the failure and returns false to honor the IBufferDistributedCache contract, but + // telemetry must not report it as a cache miss — that would make an outage look like a cold cache. + // Callers wanting the observed miss rate should compute miss + error. + var measurement = Assert.Single(duration.GetMeasurementSnapshot()); + Assert.Equal("get", measurement.Tags["nats.cache.operation"]); + Assert.Equal("error", measurement.Tags["nats.cache.result"]); + Assert.NotNull(measurement.Tags["error.type"]); + Assert.Empty(misses.GetMeasurementSnapshot()); + } + + [Fact] + public async Task HybridCacheL2OperationsEmitNatsCacheInstruments() + { + var key = MethodKey(); + var token = TestContext.Current.CancellationToken; + var options = new HybridCacheEntryOptions { Expiration = TimeSpan.FromMinutes(10) }; + + // HybridCache writes L2 through IBufferDistributedCache.SetAsync(ReadOnlySequence) — three + // delegations deep, and the chain most at risk of double counting. SetAsync is used rather than + // GetOrCreateAsync because the latter writes L2 in the background, which would race the assertion. + using (var duration = CreateDurationCollector()) + { + await HybridCache.SetAsync(key, "value", options, cancellationToken: token); + + // Asserts the count of writes rather than the full operation sequence: HybridCache may also + // read L2 as part of a write, and pinning its exact internal choreography would make this test + // fail on a HybridCache upgrade for no good reason. The property that matters here is that the + // three-deep ReadOnlySequence chain records one measurement, not two. + var write = Assert.Single( + duration.GetMeasurementSnapshot(), + m => Equals(m.Tags["nats.cache.operation"], "set")); + Assert.Equal("ok", write.Tags["nats.cache.result"]); + } + + // A second container has a cold L1, so its GetOrCreateAsync must fall through to L2 — exercising + // TryGetAsync(IBufferWriter), the read chain HybridCache uses exclusively. This also confirms + // AddNatsHybridCache inherits telemetry with no extra wiring. + await using var other = BuildProvider(); + var otherHybridCache = other.GetRequiredService(); + using var reads = CreateDurationCollector(other.GetRequiredService()); + + var value = await otherHybridCache.GetOrCreateAsync( + key, + _ => ValueTask.FromResult("factory-should-not-run"), + options, + cancellationToken: token); + + Assert.Equal("value", value); + + var read = Assert.Single( + reads.GetMeasurementSnapshot(), + m => Equals(m.Tags["nats.cache.operation"], "get")); + Assert.Equal("hit", read.Tags["nats.cache.result"]); + } + + [Fact] + public async Task CallerCancellationIsTaggedCancelledEndToEnd() + { + // Uses the real bucket so the store resolves; the pre-cancelled token then fails the read itself. + var cache = CreateDirectCache(); + using var duration = CreateFallbackDurationCollector(); + using var cts = new CancellationTokenSource(); + await cts.CancelAsync(); + + await Assert.ThrowsAnyAsync( + () => cache.GetAsync(MethodKey(), cts.Token)); + + // The caller's own cancellation is not a cache failure, so it must not land in the error rate. + var measurement = Assert.Single(duration.GetMeasurementSnapshot()); + Assert.Equal("cancelled", measurement.Tags["nats.cache.result"]); + Assert.DoesNotContain(measurement.Tags, tag => tag.Key == "error.type"); + } + + [Fact] + public async Task MissesAreRecordedWhenOnlyTheCounterIsSubscribed() + { + var key = MethodKey(); + + // Subscribe to the misses counter but NOT the duration histogram, mimicking a user who drops the + // histogram with an OTel View to cut cost. An earlier revision gated all metric work on the + // histogram being enabled, which silently produced zero miss data in exactly this configuration. + using var misses = CreateMissesCollector(); + + Assert.Null(await DistributedCache.GetAsync(key, TestContext.Current.CancellationToken)); + + var miss = Assert.Single(misses.GetMeasurementSnapshot()); + Assert.Equal(1, miss.Value); + Assert.Equal("not_found", miss.Tags["nats.cache.miss.reason"]); + } + + [Fact] + public async Task SeparateServiceProvidersHaveIsolatedMeters() + { + var token = TestContext.Current.CancellationToken; + await using var other = BuildProvider(); + using var thisProviderMetrics = CreateDurationCollector(); + using var otherProviderMetrics = CreateDurationCollector(other.GetRequiredService()); + + await DistributedCache.SetAsync(MethodKey(), [1], new DistributedCacheEntryOptions(), token); + + // This is the property that justifies resolving IMeterFactory instead of using a single static + // Meter: each container aggregates independently. With a static meter the second collector would + // observe the first provider's traffic, silently cross-contaminating any parallel test or any host + // that builds more than one container in a process. + Assert.Single(thisProviderMetrics.GetMeasurementSnapshot()); + Assert.Empty(otherProviderMetrics.GetMeasurementSnapshot()); + } + + [Fact] + public async Task ReadProducesOneClientSpanCarryingResultAndBucket() + { + var key = MethodKey(); + using var activities = new RecordingActivityListener(NatsCacheTelemetryNames.ActivitySourceName); + + Assert.Null(await DistributedCache.GetAsync(key, TestContext.Current.CancellationToken)); + + var activity = Assert.Single(activities.Activities); + Assert.Equal("get cache", activity.DisplayName); + Assert.Equal(ActivityKind.Client, activity.Kind); + Assert.Equal("get", activity.GetTagItem("nats.cache.operation")); + Assert.Equal("cache", activity.GetTagItem("nats.cache.bucket")); + Assert.Equal("miss", activity.GetTagItem("nats.cache.result")); + Assert.Equal("not_found", activity.GetTagItem("nats.cache.miss.reason")); + + // A miss is a normal outcome, so the span status stays Unset. Marking misses as errors would make + // every cold cache look like an outage in a trace UI. + Assert.Equal(ActivityStatusCode.Unset, activity.Status); + + // Keys are omitted from spans unless RecordCacheKeys is enabled, because they commonly carry PII. + Assert.Null(activity.GetTagItem("nats.cache.key")); + } + + [Fact] + public async Task FailedReadProducesSpanWithErrorStatusAndErrorType() + { + var cache = CreateFailingCache(); + using var activities = new RecordingActivityListener(NatsCacheTelemetryNames.ActivitySourceName); + + await Assert.ThrowsAnyAsync( + () => cache.GetAsync(MethodKey(), TestContext.Current.CancellationToken)); + + var activity = Assert.Single(activities.Activities); + Assert.Equal(ActivityStatusCode.Error, activity.Status); + Assert.Equal("error", activity.GetTagItem("nats.cache.result")); + Assert.NotNull(activity.GetTagItem("error.type")); + } + + [Fact] + public async Task RecordCacheKeysAddsKeyToSpanOnly() + { + var key = MethodKey(); + var options = new NatsCacheOptions { BucketName = "cache" }; + options.Telemetry.RecordCacheKeys = true; + var cache = new NatsCache(Options.Create(options), NatsConnection); + + using var activities = new RecordingActivityListener(NatsCacheTelemetryNames.ActivitySourceName); + using var duration = CreateFallbackDurationCollector(); + + Assert.Null(await cache.GetAsync(key, TestContext.Current.CancellationToken)); + + var activity = Assert.Single(activities.Activities); + Assert.Equal(key, activity.GetTagItem("nats.cache.key")); + + // Opt-in or not, the key never reaches metrics: it is an unbounded dimension that would break + // cardinality for every consumer. + var measurement = Assert.Single(duration.GetMeasurementSnapshot()); + Assert.DoesNotContain(measurement.Tags, tag => Equals(tag.Value, key)); + } + + // Collectors for directly-constructed caches, which have no IMeterFactory and therefore publish on the + // process-wide fallback meter (null scope). Safe to assert on because integration tests share a + // collection and run serially. + private static MetricCollector CreateFallbackDurationCollector() => + new(null, NatsCacheTelemetryNames.MeterName, NatsCacheTelemetryNames.OperationDurationInstrumentName); + + private static MetricCollector CreateFallbackMissesCollector() => + new(null, NatsCacheTelemetryNames.MeterName, NatsCacheTelemetryNames.MissesInstrumentName); + + // Collectors for caches built by this test's own container. Scoping to the meter factory keeps the + // measurements isolated from any cache using the process-wide fallback meter. + private MetricCollector CreateDurationCollector(IMeterFactory? meterFactory = null) => + new( + meterFactory ?? MeterFactory, + NatsCacheTelemetryNames.MeterName, + NatsCacheTelemetryNames.OperationDurationInstrumentName); + + private MetricCollector CreateMissesCollector(IMeterFactory? meterFactory = null) => + new( + meterFactory ?? MeterFactory, + NatsCacheTelemetryNames.MeterName, + NatsCacheTelemetryNames.MissesInstrumentName); + + // A container mirroring TestBase's, optionally on a fake clock, used by tests that need a second + // isolated meter or a controllable clock. + private ServiceProvider BuildProvider(TimeProvider? timeProvider = null) + { + var services = new ServiceCollection(); + services.AddMetrics(); + if (timeProvider is not null) + { + services.AddSingleton(timeProvider); + } + + _fixture.ConfigureServices(services); + services.AddHybridCacheTestClient(); + return services.BuildServiceProvider(); + } + + // Directly constructed, so it uses the process-wide fallback meter rather than this test's factory. + // Safe because integration tests share a collection and therefore run serially. + private NatsCache CreateDirectCache() => + new(Options.Create(new NatsCacheOptions { BucketName = "cache" }), NatsConnection); + + // Points a cache at a bucket that does not exist so the read path throws when it resolves the KV store. + private NatsCache CreateFailingCache() => + new( + Options.Create(new NatsCacheOptions { BucketName = "does-not-exist" }), + NatsConnection, + new RecordingLogger()); + + private async Task WriteRawEntryAsync(string key, byte[] raw) + { + var encodedKey = new NatsCacheKeyEncoder().Encode(key); + var kvStore = await NatsConnection.CreateKeyValueStoreContext().GetStoreAsync("cache"); + await kvStore.PutAsync(encodedKey, raw, cancellationToken: TestContext.Current.CancellationToken); + } +} diff --git a/test/IntegrationTests/IntegrationTests.csproj b/test/IntegrationTests/IntegrationTests.csproj index 689a1de..01e2bef 100644 --- a/test/IntegrationTests/IntegrationTests.csproj +++ b/test/IntegrationTests/IntegrationTests.csproj @@ -12,6 +12,8 @@ + + diff --git a/test/IntegrationTests/TestBase.cs b/test/IntegrationTests/TestBase.cs index 0104961..2019daa 100644 --- a/test/IntegrationTests/TestBase.cs +++ b/test/IntegrationTests/TestBase.cs @@ -1,3 +1,4 @@ +using System.Diagnostics.Metrics; using System.Runtime.CompilerServices; using CodeCargo.Nats.DistributedCache.TestUtils; using CodeCargo.Nats.DistributedCache.TestUtils.Services.Logging; @@ -38,6 +39,11 @@ protected TestBase(NatsIntegrationFixture fixture) builder.AddXUnitTestOutput(output); }); + // Registers IMeterFactory so each test's ServiceProvider gets its own Meter instance. Without this + // the cache falls back to the process-wide static meter and concurrent tests would see each + // other's measurements. + services.AddMetrics(); + // Configure the service collection with NATS connection fixture.ConfigureServices(services); @@ -69,6 +75,11 @@ protected TestBase(NatsIntegrationFixture fixture) /// protected HybridCache HybridCache => ServiceProvider.GetRequiredService(); + /// + /// Gets the meter factory scoping this test's cache instruments + /// + protected IMeterFactory MeterFactory => ServiceProvider.GetRequiredService(); + /// /// Purge stream before test run /// diff --git a/test/IntegrationTests/packages.linux-arm64.lock.json b/test/IntegrationTests/packages.linux-arm64.lock.json index cbf783b..e815c20 100644 --- a/test/IntegrationTests/packages.linux-arm64.lock.json +++ b/test/IntegrationTests/packages.linux-arm64.lock.json @@ -43,6 +43,23 @@ "System.IO.Hashing": "10.0.8" } }, + "Microsoft.Extensions.Diagnostics.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "TEQTZklstvSx7/W+qom54+NlExkJAIOXeO3OMt/6zBAtBf14G+X3/vVUU1SyjNiNXiaOkYy/MGuyVXHG7/lX4Q==", + "dependencies": { + "Microsoft.Extensions.Logging": "10.0.1", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.1", + "Microsoft.Extensions.Telemetry.Abstractions": "10.1.0" + } + }, + "Microsoft.Extensions.TimeProvider.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "wH/CohN2yvYlpyPptNwWVZxlIQ8CkFvcv1eOEZTi/y8FhqVeISLbrraaW0qvVtXRKEeO0EyapNCZzj4HtdRGRw==" + }, "Microsoft.NET.Test.Sdk": { "type": "Direct", "requested": "[18.7.0, )", diff --git a/test/IntegrationTests/packages.linux-x64.lock.json b/test/IntegrationTests/packages.linux-x64.lock.json index 7121bb3..2cbec24 100644 --- a/test/IntegrationTests/packages.linux-x64.lock.json +++ b/test/IntegrationTests/packages.linux-x64.lock.json @@ -43,6 +43,23 @@ "System.IO.Hashing": "10.0.8" } }, + "Microsoft.Extensions.Diagnostics.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "TEQTZklstvSx7/W+qom54+NlExkJAIOXeO3OMt/6zBAtBf14G+X3/vVUU1SyjNiNXiaOkYy/MGuyVXHG7/lX4Q==", + "dependencies": { + "Microsoft.Extensions.Logging": "10.0.1", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.1", + "Microsoft.Extensions.Telemetry.Abstractions": "10.1.0" + } + }, + "Microsoft.Extensions.TimeProvider.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "wH/CohN2yvYlpyPptNwWVZxlIQ8CkFvcv1eOEZTi/y8FhqVeISLbrraaW0qvVtXRKEeO0EyapNCZzj4HtdRGRw==" + }, "Microsoft.NET.Test.Sdk": { "type": "Direct", "requested": "[18.7.0, )", diff --git a/test/IntegrationTests/packages.osx-arm64.lock.json b/test/IntegrationTests/packages.osx-arm64.lock.json index c89c98c..543a99c 100644 --- a/test/IntegrationTests/packages.osx-arm64.lock.json +++ b/test/IntegrationTests/packages.osx-arm64.lock.json @@ -43,6 +43,23 @@ "System.IO.Hashing": "10.0.8" } }, + "Microsoft.Extensions.Diagnostics.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "TEQTZklstvSx7/W+qom54+NlExkJAIOXeO3OMt/6zBAtBf14G+X3/vVUU1SyjNiNXiaOkYy/MGuyVXHG7/lX4Q==", + "dependencies": { + "Microsoft.Extensions.Logging": "10.0.1", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.1", + "Microsoft.Extensions.Telemetry.Abstractions": "10.1.0" + } + }, + "Microsoft.Extensions.TimeProvider.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "wH/CohN2yvYlpyPptNwWVZxlIQ8CkFvcv1eOEZTi/y8FhqVeISLbrraaW0qvVtXRKEeO0EyapNCZzj4HtdRGRw==" + }, "Microsoft.NET.Test.Sdk": { "type": "Direct", "requested": "[18.7.0, )", diff --git a/test/IntegrationTests/packages.win-x64.lock.json b/test/IntegrationTests/packages.win-x64.lock.json index d63c034..41925d4 100644 --- a/test/IntegrationTests/packages.win-x64.lock.json +++ b/test/IntegrationTests/packages.win-x64.lock.json @@ -43,6 +43,23 @@ "System.IO.Hashing": "10.0.8" } }, + "Microsoft.Extensions.Diagnostics.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "TEQTZklstvSx7/W+qom54+NlExkJAIOXeO3OMt/6zBAtBf14G+X3/vVUU1SyjNiNXiaOkYy/MGuyVXHG7/lX4Q==", + "dependencies": { + "Microsoft.Extensions.Logging": "10.0.1", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.1", + "Microsoft.Extensions.Telemetry.Abstractions": "10.1.0" + } + }, + "Microsoft.Extensions.TimeProvider.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "wH/CohN2yvYlpyPptNwWVZxlIQ8CkFvcv1eOEZTi/y8FhqVeISLbrraaW0qvVtXRKEeO0EyapNCZzj4HtdRGRw==" + }, "Microsoft.NET.Test.Sdk": { "type": "Direct", "requested": "[18.7.0, )", diff --git a/test/TestUtils/Services/Diagnostics/RecordingActivityListener.cs b/test/TestUtils/Services/Diagnostics/RecordingActivityListener.cs new file mode 100644 index 0000000..4851c94 --- /dev/null +++ b/test/TestUtils/Services/Diagnostics/RecordingActivityListener.cs @@ -0,0 +1,65 @@ +using System.Diagnostics; + +namespace CodeCargo.Nats.DistributedCache.TestUtils.Services.Diagnostics; + +/// +/// An that captures completed activities from a single source in memory so +/// tests can assert on them. Mirrors RecordingLogger{T} for traces. +/// +/// +/// Samples every activity as , so tags set behind +/// IsAllDataRequested are captured. Only activities that stop while the listener is alive are +/// recorded, which is what makes per-test instances work. +/// +public sealed class RecordingActivityListener : IDisposable +{ + private readonly List _activities = new(); + private readonly ActivityListener _listener; + + /// + /// Initializes a new instance of the class + /// + /// The name to listen to + public RecordingActivityListener(string sourceName) + { + _listener = new ActivityListener + { + ShouldListenTo = source => source.Name == sourceName, + Sample = SampleAllData, + SampleUsingParentId = SampleAllDataUsingParentId, + ActivityStopped = activity => + { + lock (_activities) + { + _activities.Add(activity); + } + }, + }; + + ActivitySource.AddActivityListener(_listener); + } + + /// + /// Gets a snapshot of the activities captured so far + /// + public IReadOnlyList Activities + { + get + { + lock (_activities) + { + return _activities.ToArray(); + } + } + } + + public void Dispose() => _listener.Dispose(); + + // Named static methods rather than lambdas: SampleActivity takes a `ref` parameter, and lambda + // inference for ref parameters differs across the two target frameworks. + private static ActivitySamplingResult SampleAllData(ref ActivityCreationOptions options) => + ActivitySamplingResult.AllDataAndRecorded; + + private static ActivitySamplingResult SampleAllDataUsingParentId(ref ActivityCreationOptions options) => + ActivitySamplingResult.AllDataAndRecorded; +} diff --git a/test/TestUtils/packages.linux-arm64.lock.json b/test/TestUtils/packages.linux-arm64.lock.json index a27a333..a87a19d 100644 --- a/test/TestUtils/packages.linux-arm64.lock.json +++ b/test/TestUtils/packages.linux-arm64.lock.json @@ -540,7 +540,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/test/TestUtils/packages.linux-x64.lock.json b/test/TestUtils/packages.linux-x64.lock.json index a27a333..a87a19d 100644 --- a/test/TestUtils/packages.linux-x64.lock.json +++ b/test/TestUtils/packages.linux-x64.lock.json @@ -540,7 +540,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/test/TestUtils/packages.osx-arm64.lock.json b/test/TestUtils/packages.osx-arm64.lock.json index a27a333..a87a19d 100644 --- a/test/TestUtils/packages.osx-arm64.lock.json +++ b/test/TestUtils/packages.osx-arm64.lock.json @@ -540,7 +540,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/test/TestUtils/packages.win-x64.lock.json b/test/TestUtils/packages.win-x64.lock.json index a27a333..a87a19d 100644 --- a/test/TestUtils/packages.win-x64.lock.json +++ b/test/TestUtils/packages.win-x64.lock.json @@ -540,7 +540,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/test/UnitTests/Cache/TelemetryUnitTests.cs b/test/UnitTests/Cache/TelemetryUnitTests.cs new file mode 100644 index 0000000..d211b4e --- /dev/null +++ b/test/UnitTests/Cache/TelemetryUnitTests.cs @@ -0,0 +1,373 @@ +using System.Buffers; +using System.Diagnostics; +using System.Diagnostics.Metrics; +using Microsoft.Extensions.Caching.Distributed; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Diagnostics.Metrics.Testing; +using Microsoft.Extensions.Logging; +using Microsoft.Extensions.Options; +using Microsoft.Extensions.Time.Testing; +using Moq; +using NATS.Client.Core; + +namespace CodeCargo.Nats.DistributedCache.UnitTests.Cache; + +/// +/// Telemetry behavior that can be asserted without a NATS server. +/// +/// +/// Each test builds its own so the cache's instruments are scoped to that +/// factory rather than the process-wide fallback meter. Without that, unit test classes running in +/// parallel would observe each other's measurements. +/// +public class TelemetryUnitTests +{ + [Fact] + public void PublicTelemetryNamesAreStable() + { + // These names are load-bearing: users hardcode them in AddMeter/AddSource calls and build + // dashboards and alerts on the instrument names. This repo has no PublicAPI.Shipped.txt and no + // API-approval test, so this is the only thing that turns a rename into a visible failure rather + // than a silent break of every downstream dashboard. + Assert.Equal("CodeCargo.Nats.DistributedCache", NatsCacheTelemetryNames.MeterName); + Assert.Equal("CodeCargo.Nats.DistributedCache", NatsCacheTelemetryNames.ActivitySourceName); + Assert.Equal("nats.cache.operation.duration", NatsCacheTelemetryNames.OperationDurationInstrumentName); + Assert.Equal("nats.cache.misses", NatsCacheTelemetryNames.MissesInstrumentName); + } + + [Fact] + public void InstrumentsUseDocumentedUnits() + { + using var provider = BuildMeterProvider(); + var meterFactory = provider.GetRequiredService(); + using var duration = CreateDurationCollector(meterFactory); + using var misses = CreateMissesCollector(meterFactory); + + // Creating the cache is not enough; instruments are built on first use. Drive one failing + // operation so the meter is materialized, then assert the published metadata. + var cache = CreateCache(meterFactory); + Assert.ThrowsAny(() => cache.Set(nameof(InstrumentsUseDocumentedUnits), [1], new())); + + // Seconds, not milliseconds: OpenTelemetry mandates seconds for duration histograms, and a wrong + // unit here is invisible until it is already in someone's dashboard. + Assert.NotNull(duration.Instrument); + Assert.NotNull(misses.Instrument); + Assert.Equal("s", duration.Instrument.Unit); + Assert.Equal("{miss}", misses.Instrument.Unit); + } + + [Fact] + public void InvalidExpirationRecordsNoMeasurement() + { + using var provider = BuildMeterProvider(); + var meterFactory = provider.GetRequiredService(); + var timeProvider = new FakeTimeProvider(); + var cache = CreateCache(meterFactory, timeProvider); + using var duration = CreateDurationCollector(meterFactory); + + var expired = timeProvider.GetUtcNow() - TimeSpan.FromMinutes(1); + Assert.ThrowsAny( + () => cache.Set( + nameof(InvalidExpirationRecordsNoMeasurement), + [1], + new DistributedCacheEntryOptions().SetAbsoluteExpiration(expired))); + + // A caller passing a bad expiration is a caller bug that never reaches NATS. Counting it would + // fire the error-rate alert for an operation that was never attempted, and would inject a ~0s + // sample into the latency distribution. The scope deliberately opens after GetTtl. + Assert.Empty(duration.GetMeasurementSnapshot()); + } + + [Fact] + public void SyncSetOfReadOnlySequenceRecordsExactlyOneMeasurement() + { + using var provider = BuildMeterProvider(); + var meterFactory = provider.GetRequiredService(); + var cache = CreateCache(meterFactory); + using var duration = CreateDurationCollector(meterFactory); + + // Set(ReadOnlySequence) -> SetAsync(ReadOnlySequence) -> SetAsync(byte[]) is three deep, and is + // how HybridCache writes to L2. Only the innermost overload is instrumented, so this must still + // produce a single measurement. + Assert.ThrowsAny( + () => cache.Set( + nameof(SyncSetOfReadOnlySequenceRecordsExactlyOneMeasurement), + new ReadOnlySequence(new byte[] { 1, 2, 3 }), + new DistributedCacheEntryOptions())); + + var measurement = Assert.Single(duration.GetMeasurementSnapshot()); + Assert.Equal("set", measurement.Tags["nats.cache.operation"]); + Assert.Equal("error", measurement.Tags["nats.cache.result"]); + } + + [Fact] + public void SyncGetRecordsExactlyOneMeasurementTaggedError() + { + using var provider = BuildMeterProvider(); + var meterFactory = provider.GetRequiredService(); + var cache = CreateCache(meterFactory); + using var duration = CreateDurationCollector(meterFactory); + using var misses = CreateMissesCollector(meterFactory); + + Assert.ThrowsAny(() => cache.Get(nameof(SyncGetRecordsExactlyOneMeasurementTaggedError))); + + // Get -> GetAsync -> GetAndRefreshAsync: instrumented only at the core, so the sync wrapper adds + // no second measurement. + var measurement = Assert.Single(duration.GetMeasurementSnapshot()); + Assert.Equal("get", measurement.Tags["nats.cache.operation"]); + Assert.Equal("error", measurement.Tags["nats.cache.result"]); + Assert.NotNull(measurement.Tags["error.type"]); + + // A failure is an error, never a miss: the misses counter must stay untouched so that hit-rate + // dashboards are not polluted by outages. + Assert.Empty(misses.GetMeasurementSnapshot()); + } + + [Fact] + public async Task RefreshTagsOperationRefreshNotGet() + { + using var provider = BuildMeterProvider(); + var meterFactory = provider.GetRequiredService(); + var cache = CreateCache(meterFactory); + using var duration = CreateDurationCollector(meterFactory); + + await Assert.ThrowsAnyAsync( + () => cache.RefreshAsync(nameof(RefreshTagsOperationRefreshNotGet), TestContext.Current.CancellationToken)); + + // Refresh shares GetAndRefreshAsync with Get, so this pins that the operation discriminator is + // threaded through correctly rather than every read reporting as "get". + var measurement = Assert.Single(duration.GetMeasurementSnapshot()); + Assert.Equal("refresh", measurement.Tags["nats.cache.operation"]); + } + + [Fact] + public async Task RemoveTagsOperationRemove() + { + using var provider = BuildMeterProvider(); + var meterFactory = provider.GetRequiredService(); + var cache = CreateCache(meterFactory); + using var duration = CreateDurationCollector(meterFactory); + + await Assert.ThrowsAnyAsync( + () => cache.RemoveAsync(nameof(RemoveTagsOperationRemove), TestContext.Current.CancellationToken)); + + var measurement = Assert.Single(duration.GetMeasurementSnapshot()); + Assert.Equal("remove", measurement.Tags["nats.cache.operation"]); + } + + [Fact] + public void CacheKeyIsNeverRecordedOnMetricsEvenWhenRecordCacheKeysIsEnabled() + { + using var provider = BuildMeterProvider(); + var meterFactory = provider.GetRequiredService(); + var cache = CreateCache(meterFactory, recordCacheKeys: true); + using var duration = CreateDurationCollector(meterFactory); + + const string key = "user:12345:profile"; + Assert.ThrowsAny(() => cache.Get(key)); + + // RecordCacheKeys is a span-only opt-in. Keys are an unbounded dimension and a common PII + // carrier, so they must never reach metrics regardless of the setting. + var measurement = Assert.Single(duration.GetMeasurementSnapshot()); + Assert.DoesNotContain(measurement.Tags, tag => Equals(tag.Value, key)); + Assert.DoesNotContain(measurement.Tags, tag => tag.Key == "nats.cache.key"); + } + + [Fact] + public void NoSubscriberDoesNotThrow() + { + using var provider = BuildMeterProvider(); + var cache = CreateCache(provider.GetRequiredService()); + + // Exercises the fast path (no MetricCollector, no ActivityListener) in CI, so a null-reference or + // divide-by-zero in the disabled branch cannot go unnoticed. + Assert.ThrowsAny(() => cache.Get(nameof(NoSubscriberDoesNotThrow))); + Assert.ThrowsAny(() => cache.Remove(nameof(NoSubscriberDoesNotThrow))); + } + + [Fact] + public void CallerCancellationIsTaggedCancelledNotError() + { + using var provider = BuildMeterProvider(); + var meterFactory = provider.GetRequiredService(); + var telemetry = new NatsCacheTelemetry(meterFactory, "cache", false); + using var duration = CreateDurationCollector(meterFactory); + using var cts = new CancellationTokenSource(); + cts.Cancel(); + + var scope = NatsCacheOperationScope.Start( + telemetry, + TimeProvider.System, + CacheOperation.Get, + "key", + cts.Token); + scope.SetError(new OperationCanceledException(cts.Token)); + scope.Complete(); + + // Cooperative shutdown is not a failure, and callers are told they may exclude it from alerting. + var measurement = Assert.Single(duration.GetMeasurementSnapshot()); + Assert.Equal("cancelled", measurement.Tags["nats.cache.result"]); + Assert.DoesNotContain(measurement.Tags, tag => tag.Key == "error.type"); + } + + [Fact] + public void CancellationExceptionWithoutCallerCancellationIsTaggedError() + { + using var provider = BuildMeterProvider(); + var meterFactory = provider.GetRequiredService(); + var telemetry = new NatsCacheTelemetry(meterFactory, "cache", false); + using var duration = CreateDurationCollector(meterFactory); + + // A NATS request timeout surfaces as TaskCanceledException with the caller's token unsignalled. + // Classifying that as `cancelled` would hide a real outage from the error rate, since callers are + // told they can exclude cancellations from alerting. TryGetAsync draws the same line before + // logging these at Warning, so metrics and logs must agree that this is a failure. + var scope = NatsCacheOperationScope.Start( + telemetry, + TimeProvider.System, + CacheOperation.Get, + "key", + CancellationToken.None); + scope.SetError(new TaskCanceledException("NATS request timed out")); + scope.Complete(); + + var measurement = Assert.Single(duration.GetMeasurementSnapshot()); + Assert.Equal("error", measurement.Tags["nats.cache.result"]); + Assert.Equal("System.Threading.Tasks.TaskCanceledException", measurement.Tags["error.type"]); + } + + [Fact] + public void MissesAreRecordedWhileTheHistogramIsDisabled() + { + using var provider = BuildMeterProvider(); + var meterFactory = provider.GetRequiredService(); + var telemetry = new NatsCacheTelemetry(meterFactory, "cache", false); + using var misses = CreateMissesCollector(meterFactory); + + // The precondition is what gives this test its value: only the counter is subscribed, mimicking a + // user who dropped the histogram with an OTel View. Asserting it explicitly means the test cannot + // silently stop covering the regression if something else starts enabling the histogram. + Assert.False(telemetry.OperationDuration.Enabled); + Assert.True(telemetry.Misses.Enabled); + + var scope = NatsCacheOperationScope.Start( + telemetry, + TimeProvider.System, + CacheOperation.Get, + "key", + CancellationToken.None); + scope.SetMiss(CacheMissReason.NotFound); + scope.Complete(); + + var miss = Assert.Single(misses.GetMeasurementSnapshot()); + Assert.Equal(1, miss.Value); + Assert.Equal("not_found", miss.Tags["nats.cache.miss.reason"]); + } + + [Fact] + public void ThrowingListenerDoesNotBreakTheOperation() + { + using var provider = BuildMeterProvider(); + var meterFactory = provider.GetRequiredService(); + var telemetry = new NatsCacheTelemetry(meterFactory, "cache", false); + + using var listener = new ActivityListener + { + ShouldListenTo = source => source.Name == NatsCacheTelemetryNames.ActivitySourceName, + Sample = SampleAllData, + ActivityStopped = _ => throw new InvalidOperationException("badly-behaved exporter"), + }; + ActivitySource.AddActivityListener(listener); + + var scope = NatsCacheOperationScope.Start( + telemetry, + TimeProvider.System, + CacheOperation.Get, + "key", + CancellationToken.None); + scope.SetHit(); + + // Complete() always runs from a finally block, so an exception escaping it would replace the + // in-flight cache exception or fail an operation that actually succeeded. ActivitySource does not + // guard listener callbacks, so a third-party exporter really can throw into this frame. + scope.Complete(); + + // And the activity is still stopped despite the throw, so Activity.Current is not left dangling — + // otherwise every subsequent span on this context would be misparented. + Assert.Null(Activity.Current); + } + + [Fact] + public void UnsubscribedScopeAllocatesNothing() + { + using var provider = BuildMeterProvider(); + var telemetry = new NatsCacheTelemetry(provider.GetRequiredService(), "cache", false); + + // Warm up so JIT compilation and any one-time initialization are not counted below. + for (var i = 0; i < 100; i++) + { + RunScope(telemetry); + } + + var before = GC.GetAllocatedBytesForCurrentThread(); + for (var i = 0; i < 1_000; i++) + { + RunScope(telemetry); + } + + // Pins the README's claim that an unsubscribed cache allocates nothing per operation. With no + // listener the scope must be a zeroed struct: no timestamp, no TagList, no Activity, no boxing. + Assert.Equal(0, GC.GetAllocatedBytesForCurrentThread() - before); + } + + private static void RunScope(NatsCacheTelemetry telemetry) + { + var scope = NatsCacheOperationScope.Start( + telemetry, + TimeProvider.System, + CacheOperation.Get, + "key", + CancellationToken.None); + scope.SetMiss(CacheMissReason.NotFound); + scope.Complete(); + } + + // Named static method rather than a lambda: SampleActivity takes a `ref` parameter, and lambda + // inference for ref parameters differs across the two target frameworks. + private static ActivitySamplingResult SampleAllData(ref ActivityCreationOptions options) => + ActivitySamplingResult.AllDataAndRecorded; + + private static ServiceProvider BuildMeterProvider() => + new ServiceCollection().AddMetrics().BuildServiceProvider(); + + private static MetricCollector CreateDurationCollector(IMeterFactory meterFactory) => + new( + meterFactory, + NatsCacheTelemetryNames.MeterName, + NatsCacheTelemetryNames.OperationDurationInstrumentName); + + private static MetricCollector CreateMissesCollector(IMeterFactory meterFactory) => + new(meterFactory, NatsCacheTelemetryNames.MeterName, NatsCacheTelemetryNames.MissesInstrumentName); + + // A cache over a mocked connection: every KV operation fails, which is exactly what makes the error + // paths deterministic without a server. + private static NatsCache CreateCache( + IMeterFactory meterFactory, + TimeProvider? timeProvider = null, + bool recordCacheKeys = false) + { + var mockNatsConnection = new Mock(); + var opts = new NatsOpts { LoggerFactory = new LoggerFactory() }; + mockNatsConnection.SetupGet(m => m.Opts).Returns(opts); + mockNatsConnection.SetupGet(m => m.Connection).Returns(new NatsConnection(opts)); + + var options = new NatsCacheOptions { BucketName = "cache" }; + options.Telemetry.RecordCacheKeys = recordCacheKeys; + + return new NatsCache(Options.Create(options), mockNatsConnection.Object) + { + TimeProvider = timeProvider ?? new FakeTimeProvider(), + MeterFactory = meterFactory, + }; + } +} diff --git a/test/UnitTests/UnitTests.csproj b/test/UnitTests/UnitTests.csproj index 6889719..ddcc439 100644 --- a/test/UnitTests/UnitTests.csproj +++ b/test/UnitTests/UnitTests.csproj @@ -9,6 +9,10 @@ + + + diff --git a/test/UnitTests/packages.linux-arm64.lock.json b/test/UnitTests/packages.linux-arm64.lock.json index 90126b0..97ad0e8 100644 --- a/test/UnitTests/packages.linux-arm64.lock.json +++ b/test/UnitTests/packages.linux-arm64.lock.json @@ -2,6 +2,28 @@ "version": 1, "dependencies": { "net10.0": { + "Microsoft.Extensions.Diagnostics": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "NLXI3PbTe39q6/sgs7JYhmfPf7bMzReUoAJ0q9Po6yhfM+0anZa7PrEva4W2SdiLWGyB9eKZS9THGt2BP40xJg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Diagnostics.Abstractions": "10.0.9", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.9" + } + }, + "Microsoft.Extensions.Diagnostics.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "TEQTZklstvSx7/W+qom54+NlExkJAIOXeO3OMt/6zBAtBf14G+X3/vVUU1SyjNiNXiaOkYy/MGuyVXHG7/lX4Q==", + "dependencies": { + "Microsoft.Extensions.Logging": "10.0.1", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.1", + "Microsoft.Extensions.Telemetry.Abstractions": "10.1.0" + } + }, "Microsoft.Extensions.TimeProvider.Testing": { "type": "Direct", "requested": "[10.1.0, )", @@ -105,12 +127,39 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Compliance.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "M3JWrgZMkVzyEybZzNkTiC/e8U1ipXTi8xm8bj+PHHp4AcEmhmIEqnxRS0VHVCKZjLkOPt2hY2CIisUFQ6gqLA==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.1", + "Microsoft.Extensions.ObjectPool": "10.0.1" + } + }, + "Microsoft.Extensions.Configuration": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "woZsWLhOQsASuxbmgiZJqiGUBNo3IjRdXC92xt8rRokza+P6/nIsnzq7sm9Or6ZYcRl2kL1ufj8HVzp1QlPTXw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Configuration.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "3lE/iLSutpgX1CC0NOW70FJoGARRHbyKmG7dc0klnUZ9Dd9hS6N/POPWhKhMLCEuNN5nXEY5agmlFtH562vqhQ==", + "resolved": "10.0.9", + "contentHash": "qGhRPd3VxfLV9UqatVOiD9mAeUbj2KiMwGFYC5uXlzExiZQoe4X/hdmzGIU7BQjNLTqCnnbTHVyBglG3668/HA==", "dependencies": { - "Microsoft.Extensions.Primitives": "8.0.0" + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, + "Microsoft.Extensions.Configuration.Binder": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Tp/+LPb70RyjjtLg9m5C959eP4KrUpJHThZfAegZVpsfmGvzfuNkuYbI/ft+LvXhMSyUcAeOPaN6rzTccwnZAg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9" } }, "Microsoft.Extensions.DependencyInjection": { @@ -128,11 +177,11 @@ }, "Microsoft.Extensions.Diagnostics.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "JHYCQG7HmugNYUhOl368g+NMxYE/N/AiclCYRNlgCY9eVyiBkOHMwK4x60RYMxv9EL3+rmj1mqHvdCiPpC+D4Q==", + "resolved": "10.0.9", + "contentHash": "86RgyFsmVslW4Nu28IXgt8tLglynGQrwjk/xhGZaTe8j6YIeR1Ywoc42hSHsBSl920CQdfqq2dBohZiGm3AkUA==", "dependencies": { - "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0", - "Microsoft.Extensions.Options": "8.0.0" + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9" } }, "Microsoft.Extensions.FileProviders.Abstractions": { @@ -173,6 +222,11 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9" } }, + "Microsoft.Extensions.ObjectPool": { + "type": "Transitive", + "resolved": "10.0.1", + "contentHash": "HqAEbtoAhgvH53c54IV5e4vQ60PYvl7Z/WIHsbet+UGGE7n+7dwVNXw1mb9LZlWbsxnupCevvtgIne5P//ZKpQ==" + }, "Microsoft.Extensions.Options": { "type": "Transitive", "resolved": "10.0.9", @@ -182,11 +236,34 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Options.ConfigurationExtensions": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Y4E24zffF/aPS0igNvY6ZzAQfbxd6AYdC9L4brnH+uK0yYYHIR6FeGVQVVjAOo8wub1EQDl2B90lCcpqoTF7Yw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Configuration.Binder": "10.0.9", + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Primitives": { "type": "Transitive", "resolved": "10.0.9", "contentHash": "fmEbAUFsaIKirgLt/lYhuFRBwhcSJN31jjHgCdbQxJiWOum6EdLjkbgGuukSP9z/a+9LibaxII/kF+GwOXgC4g==" }, + "Microsoft.Extensions.Telemetry.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "0jAF2b0YJ1LOtunmo3PzSoJOx/ThhcGH5Y5kaV0jeM0BUlyr9orjg+fH5YabqnPSmwcN/DSTj0iZ7UwDISn5ag==", + "dependencies": { + "Microsoft.Extensions.Compliance.Abstractions": "10.1.0", + "Microsoft.Extensions.Logging.Abstractions": "10.0.1", + "Microsoft.Extensions.ObjectPool": "10.0.1", + "Microsoft.Extensions.Options": "10.0.1" + } + }, "Microsoft.Testing.Extensions.Telemetry": { "type": "Transitive", "resolved": "1.9.1", @@ -440,6 +517,28 @@ } }, "net8.0": { + "Microsoft.Extensions.Diagnostics": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "NLXI3PbTe39q6/sgs7JYhmfPf7bMzReUoAJ0q9Po6yhfM+0anZa7PrEva4W2SdiLWGyB9eKZS9THGt2BP40xJg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Diagnostics.Abstractions": "10.0.9", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.9" + } + }, + "Microsoft.Extensions.Diagnostics.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "TEQTZklstvSx7/W+qom54+NlExkJAIOXeO3OMt/6zBAtBf14G+X3/vVUU1SyjNiNXiaOkYy/MGuyVXHG7/lX4Q==", + "dependencies": { + "Microsoft.Extensions.Logging": "8.0.1", + "Microsoft.Extensions.Options.ConfigurationExtensions": "8.0.0", + "Microsoft.Extensions.Telemetry.Abstractions": "10.1.0" + } + }, "Microsoft.Extensions.TimeProvider.Testing": { "type": "Direct", "requested": "[10.1.0, )", @@ -543,12 +642,39 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Compliance.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "M3JWrgZMkVzyEybZzNkTiC/e8U1ipXTi8xm8bj+PHHp4AcEmhmIEqnxRS0VHVCKZjLkOPt2hY2CIisUFQ6gqLA==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.2", + "Microsoft.Extensions.ObjectPool": "8.0.22" + } + }, + "Microsoft.Extensions.Configuration": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "woZsWLhOQsASuxbmgiZJqiGUBNo3IjRdXC92xt8rRokza+P6/nIsnzq7sm9Or6ZYcRl2kL1ufj8HVzp1QlPTXw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Configuration.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "3lE/iLSutpgX1CC0NOW70FJoGARRHbyKmG7dc0klnUZ9Dd9hS6N/POPWhKhMLCEuNN5nXEY5agmlFtH562vqhQ==", + "resolved": "10.0.9", + "contentHash": "qGhRPd3VxfLV9UqatVOiD9mAeUbj2KiMwGFYC5uXlzExiZQoe4X/hdmzGIU7BQjNLTqCnnbTHVyBglG3668/HA==", "dependencies": { - "Microsoft.Extensions.Primitives": "8.0.0" + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, + "Microsoft.Extensions.Configuration.Binder": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Tp/+LPb70RyjjtLg9m5C959eP4KrUpJHThZfAegZVpsfmGvzfuNkuYbI/ft+LvXhMSyUcAeOPaN6rzTccwnZAg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9" } }, "Microsoft.Extensions.DependencyInjection": { @@ -566,11 +692,12 @@ }, "Microsoft.Extensions.Diagnostics.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "JHYCQG7HmugNYUhOl368g+NMxYE/N/AiclCYRNlgCY9eVyiBkOHMwK4x60RYMxv9EL3+rmj1mqHvdCiPpC+D4Q==", + "resolved": "10.0.9", + "contentHash": "86RgyFsmVslW4Nu28IXgt8tLglynGQrwjk/xhGZaTe8j6YIeR1Ywoc42hSHsBSl920CQdfqq2dBohZiGm3AkUA==", "dependencies": { - "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0", - "Microsoft.Extensions.Options": "8.0.0" + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9", + "System.Diagnostics.DiagnosticSource": "10.0.9" } }, "Microsoft.Extensions.FileProviders.Abstractions": { @@ -612,6 +739,11 @@ "System.Diagnostics.DiagnosticSource": "10.0.9" } }, + "Microsoft.Extensions.ObjectPool": { + "type": "Transitive", + "resolved": "8.0.22", + "contentHash": "4K7MUXbEDtVHTa/OYlkDya2kHSflojuD4d6dcmvnGYnvuJQ0bfylWbMTkA65N94SdTGo5zdkXR8T9mEED7RUvQ==" + }, "Microsoft.Extensions.Options": { "type": "Transitive", "resolved": "10.0.9", @@ -621,11 +753,34 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Options.ConfigurationExtensions": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Y4E24zffF/aPS0igNvY6ZzAQfbxd6AYdC9L4brnH+uK0yYYHIR6FeGVQVVjAOo8wub1EQDl2B90lCcpqoTF7Yw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Configuration.Binder": "10.0.9", + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Primitives": { "type": "Transitive", "resolved": "10.0.9", "contentHash": "fmEbAUFsaIKirgLt/lYhuFRBwhcSJN31jjHgCdbQxJiWOum6EdLjkbgGuukSP9z/a+9LibaxII/kF+GwOXgC4g==" }, + "Microsoft.Extensions.Telemetry.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "0jAF2b0YJ1LOtunmo3PzSoJOx/ThhcGH5Y5kaV0jeM0BUlyr9orjg+fH5YabqnPSmwcN/DSTj0iZ7UwDISn5ag==", + "dependencies": { + "Microsoft.Extensions.Compliance.Abstractions": "10.1.0", + "Microsoft.Extensions.Logging.Abstractions": "8.0.3", + "Microsoft.Extensions.ObjectPool": "8.0.22", + "Microsoft.Extensions.Options": "8.0.2" + } + }, "Microsoft.Testing.Extensions.Telemetry": { "type": "Transitive", "resolved": "1.9.1", @@ -868,7 +1023,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/test/UnitTests/packages.linux-x64.lock.json b/test/UnitTests/packages.linux-x64.lock.json index 90126b0..97ad0e8 100644 --- a/test/UnitTests/packages.linux-x64.lock.json +++ b/test/UnitTests/packages.linux-x64.lock.json @@ -2,6 +2,28 @@ "version": 1, "dependencies": { "net10.0": { + "Microsoft.Extensions.Diagnostics": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "NLXI3PbTe39q6/sgs7JYhmfPf7bMzReUoAJ0q9Po6yhfM+0anZa7PrEva4W2SdiLWGyB9eKZS9THGt2BP40xJg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Diagnostics.Abstractions": "10.0.9", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.9" + } + }, + "Microsoft.Extensions.Diagnostics.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "TEQTZklstvSx7/W+qom54+NlExkJAIOXeO3OMt/6zBAtBf14G+X3/vVUU1SyjNiNXiaOkYy/MGuyVXHG7/lX4Q==", + "dependencies": { + "Microsoft.Extensions.Logging": "10.0.1", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.1", + "Microsoft.Extensions.Telemetry.Abstractions": "10.1.0" + } + }, "Microsoft.Extensions.TimeProvider.Testing": { "type": "Direct", "requested": "[10.1.0, )", @@ -105,12 +127,39 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Compliance.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "M3JWrgZMkVzyEybZzNkTiC/e8U1ipXTi8xm8bj+PHHp4AcEmhmIEqnxRS0VHVCKZjLkOPt2hY2CIisUFQ6gqLA==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.1", + "Microsoft.Extensions.ObjectPool": "10.0.1" + } + }, + "Microsoft.Extensions.Configuration": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "woZsWLhOQsASuxbmgiZJqiGUBNo3IjRdXC92xt8rRokza+P6/nIsnzq7sm9Or6ZYcRl2kL1ufj8HVzp1QlPTXw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Configuration.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "3lE/iLSutpgX1CC0NOW70FJoGARRHbyKmG7dc0klnUZ9Dd9hS6N/POPWhKhMLCEuNN5nXEY5agmlFtH562vqhQ==", + "resolved": "10.0.9", + "contentHash": "qGhRPd3VxfLV9UqatVOiD9mAeUbj2KiMwGFYC5uXlzExiZQoe4X/hdmzGIU7BQjNLTqCnnbTHVyBglG3668/HA==", "dependencies": { - "Microsoft.Extensions.Primitives": "8.0.0" + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, + "Microsoft.Extensions.Configuration.Binder": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Tp/+LPb70RyjjtLg9m5C959eP4KrUpJHThZfAegZVpsfmGvzfuNkuYbI/ft+LvXhMSyUcAeOPaN6rzTccwnZAg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9" } }, "Microsoft.Extensions.DependencyInjection": { @@ -128,11 +177,11 @@ }, "Microsoft.Extensions.Diagnostics.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "JHYCQG7HmugNYUhOl368g+NMxYE/N/AiclCYRNlgCY9eVyiBkOHMwK4x60RYMxv9EL3+rmj1mqHvdCiPpC+D4Q==", + "resolved": "10.0.9", + "contentHash": "86RgyFsmVslW4Nu28IXgt8tLglynGQrwjk/xhGZaTe8j6YIeR1Ywoc42hSHsBSl920CQdfqq2dBohZiGm3AkUA==", "dependencies": { - "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0", - "Microsoft.Extensions.Options": "8.0.0" + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9" } }, "Microsoft.Extensions.FileProviders.Abstractions": { @@ -173,6 +222,11 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9" } }, + "Microsoft.Extensions.ObjectPool": { + "type": "Transitive", + "resolved": "10.0.1", + "contentHash": "HqAEbtoAhgvH53c54IV5e4vQ60PYvl7Z/WIHsbet+UGGE7n+7dwVNXw1mb9LZlWbsxnupCevvtgIne5P//ZKpQ==" + }, "Microsoft.Extensions.Options": { "type": "Transitive", "resolved": "10.0.9", @@ -182,11 +236,34 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Options.ConfigurationExtensions": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Y4E24zffF/aPS0igNvY6ZzAQfbxd6AYdC9L4brnH+uK0yYYHIR6FeGVQVVjAOo8wub1EQDl2B90lCcpqoTF7Yw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Configuration.Binder": "10.0.9", + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Primitives": { "type": "Transitive", "resolved": "10.0.9", "contentHash": "fmEbAUFsaIKirgLt/lYhuFRBwhcSJN31jjHgCdbQxJiWOum6EdLjkbgGuukSP9z/a+9LibaxII/kF+GwOXgC4g==" }, + "Microsoft.Extensions.Telemetry.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "0jAF2b0YJ1LOtunmo3PzSoJOx/ThhcGH5Y5kaV0jeM0BUlyr9orjg+fH5YabqnPSmwcN/DSTj0iZ7UwDISn5ag==", + "dependencies": { + "Microsoft.Extensions.Compliance.Abstractions": "10.1.0", + "Microsoft.Extensions.Logging.Abstractions": "10.0.1", + "Microsoft.Extensions.ObjectPool": "10.0.1", + "Microsoft.Extensions.Options": "10.0.1" + } + }, "Microsoft.Testing.Extensions.Telemetry": { "type": "Transitive", "resolved": "1.9.1", @@ -440,6 +517,28 @@ } }, "net8.0": { + "Microsoft.Extensions.Diagnostics": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "NLXI3PbTe39q6/sgs7JYhmfPf7bMzReUoAJ0q9Po6yhfM+0anZa7PrEva4W2SdiLWGyB9eKZS9THGt2BP40xJg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Diagnostics.Abstractions": "10.0.9", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.9" + } + }, + "Microsoft.Extensions.Diagnostics.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "TEQTZklstvSx7/W+qom54+NlExkJAIOXeO3OMt/6zBAtBf14G+X3/vVUU1SyjNiNXiaOkYy/MGuyVXHG7/lX4Q==", + "dependencies": { + "Microsoft.Extensions.Logging": "8.0.1", + "Microsoft.Extensions.Options.ConfigurationExtensions": "8.0.0", + "Microsoft.Extensions.Telemetry.Abstractions": "10.1.0" + } + }, "Microsoft.Extensions.TimeProvider.Testing": { "type": "Direct", "requested": "[10.1.0, )", @@ -543,12 +642,39 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Compliance.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "M3JWrgZMkVzyEybZzNkTiC/e8U1ipXTi8xm8bj+PHHp4AcEmhmIEqnxRS0VHVCKZjLkOPt2hY2CIisUFQ6gqLA==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.2", + "Microsoft.Extensions.ObjectPool": "8.0.22" + } + }, + "Microsoft.Extensions.Configuration": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "woZsWLhOQsASuxbmgiZJqiGUBNo3IjRdXC92xt8rRokza+P6/nIsnzq7sm9Or6ZYcRl2kL1ufj8HVzp1QlPTXw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Configuration.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "3lE/iLSutpgX1CC0NOW70FJoGARRHbyKmG7dc0klnUZ9Dd9hS6N/POPWhKhMLCEuNN5nXEY5agmlFtH562vqhQ==", + "resolved": "10.0.9", + "contentHash": "qGhRPd3VxfLV9UqatVOiD9mAeUbj2KiMwGFYC5uXlzExiZQoe4X/hdmzGIU7BQjNLTqCnnbTHVyBglG3668/HA==", "dependencies": { - "Microsoft.Extensions.Primitives": "8.0.0" + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, + "Microsoft.Extensions.Configuration.Binder": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Tp/+LPb70RyjjtLg9m5C959eP4KrUpJHThZfAegZVpsfmGvzfuNkuYbI/ft+LvXhMSyUcAeOPaN6rzTccwnZAg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9" } }, "Microsoft.Extensions.DependencyInjection": { @@ -566,11 +692,12 @@ }, "Microsoft.Extensions.Diagnostics.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "JHYCQG7HmugNYUhOl368g+NMxYE/N/AiclCYRNlgCY9eVyiBkOHMwK4x60RYMxv9EL3+rmj1mqHvdCiPpC+D4Q==", + "resolved": "10.0.9", + "contentHash": "86RgyFsmVslW4Nu28IXgt8tLglynGQrwjk/xhGZaTe8j6YIeR1Ywoc42hSHsBSl920CQdfqq2dBohZiGm3AkUA==", "dependencies": { - "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0", - "Microsoft.Extensions.Options": "8.0.0" + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9", + "System.Diagnostics.DiagnosticSource": "10.0.9" } }, "Microsoft.Extensions.FileProviders.Abstractions": { @@ -612,6 +739,11 @@ "System.Diagnostics.DiagnosticSource": "10.0.9" } }, + "Microsoft.Extensions.ObjectPool": { + "type": "Transitive", + "resolved": "8.0.22", + "contentHash": "4K7MUXbEDtVHTa/OYlkDya2kHSflojuD4d6dcmvnGYnvuJQ0bfylWbMTkA65N94SdTGo5zdkXR8T9mEED7RUvQ==" + }, "Microsoft.Extensions.Options": { "type": "Transitive", "resolved": "10.0.9", @@ -621,11 +753,34 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Options.ConfigurationExtensions": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Y4E24zffF/aPS0igNvY6ZzAQfbxd6AYdC9L4brnH+uK0yYYHIR6FeGVQVVjAOo8wub1EQDl2B90lCcpqoTF7Yw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Configuration.Binder": "10.0.9", + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Primitives": { "type": "Transitive", "resolved": "10.0.9", "contentHash": "fmEbAUFsaIKirgLt/lYhuFRBwhcSJN31jjHgCdbQxJiWOum6EdLjkbgGuukSP9z/a+9LibaxII/kF+GwOXgC4g==" }, + "Microsoft.Extensions.Telemetry.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "0jAF2b0YJ1LOtunmo3PzSoJOx/ThhcGH5Y5kaV0jeM0BUlyr9orjg+fH5YabqnPSmwcN/DSTj0iZ7UwDISn5ag==", + "dependencies": { + "Microsoft.Extensions.Compliance.Abstractions": "10.1.0", + "Microsoft.Extensions.Logging.Abstractions": "8.0.3", + "Microsoft.Extensions.ObjectPool": "8.0.22", + "Microsoft.Extensions.Options": "8.0.2" + } + }, "Microsoft.Testing.Extensions.Telemetry": { "type": "Transitive", "resolved": "1.9.1", @@ -868,7 +1023,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/test/UnitTests/packages.osx-arm64.lock.json b/test/UnitTests/packages.osx-arm64.lock.json index 90126b0..97ad0e8 100644 --- a/test/UnitTests/packages.osx-arm64.lock.json +++ b/test/UnitTests/packages.osx-arm64.lock.json @@ -2,6 +2,28 @@ "version": 1, "dependencies": { "net10.0": { + "Microsoft.Extensions.Diagnostics": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "NLXI3PbTe39q6/sgs7JYhmfPf7bMzReUoAJ0q9Po6yhfM+0anZa7PrEva4W2SdiLWGyB9eKZS9THGt2BP40xJg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Diagnostics.Abstractions": "10.0.9", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.9" + } + }, + "Microsoft.Extensions.Diagnostics.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "TEQTZklstvSx7/W+qom54+NlExkJAIOXeO3OMt/6zBAtBf14G+X3/vVUU1SyjNiNXiaOkYy/MGuyVXHG7/lX4Q==", + "dependencies": { + "Microsoft.Extensions.Logging": "10.0.1", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.1", + "Microsoft.Extensions.Telemetry.Abstractions": "10.1.0" + } + }, "Microsoft.Extensions.TimeProvider.Testing": { "type": "Direct", "requested": "[10.1.0, )", @@ -105,12 +127,39 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Compliance.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "M3JWrgZMkVzyEybZzNkTiC/e8U1ipXTi8xm8bj+PHHp4AcEmhmIEqnxRS0VHVCKZjLkOPt2hY2CIisUFQ6gqLA==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.1", + "Microsoft.Extensions.ObjectPool": "10.0.1" + } + }, + "Microsoft.Extensions.Configuration": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "woZsWLhOQsASuxbmgiZJqiGUBNo3IjRdXC92xt8rRokza+P6/nIsnzq7sm9Or6ZYcRl2kL1ufj8HVzp1QlPTXw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Configuration.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "3lE/iLSutpgX1CC0NOW70FJoGARRHbyKmG7dc0klnUZ9Dd9hS6N/POPWhKhMLCEuNN5nXEY5agmlFtH562vqhQ==", + "resolved": "10.0.9", + "contentHash": "qGhRPd3VxfLV9UqatVOiD9mAeUbj2KiMwGFYC5uXlzExiZQoe4X/hdmzGIU7BQjNLTqCnnbTHVyBglG3668/HA==", "dependencies": { - "Microsoft.Extensions.Primitives": "8.0.0" + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, + "Microsoft.Extensions.Configuration.Binder": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Tp/+LPb70RyjjtLg9m5C959eP4KrUpJHThZfAegZVpsfmGvzfuNkuYbI/ft+LvXhMSyUcAeOPaN6rzTccwnZAg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9" } }, "Microsoft.Extensions.DependencyInjection": { @@ -128,11 +177,11 @@ }, "Microsoft.Extensions.Diagnostics.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "JHYCQG7HmugNYUhOl368g+NMxYE/N/AiclCYRNlgCY9eVyiBkOHMwK4x60RYMxv9EL3+rmj1mqHvdCiPpC+D4Q==", + "resolved": "10.0.9", + "contentHash": "86RgyFsmVslW4Nu28IXgt8tLglynGQrwjk/xhGZaTe8j6YIeR1Ywoc42hSHsBSl920CQdfqq2dBohZiGm3AkUA==", "dependencies": { - "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0", - "Microsoft.Extensions.Options": "8.0.0" + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9" } }, "Microsoft.Extensions.FileProviders.Abstractions": { @@ -173,6 +222,11 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9" } }, + "Microsoft.Extensions.ObjectPool": { + "type": "Transitive", + "resolved": "10.0.1", + "contentHash": "HqAEbtoAhgvH53c54IV5e4vQ60PYvl7Z/WIHsbet+UGGE7n+7dwVNXw1mb9LZlWbsxnupCevvtgIne5P//ZKpQ==" + }, "Microsoft.Extensions.Options": { "type": "Transitive", "resolved": "10.0.9", @@ -182,11 +236,34 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Options.ConfigurationExtensions": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Y4E24zffF/aPS0igNvY6ZzAQfbxd6AYdC9L4brnH+uK0yYYHIR6FeGVQVVjAOo8wub1EQDl2B90lCcpqoTF7Yw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Configuration.Binder": "10.0.9", + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Primitives": { "type": "Transitive", "resolved": "10.0.9", "contentHash": "fmEbAUFsaIKirgLt/lYhuFRBwhcSJN31jjHgCdbQxJiWOum6EdLjkbgGuukSP9z/a+9LibaxII/kF+GwOXgC4g==" }, + "Microsoft.Extensions.Telemetry.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "0jAF2b0YJ1LOtunmo3PzSoJOx/ThhcGH5Y5kaV0jeM0BUlyr9orjg+fH5YabqnPSmwcN/DSTj0iZ7UwDISn5ag==", + "dependencies": { + "Microsoft.Extensions.Compliance.Abstractions": "10.1.0", + "Microsoft.Extensions.Logging.Abstractions": "10.0.1", + "Microsoft.Extensions.ObjectPool": "10.0.1", + "Microsoft.Extensions.Options": "10.0.1" + } + }, "Microsoft.Testing.Extensions.Telemetry": { "type": "Transitive", "resolved": "1.9.1", @@ -440,6 +517,28 @@ } }, "net8.0": { + "Microsoft.Extensions.Diagnostics": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "NLXI3PbTe39q6/sgs7JYhmfPf7bMzReUoAJ0q9Po6yhfM+0anZa7PrEva4W2SdiLWGyB9eKZS9THGt2BP40xJg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Diagnostics.Abstractions": "10.0.9", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.9" + } + }, + "Microsoft.Extensions.Diagnostics.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "TEQTZklstvSx7/W+qom54+NlExkJAIOXeO3OMt/6zBAtBf14G+X3/vVUU1SyjNiNXiaOkYy/MGuyVXHG7/lX4Q==", + "dependencies": { + "Microsoft.Extensions.Logging": "8.0.1", + "Microsoft.Extensions.Options.ConfigurationExtensions": "8.0.0", + "Microsoft.Extensions.Telemetry.Abstractions": "10.1.0" + } + }, "Microsoft.Extensions.TimeProvider.Testing": { "type": "Direct", "requested": "[10.1.0, )", @@ -543,12 +642,39 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Compliance.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "M3JWrgZMkVzyEybZzNkTiC/e8U1ipXTi8xm8bj+PHHp4AcEmhmIEqnxRS0VHVCKZjLkOPt2hY2CIisUFQ6gqLA==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.2", + "Microsoft.Extensions.ObjectPool": "8.0.22" + } + }, + "Microsoft.Extensions.Configuration": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "woZsWLhOQsASuxbmgiZJqiGUBNo3IjRdXC92xt8rRokza+P6/nIsnzq7sm9Or6ZYcRl2kL1ufj8HVzp1QlPTXw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Configuration.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "3lE/iLSutpgX1CC0NOW70FJoGARRHbyKmG7dc0klnUZ9Dd9hS6N/POPWhKhMLCEuNN5nXEY5agmlFtH562vqhQ==", + "resolved": "10.0.9", + "contentHash": "qGhRPd3VxfLV9UqatVOiD9mAeUbj2KiMwGFYC5uXlzExiZQoe4X/hdmzGIU7BQjNLTqCnnbTHVyBglG3668/HA==", "dependencies": { - "Microsoft.Extensions.Primitives": "8.0.0" + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, + "Microsoft.Extensions.Configuration.Binder": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Tp/+LPb70RyjjtLg9m5C959eP4KrUpJHThZfAegZVpsfmGvzfuNkuYbI/ft+LvXhMSyUcAeOPaN6rzTccwnZAg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9" } }, "Microsoft.Extensions.DependencyInjection": { @@ -566,11 +692,12 @@ }, "Microsoft.Extensions.Diagnostics.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "JHYCQG7HmugNYUhOl368g+NMxYE/N/AiclCYRNlgCY9eVyiBkOHMwK4x60RYMxv9EL3+rmj1mqHvdCiPpC+D4Q==", + "resolved": "10.0.9", + "contentHash": "86RgyFsmVslW4Nu28IXgt8tLglynGQrwjk/xhGZaTe8j6YIeR1Ywoc42hSHsBSl920CQdfqq2dBohZiGm3AkUA==", "dependencies": { - "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0", - "Microsoft.Extensions.Options": "8.0.0" + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9", + "System.Diagnostics.DiagnosticSource": "10.0.9" } }, "Microsoft.Extensions.FileProviders.Abstractions": { @@ -612,6 +739,11 @@ "System.Diagnostics.DiagnosticSource": "10.0.9" } }, + "Microsoft.Extensions.ObjectPool": { + "type": "Transitive", + "resolved": "8.0.22", + "contentHash": "4K7MUXbEDtVHTa/OYlkDya2kHSflojuD4d6dcmvnGYnvuJQ0bfylWbMTkA65N94SdTGo5zdkXR8T9mEED7RUvQ==" + }, "Microsoft.Extensions.Options": { "type": "Transitive", "resolved": "10.0.9", @@ -621,11 +753,34 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Options.ConfigurationExtensions": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Y4E24zffF/aPS0igNvY6ZzAQfbxd6AYdC9L4brnH+uK0yYYHIR6FeGVQVVjAOo8wub1EQDl2B90lCcpqoTF7Yw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Configuration.Binder": "10.0.9", + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Primitives": { "type": "Transitive", "resolved": "10.0.9", "contentHash": "fmEbAUFsaIKirgLt/lYhuFRBwhcSJN31jjHgCdbQxJiWOum6EdLjkbgGuukSP9z/a+9LibaxII/kF+GwOXgC4g==" }, + "Microsoft.Extensions.Telemetry.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "0jAF2b0YJ1LOtunmo3PzSoJOx/ThhcGH5Y5kaV0jeM0BUlyr9orjg+fH5YabqnPSmwcN/DSTj0iZ7UwDISn5ag==", + "dependencies": { + "Microsoft.Extensions.Compliance.Abstractions": "10.1.0", + "Microsoft.Extensions.Logging.Abstractions": "8.0.3", + "Microsoft.Extensions.ObjectPool": "8.0.22", + "Microsoft.Extensions.Options": "8.0.2" + } + }, "Microsoft.Testing.Extensions.Telemetry": { "type": "Transitive", "resolved": "1.9.1", @@ -868,7 +1023,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/test/UnitTests/packages.win-x64.lock.json b/test/UnitTests/packages.win-x64.lock.json index 90126b0..97ad0e8 100644 --- a/test/UnitTests/packages.win-x64.lock.json +++ b/test/UnitTests/packages.win-x64.lock.json @@ -2,6 +2,28 @@ "version": 1, "dependencies": { "net10.0": { + "Microsoft.Extensions.Diagnostics": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "NLXI3PbTe39q6/sgs7JYhmfPf7bMzReUoAJ0q9Po6yhfM+0anZa7PrEva4W2SdiLWGyB9eKZS9THGt2BP40xJg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Diagnostics.Abstractions": "10.0.9", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.9" + } + }, + "Microsoft.Extensions.Diagnostics.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "TEQTZklstvSx7/W+qom54+NlExkJAIOXeO3OMt/6zBAtBf14G+X3/vVUU1SyjNiNXiaOkYy/MGuyVXHG7/lX4Q==", + "dependencies": { + "Microsoft.Extensions.Logging": "10.0.1", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.1", + "Microsoft.Extensions.Telemetry.Abstractions": "10.1.0" + } + }, "Microsoft.Extensions.TimeProvider.Testing": { "type": "Direct", "requested": "[10.1.0, )", @@ -105,12 +127,39 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Compliance.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "M3JWrgZMkVzyEybZzNkTiC/e8U1ipXTi8xm8bj+PHHp4AcEmhmIEqnxRS0VHVCKZjLkOPt2hY2CIisUFQ6gqLA==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.1", + "Microsoft.Extensions.ObjectPool": "10.0.1" + } + }, + "Microsoft.Extensions.Configuration": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "woZsWLhOQsASuxbmgiZJqiGUBNo3IjRdXC92xt8rRokza+P6/nIsnzq7sm9Or6ZYcRl2kL1ufj8HVzp1QlPTXw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Configuration.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "3lE/iLSutpgX1CC0NOW70FJoGARRHbyKmG7dc0klnUZ9Dd9hS6N/POPWhKhMLCEuNN5nXEY5agmlFtH562vqhQ==", + "resolved": "10.0.9", + "contentHash": "qGhRPd3VxfLV9UqatVOiD9mAeUbj2KiMwGFYC5uXlzExiZQoe4X/hdmzGIU7BQjNLTqCnnbTHVyBglG3668/HA==", "dependencies": { - "Microsoft.Extensions.Primitives": "8.0.0" + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, + "Microsoft.Extensions.Configuration.Binder": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Tp/+LPb70RyjjtLg9m5C959eP4KrUpJHThZfAegZVpsfmGvzfuNkuYbI/ft+LvXhMSyUcAeOPaN6rzTccwnZAg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9" } }, "Microsoft.Extensions.DependencyInjection": { @@ -128,11 +177,11 @@ }, "Microsoft.Extensions.Diagnostics.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "JHYCQG7HmugNYUhOl368g+NMxYE/N/AiclCYRNlgCY9eVyiBkOHMwK4x60RYMxv9EL3+rmj1mqHvdCiPpC+D4Q==", + "resolved": "10.0.9", + "contentHash": "86RgyFsmVslW4Nu28IXgt8tLglynGQrwjk/xhGZaTe8j6YIeR1Ywoc42hSHsBSl920CQdfqq2dBohZiGm3AkUA==", "dependencies": { - "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0", - "Microsoft.Extensions.Options": "8.0.0" + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9" } }, "Microsoft.Extensions.FileProviders.Abstractions": { @@ -173,6 +222,11 @@ "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9" } }, + "Microsoft.Extensions.ObjectPool": { + "type": "Transitive", + "resolved": "10.0.1", + "contentHash": "HqAEbtoAhgvH53c54IV5e4vQ60PYvl7Z/WIHsbet+UGGE7n+7dwVNXw1mb9LZlWbsxnupCevvtgIne5P//ZKpQ==" + }, "Microsoft.Extensions.Options": { "type": "Transitive", "resolved": "10.0.9", @@ -182,11 +236,34 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Options.ConfigurationExtensions": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Y4E24zffF/aPS0igNvY6ZzAQfbxd6AYdC9L4brnH+uK0yYYHIR6FeGVQVVjAOo8wub1EQDl2B90lCcpqoTF7Yw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Configuration.Binder": "10.0.9", + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Primitives": { "type": "Transitive", "resolved": "10.0.9", "contentHash": "fmEbAUFsaIKirgLt/lYhuFRBwhcSJN31jjHgCdbQxJiWOum6EdLjkbgGuukSP9z/a+9LibaxII/kF+GwOXgC4g==" }, + "Microsoft.Extensions.Telemetry.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "0jAF2b0YJ1LOtunmo3PzSoJOx/ThhcGH5Y5kaV0jeM0BUlyr9orjg+fH5YabqnPSmwcN/DSTj0iZ7UwDISn5ag==", + "dependencies": { + "Microsoft.Extensions.Compliance.Abstractions": "10.1.0", + "Microsoft.Extensions.Logging.Abstractions": "10.0.1", + "Microsoft.Extensions.ObjectPool": "10.0.1", + "Microsoft.Extensions.Options": "10.0.1" + } + }, "Microsoft.Testing.Extensions.Telemetry": { "type": "Transitive", "resolved": "1.9.1", @@ -440,6 +517,28 @@ } }, "net8.0": { + "Microsoft.Extensions.Diagnostics": { + "type": "Direct", + "requested": "[10.0.9, )", + "resolved": "10.0.9", + "contentHash": "NLXI3PbTe39q6/sgs7JYhmfPf7bMzReUoAJ0q9Po6yhfM+0anZa7PrEva4W2SdiLWGyB9eKZS9THGt2BP40xJg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Diagnostics.Abstractions": "10.0.9", + "Microsoft.Extensions.Options.ConfigurationExtensions": "10.0.9" + } + }, + "Microsoft.Extensions.Diagnostics.Testing": { + "type": "Direct", + "requested": "[10.1.0, )", + "resolved": "10.1.0", + "contentHash": "TEQTZklstvSx7/W+qom54+NlExkJAIOXeO3OMt/6zBAtBf14G+X3/vVUU1SyjNiNXiaOkYy/MGuyVXHG7/lX4Q==", + "dependencies": { + "Microsoft.Extensions.Logging": "8.0.1", + "Microsoft.Extensions.Options.ConfigurationExtensions": "8.0.0", + "Microsoft.Extensions.Telemetry.Abstractions": "10.1.0" + } + }, "Microsoft.Extensions.TimeProvider.Testing": { "type": "Direct", "requested": "[10.1.0, )", @@ -543,12 +642,39 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Compliance.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "M3JWrgZMkVzyEybZzNkTiC/e8U1ipXTi8xm8bj+PHHp4AcEmhmIEqnxRS0VHVCKZjLkOPt2hY2CIisUFQ6gqLA==", + "dependencies": { + "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.2", + "Microsoft.Extensions.ObjectPool": "8.0.22" + } + }, + "Microsoft.Extensions.Configuration": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "woZsWLhOQsASuxbmgiZJqiGUBNo3IjRdXC92xt8rRokza+P6/nIsnzq7sm9Or6ZYcRl2kL1ufj8HVzp1QlPTXw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Configuration.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "3lE/iLSutpgX1CC0NOW70FJoGARRHbyKmG7dc0klnUZ9Dd9hS6N/POPWhKhMLCEuNN5nXEY5agmlFtH562vqhQ==", + "resolved": "10.0.9", + "contentHash": "qGhRPd3VxfLV9UqatVOiD9mAeUbj2KiMwGFYC5uXlzExiZQoe4X/hdmzGIU7BQjNLTqCnnbTHVyBglG3668/HA==", "dependencies": { - "Microsoft.Extensions.Primitives": "8.0.0" + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, + "Microsoft.Extensions.Configuration.Binder": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Tp/+LPb70RyjjtLg9m5C959eP4KrUpJHThZfAegZVpsfmGvzfuNkuYbI/ft+LvXhMSyUcAeOPaN6rzTccwnZAg==", + "dependencies": { + "Microsoft.Extensions.Configuration": "10.0.9", + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9" } }, "Microsoft.Extensions.DependencyInjection": { @@ -566,11 +692,12 @@ }, "Microsoft.Extensions.Diagnostics.Abstractions": { "type": "Transitive", - "resolved": "8.0.0", - "contentHash": "JHYCQG7HmugNYUhOl368g+NMxYE/N/AiclCYRNlgCY9eVyiBkOHMwK4x60RYMxv9EL3+rmj1mqHvdCiPpC+D4Q==", + "resolved": "10.0.9", + "contentHash": "86RgyFsmVslW4Nu28IXgt8tLglynGQrwjk/xhGZaTe8j6YIeR1Ywoc42hSHsBSl920CQdfqq2dBohZiGm3AkUA==", "dependencies": { - "Microsoft.Extensions.DependencyInjection.Abstractions": "8.0.0", - "Microsoft.Extensions.Options": "8.0.0" + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9", + "System.Diagnostics.DiagnosticSource": "10.0.9" } }, "Microsoft.Extensions.FileProviders.Abstractions": { @@ -612,6 +739,11 @@ "System.Diagnostics.DiagnosticSource": "10.0.9" } }, + "Microsoft.Extensions.ObjectPool": { + "type": "Transitive", + "resolved": "8.0.22", + "contentHash": "4K7MUXbEDtVHTa/OYlkDya2kHSflojuD4d6dcmvnGYnvuJQ0bfylWbMTkA65N94SdTGo5zdkXR8T9mEED7RUvQ==" + }, "Microsoft.Extensions.Options": { "type": "Transitive", "resolved": "10.0.9", @@ -621,11 +753,34 @@ "Microsoft.Extensions.Primitives": "10.0.9" } }, + "Microsoft.Extensions.Options.ConfigurationExtensions": { + "type": "Transitive", + "resolved": "10.0.9", + "contentHash": "Y4E24zffF/aPS0igNvY6ZzAQfbxd6AYdC9L4brnH+uK0yYYHIR6FeGVQVVjAOo8wub1EQDl2B90lCcpqoTF7Yw==", + "dependencies": { + "Microsoft.Extensions.Configuration.Abstractions": "10.0.9", + "Microsoft.Extensions.Configuration.Binder": "10.0.9", + "Microsoft.Extensions.DependencyInjection.Abstractions": "10.0.9", + "Microsoft.Extensions.Options": "10.0.9", + "Microsoft.Extensions.Primitives": "10.0.9" + } + }, "Microsoft.Extensions.Primitives": { "type": "Transitive", "resolved": "10.0.9", "contentHash": "fmEbAUFsaIKirgLt/lYhuFRBwhcSJN31jjHgCdbQxJiWOum6EdLjkbgGuukSP9z/a+9LibaxII/kF+GwOXgC4g==" }, + "Microsoft.Extensions.Telemetry.Abstractions": { + "type": "Transitive", + "resolved": "10.1.0", + "contentHash": "0jAF2b0YJ1LOtunmo3PzSoJOx/ThhcGH5Y5kaV0jeM0BUlyr9orjg+fH5YabqnPSmwcN/DSTj0iZ7UwDISn5ag==", + "dependencies": { + "Microsoft.Extensions.Compliance.Abstractions": "10.1.0", + "Microsoft.Extensions.Logging.Abstractions": "8.0.3", + "Microsoft.Extensions.ObjectPool": "8.0.22", + "Microsoft.Extensions.Options": "8.0.2" + } + }, "Microsoft.Testing.Extensions.Telemetry": { "type": "Transitive", "resolved": "1.9.1", @@ -868,7 +1023,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/util/Benchmarks/packages.linux-arm64.lock.json b/util/Benchmarks/packages.linux-arm64.lock.json index ae060cc..1777f00 100644 --- a/util/Benchmarks/packages.linux-arm64.lock.json +++ b/util/Benchmarks/packages.linux-arm64.lock.json @@ -494,7 +494,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } } diff --git a/util/Benchmarks/packages.linux-x64.lock.json b/util/Benchmarks/packages.linux-x64.lock.json index ae060cc..1777f00 100644 --- a/util/Benchmarks/packages.linux-x64.lock.json +++ b/util/Benchmarks/packages.linux-x64.lock.json @@ -494,7 +494,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } } diff --git a/util/Benchmarks/packages.osx-arm64.lock.json b/util/Benchmarks/packages.osx-arm64.lock.json index ae060cc..1777f00 100644 --- a/util/Benchmarks/packages.osx-arm64.lock.json +++ b/util/Benchmarks/packages.osx-arm64.lock.json @@ -494,7 +494,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } } diff --git a/util/Benchmarks/packages.win-x64.lock.json b/util/Benchmarks/packages.win-x64.lock.json index ae060cc..1777f00 100644 --- a/util/Benchmarks/packages.win-x64.lock.json +++ b/util/Benchmarks/packages.win-x64.lock.json @@ -494,7 +494,8 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[2.8.2, )", + "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } } diff --git a/util/ReadmeExample/DistributedCache.cs b/util/ReadmeExample/DistributedCache.cs index 48f43de..1a7e647 100644 --- a/util/ReadmeExample/DistributedCache.cs +++ b/util/ReadmeExample/DistributedCache.cs @@ -41,6 +41,13 @@ public static async Task RunAsync(string[] args) services.AddNatsClient(natsBuilder => natsBuilder.ConfigureOptions(optsBuilder => optsBuilder.Configure(opts => opts.Opts = opts.Opts with { Url = natsConnectionString }))); + + // The cache emits metrics and traces via System.Diagnostics; they are inert until a listener + // subscribes. To collect them, add the OpenTelemetry packages and register the names (see the + // Telemetry section of the README): + // services.AddOpenTelemetry() + // .WithMetrics(m => m.AddMeter(NatsCacheTelemetryNames.MeterName)) + // .WithTracing(t => t.AddSource(NatsCacheTelemetryNames.ActivitySourceName)); services.AddNatsDistributedCache(options => { options.BucketName = "cache"; From de04ae0f5d37b1ae2c9594a3c7d8547018985f49 Mon Sep 17 00:00:00 2001 From: Matthew DeVenny Date: Mon, 20 Jul 2026 14:18:37 -0700 Subject: [PATCH 2/4] Update nats.net Signed-off-by: Matthew DeVenny --- src/NatsDistributedCache/NatsCache.cs | 4 +- .../NatsDistributedCache.csproj | 2 +- src/NatsDistributedCache/NatsExtensions.cs | 10 + .../packages.linux-arm64.lock.json | 55 +++--- .../packages.linux-x64.lock.json | 55 +++--- .../packages.osx-arm64.lock.json | 55 +++--- .../packages.win-x64.lock.json | 55 +++--- .../packages.linux-arm64.lock.json | 55 +++--- .../packages.linux-x64.lock.json | 55 +++--- .../packages.osx-arm64.lock.json | 55 +++--- .../packages.win-x64.lock.json | 55 +++--- .../packages.linux-arm64.lock.json | 92 +++++---- .../packages.linux-x64.lock.json | 92 +++++---- .../packages.osx-arm64.lock.json | 92 +++++---- .../packages.win-x64.lock.json | 92 +++++---- test/TestUtils/TestUtils.csproj | 2 +- test/TestUtils/packages.linux-arm64.lock.json | 185 ++++++++++-------- test/TestUtils/packages.linux-x64.lock.json | 185 ++++++++++-------- test/TestUtils/packages.osx-arm64.lock.json | 185 ++++++++++-------- test/TestUtils/packages.win-x64.lock.json | 185 ++++++++++-------- test/UnitTests/packages.linux-arm64.lock.json | 185 ++++++++++-------- test/UnitTests/packages.linux-x64.lock.json | 185 ++++++++++-------- test/UnitTests/packages.osx-arm64.lock.json | 185 ++++++++++-------- test/UnitTests/packages.win-x64.lock.json | 185 ++++++++++-------- .../Benchmarks/packages.linux-arm64.lock.json | 55 +++--- util/Benchmarks/packages.linux-x64.lock.json | 55 +++--- util/Benchmarks/packages.osx-arm64.lock.json | 55 +++--- util/Benchmarks/packages.win-x64.lock.json | 55 +++--- util/NatsAppHost/Program.cs | 2 +- .../packages.linux-arm64.lock.json | 27 +-- util/NatsAppHost/packages.linux-x64.lock.json | 27 +-- util/NatsAppHost/packages.osx-arm64.lock.json | 27 +-- util/NatsAppHost/packages.win-x64.lock.json | 27 +-- util/PerfTest/PerfTest.csproj | 2 +- util/PerfTest/packages.linux-arm64.lock.json | 94 +++++---- util/PerfTest/packages.linux-x64.lock.json | 94 +++++---- util/PerfTest/packages.osx-arm64.lock.json | 94 +++++---- util/PerfTest/packages.win-x64.lock.json | 94 +++++---- util/ReadmeExample/ReadmeExample.csproj | 2 +- .../packages.linux-arm64.lock.json | 89 +++------ .../packages.linux-x64.lock.json | 89 +++------ .../packages.osx-arm64.lock.json | 89 +++------ util/ReadmeExample/packages.win-x64.lock.json | 89 +++------ .../packages.linux-arm64.lock.json | 27 +-- .../RedisAppHost/packages.linux-x64.lock.json | 27 +-- .../RedisAppHost/packages.osx-arm64.lock.json | 27 +-- util/RedisAppHost/packages.win-x64.lock.json | 27 +-- 47 files changed, 1896 insertions(+), 1584 deletions(-) diff --git a/src/NatsDistributedCache/NatsCache.cs b/src/NatsDistributedCache/NatsCache.cs index 18eecea..fec9c82 100644 --- a/src/NatsDistributedCache/NatsCache.cs +++ b/src/NatsDistributedCache/NatsCache.cs @@ -115,8 +115,7 @@ public async Task SetAsync( { var kvStore = await GetKvStore().ConfigureAwait(false); - // todo: remove cast after https://github.com/nats-io/nats.net/pull/852 is released - await ((NatsKVStore)kvStore) + await kvStore .PutWithTtlAsync(GetEncodedKey(key), entry, ttl ?? TimeSpan.Zero, CacheEntrySerializer, token) .ConfigureAwait(false); } @@ -532,7 +531,6 @@ async Task UpdateEntryExpirationAsync(NatsKVEntry kvEntry) if (ttl > TimeSpan.Zero) { // Use optimistic concurrency control with the last revision - // todo: remove cast after https://github.com/nats-io/nats.net/pull/852 is released await kvStore.UpdateWithTtlAsync( encodedKey, kvEntry.Value, diff --git a/src/NatsDistributedCache/NatsDistributedCache.csproj b/src/NatsDistributedCache/NatsDistributedCache.csproj index 3420a02..d6b07b0 100644 --- a/src/NatsDistributedCache/NatsDistributedCache.csproj +++ b/src/NatsDistributedCache/NatsDistributedCache.csproj @@ -31,7 +31,7 @@ - + diff --git a/src/NatsDistributedCache/NatsExtensions.cs b/src/NatsDistributedCache/NatsExtensions.cs index ba949e7..a0731b4 100644 --- a/src/NatsDistributedCache/NatsExtensions.cs +++ b/src/NatsDistributedCache/NatsExtensions.cs @@ -6,6 +6,16 @@ namespace CodeCargo.Nats.DistributedCache; +/// +/// Per-key TTL support for NATS KV put and update operations. +/// +/// +/// These publish to the KV subject directly with a Nats-TTL header because the client's own KV API +/// still has no TTL overload for put or update. As of NATS.Net 3.0.1 native TTL covers only +/// CreateAsync, TryCreateAsync and PurgeAsync; the update-with-TTL work from +/// nats-io/nats.net#852 was backed out. Re-check on future NATS.Net upgrades — once +/// PutAsync/UpdateAsync gain TTL overloads, this class can be deleted in favor of them. +/// public static class NatsExtensions { private const string NatsExpectedLastSubjectSequence = "Nats-Expected-Last-Subject-Sequence"; diff --git a/src/NatsDistributedCache/packages.linux-arm64.lock.json b/src/NatsDistributedCache/packages.linux-arm64.lock.json index 91ac3b8..c94be27 100644 --- a/src/NatsDistributedCache/packages.linux-arm64.lock.json +++ b/src/NatsDistributedCache/packages.linux-arm64.lock.json @@ -43,11 +43,11 @@ }, "NATS.Client.KeyValueStore": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "StyleCop.Analyzers": { @@ -90,26 +90,29 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.NKeys": { @@ -171,11 +174,11 @@ }, "NATS.Client.KeyValueStore": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "StyleCop.Analyzers": { @@ -218,27 +221,31 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.NKeys": { diff --git a/src/NatsDistributedCache/packages.linux-x64.lock.json b/src/NatsDistributedCache/packages.linux-x64.lock.json index 91ac3b8..c94be27 100644 --- a/src/NatsDistributedCache/packages.linux-x64.lock.json +++ b/src/NatsDistributedCache/packages.linux-x64.lock.json @@ -43,11 +43,11 @@ }, "NATS.Client.KeyValueStore": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "StyleCop.Analyzers": { @@ -90,26 +90,29 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.NKeys": { @@ -171,11 +174,11 @@ }, "NATS.Client.KeyValueStore": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "StyleCop.Analyzers": { @@ -218,27 +221,31 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.NKeys": { diff --git a/src/NatsDistributedCache/packages.osx-arm64.lock.json b/src/NatsDistributedCache/packages.osx-arm64.lock.json index 91ac3b8..c94be27 100644 --- a/src/NatsDistributedCache/packages.osx-arm64.lock.json +++ b/src/NatsDistributedCache/packages.osx-arm64.lock.json @@ -43,11 +43,11 @@ }, "NATS.Client.KeyValueStore": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "StyleCop.Analyzers": { @@ -90,26 +90,29 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.NKeys": { @@ -171,11 +174,11 @@ }, "NATS.Client.KeyValueStore": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "StyleCop.Analyzers": { @@ -218,27 +221,31 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.NKeys": { diff --git a/src/NatsDistributedCache/packages.win-x64.lock.json b/src/NatsDistributedCache/packages.win-x64.lock.json index 91ac3b8..c94be27 100644 --- a/src/NatsDistributedCache/packages.win-x64.lock.json +++ b/src/NatsDistributedCache/packages.win-x64.lock.json @@ -43,11 +43,11 @@ }, "NATS.Client.KeyValueStore": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "StyleCop.Analyzers": { @@ -90,26 +90,29 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.NKeys": { @@ -171,11 +174,11 @@ }, "NATS.Client.KeyValueStore": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "StyleCop.Analyzers": { @@ -218,27 +221,31 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.NKeys": { diff --git a/src/NatsHybridCacheExtensions/packages.linux-arm64.lock.json b/src/NatsHybridCacheExtensions/packages.linux-arm64.lock.json index ae7d0ba..597e28b 100644 --- a/src/NatsHybridCacheExtensions/packages.linux-arm64.lock.json +++ b/src/NatsHybridCacheExtensions/packages.linux-arm64.lock.json @@ -96,34 +96,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -147,7 +150,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } } }, @@ -247,35 +250,39 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -309,7 +316,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } diff --git a/src/NatsHybridCacheExtensions/packages.linux-x64.lock.json b/src/NatsHybridCacheExtensions/packages.linux-x64.lock.json index ae7d0ba..597e28b 100644 --- a/src/NatsHybridCacheExtensions/packages.linux-x64.lock.json +++ b/src/NatsHybridCacheExtensions/packages.linux-x64.lock.json @@ -96,34 +96,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -147,7 +150,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } } }, @@ -247,35 +250,39 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -309,7 +316,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } diff --git a/src/NatsHybridCacheExtensions/packages.osx-arm64.lock.json b/src/NatsHybridCacheExtensions/packages.osx-arm64.lock.json index ae7d0ba..597e28b 100644 --- a/src/NatsHybridCacheExtensions/packages.osx-arm64.lock.json +++ b/src/NatsHybridCacheExtensions/packages.osx-arm64.lock.json @@ -96,34 +96,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -147,7 +150,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } } }, @@ -247,35 +250,39 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -309,7 +316,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } diff --git a/src/NatsHybridCacheExtensions/packages.win-x64.lock.json b/src/NatsHybridCacheExtensions/packages.win-x64.lock.json index ae7d0ba..597e28b 100644 --- a/src/NatsHybridCacheExtensions/packages.win-x64.lock.json +++ b/src/NatsHybridCacheExtensions/packages.win-x64.lock.json @@ -96,34 +96,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -147,7 +150,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } } }, @@ -247,35 +250,39 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -309,7 +316,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } diff --git a/test/IntegrationTests/packages.linux-arm64.lock.json b/test/IntegrationTests/packages.linux-arm64.lock.json index e815c20..445778b 100644 --- a/test/IntegrationTests/packages.linux-arm64.lock.json +++ b/test/IntegrationTests/packages.linux-arm64.lock.json @@ -848,91 +848,105 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.Net": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "NATS.NKeys": { @@ -1153,7 +1167,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -1177,7 +1191,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } diff --git a/test/IntegrationTests/packages.linux-x64.lock.json b/test/IntegrationTests/packages.linux-x64.lock.json index 2cbec24..d74fbcd 100644 --- a/test/IntegrationTests/packages.linux-x64.lock.json +++ b/test/IntegrationTests/packages.linux-x64.lock.json @@ -848,91 +848,105 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.Net": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "NATS.NKeys": { @@ -1153,7 +1167,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -1177,7 +1191,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } diff --git a/test/IntegrationTests/packages.osx-arm64.lock.json b/test/IntegrationTests/packages.osx-arm64.lock.json index 543a99c..c7e7dd4 100644 --- a/test/IntegrationTests/packages.osx-arm64.lock.json +++ b/test/IntegrationTests/packages.osx-arm64.lock.json @@ -848,91 +848,105 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.Net": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "NATS.NKeys": { @@ -1153,7 +1167,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -1177,7 +1191,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } diff --git a/test/IntegrationTests/packages.win-x64.lock.json b/test/IntegrationTests/packages.win-x64.lock.json index 41925d4..67208ab 100644 --- a/test/IntegrationTests/packages.win-x64.lock.json +++ b/test/IntegrationTests/packages.win-x64.lock.json @@ -848,91 +848,105 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.Net": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "NATS.NKeys": { @@ -1153,7 +1167,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -1177,7 +1191,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } diff --git a/test/TestUtils/TestUtils.csproj b/test/TestUtils/TestUtils.csproj index d6c1aa8..8b37cdd 100644 --- a/test/TestUtils/TestUtils.csproj +++ b/test/TestUtils/TestUtils.csproj @@ -6,7 +6,7 @@ - + diff --git a/test/TestUtils/packages.linux-arm64.lock.json b/test/TestUtils/packages.linux-arm64.lock.json index a87a19d..8cf571c 100644 --- a/test/TestUtils/packages.linux-arm64.lock.json +++ b/test/TestUtils/packages.linux-arm64.lock.json @@ -15,18 +15,19 @@ }, "NATS.Net": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "StyleCop.Analyzers": { @@ -163,76 +164,89 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.NKeys": { @@ -259,7 +273,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -284,18 +298,19 @@ }, "NATS.Net": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "StyleCop.Analyzers": { @@ -433,77 +448,91 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.NKeys": { @@ -540,7 +569,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, diff --git a/test/TestUtils/packages.linux-x64.lock.json b/test/TestUtils/packages.linux-x64.lock.json index a87a19d..8cf571c 100644 --- a/test/TestUtils/packages.linux-x64.lock.json +++ b/test/TestUtils/packages.linux-x64.lock.json @@ -15,18 +15,19 @@ }, "NATS.Net": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "StyleCop.Analyzers": { @@ -163,76 +164,89 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.NKeys": { @@ -259,7 +273,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -284,18 +298,19 @@ }, "NATS.Net": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "StyleCop.Analyzers": { @@ -433,77 +448,91 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.NKeys": { @@ -540,7 +569,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, diff --git a/test/TestUtils/packages.osx-arm64.lock.json b/test/TestUtils/packages.osx-arm64.lock.json index a87a19d..8cf571c 100644 --- a/test/TestUtils/packages.osx-arm64.lock.json +++ b/test/TestUtils/packages.osx-arm64.lock.json @@ -15,18 +15,19 @@ }, "NATS.Net": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "StyleCop.Analyzers": { @@ -163,76 +164,89 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.NKeys": { @@ -259,7 +273,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -284,18 +298,19 @@ }, "NATS.Net": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "StyleCop.Analyzers": { @@ -433,77 +448,91 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.NKeys": { @@ -540,7 +569,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, diff --git a/test/TestUtils/packages.win-x64.lock.json b/test/TestUtils/packages.win-x64.lock.json index a87a19d..8cf571c 100644 --- a/test/TestUtils/packages.win-x64.lock.json +++ b/test/TestUtils/packages.win-x64.lock.json @@ -15,18 +15,19 @@ }, "NATS.Net": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "StyleCop.Analyzers": { @@ -163,76 +164,89 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.NKeys": { @@ -259,7 +273,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -284,18 +298,19 @@ }, "NATS.Net": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "StyleCop.Analyzers": { @@ -433,77 +448,91 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.NKeys": { @@ -540,7 +569,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, diff --git a/test/UnitTests/packages.linux-arm64.lock.json b/test/UnitTests/packages.linux-arm64.lock.json index 97ad0e8..010daa5 100644 --- a/test/UnitTests/packages.linux-arm64.lock.json +++ b/test/UnitTests/packages.linux-arm64.lock.json @@ -315,91 +315,105 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.Net": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "NATS.NKeys": { @@ -495,7 +509,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -510,7 +524,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } @@ -832,92 +846,107 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.Net": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "NATS.NKeys": { @@ -1023,7 +1052,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, @@ -1039,7 +1068,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } diff --git a/test/UnitTests/packages.linux-x64.lock.json b/test/UnitTests/packages.linux-x64.lock.json index 97ad0e8..010daa5 100644 --- a/test/UnitTests/packages.linux-x64.lock.json +++ b/test/UnitTests/packages.linux-x64.lock.json @@ -315,91 +315,105 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.Net": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "NATS.NKeys": { @@ -495,7 +509,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -510,7 +524,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } @@ -832,92 +846,107 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.Net": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "NATS.NKeys": { @@ -1023,7 +1052,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, @@ -1039,7 +1068,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } diff --git a/test/UnitTests/packages.osx-arm64.lock.json b/test/UnitTests/packages.osx-arm64.lock.json index 97ad0e8..010daa5 100644 --- a/test/UnitTests/packages.osx-arm64.lock.json +++ b/test/UnitTests/packages.osx-arm64.lock.json @@ -315,91 +315,105 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.Net": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "NATS.NKeys": { @@ -495,7 +509,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -510,7 +524,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } @@ -832,92 +846,107 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.Net": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "NATS.NKeys": { @@ -1023,7 +1052,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, @@ -1039,7 +1068,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } diff --git a/test/UnitTests/packages.win-x64.lock.json b/test/UnitTests/packages.win-x64.lock.json index 97ad0e8..010daa5 100644 --- a/test/UnitTests/packages.win-x64.lock.json +++ b/test/UnitTests/packages.win-x64.lock.json @@ -315,91 +315,105 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.Net": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "NATS.NKeys": { @@ -495,7 +509,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -510,7 +524,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } @@ -832,92 +846,107 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.Net": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "NATS.NKeys": { @@ -1023,7 +1052,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } }, @@ -1039,7 +1068,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } diff --git a/util/Benchmarks/packages.linux-arm64.lock.json b/util/Benchmarks/packages.linux-arm64.lock.json index 1777f00..edafaa9 100644 --- a/util/Benchmarks/packages.linux-arm64.lock.json +++ b/util/Benchmarks/packages.linux-arm64.lock.json @@ -157,34 +157,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -234,7 +237,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } } }, @@ -398,35 +401,39 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -494,7 +501,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } diff --git a/util/Benchmarks/packages.linux-x64.lock.json b/util/Benchmarks/packages.linux-x64.lock.json index 1777f00..edafaa9 100644 --- a/util/Benchmarks/packages.linux-x64.lock.json +++ b/util/Benchmarks/packages.linux-x64.lock.json @@ -157,34 +157,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -234,7 +237,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } } }, @@ -398,35 +401,39 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -494,7 +501,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } diff --git a/util/Benchmarks/packages.osx-arm64.lock.json b/util/Benchmarks/packages.osx-arm64.lock.json index 1777f00..edafaa9 100644 --- a/util/Benchmarks/packages.osx-arm64.lock.json +++ b/util/Benchmarks/packages.osx-arm64.lock.json @@ -157,34 +157,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -234,7 +237,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } } }, @@ -398,35 +401,39 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -494,7 +501,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } diff --git a/util/Benchmarks/packages.win-x64.lock.json b/util/Benchmarks/packages.win-x64.lock.json index 1777f00..edafaa9 100644 --- a/util/Benchmarks/packages.win-x64.lock.json +++ b/util/Benchmarks/packages.win-x64.lock.json @@ -157,34 +157,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -234,7 +237,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } } }, @@ -398,35 +401,39 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1", + "System.Diagnostics.DiagnosticSource": "9.0.1", "System.IO.Pipelines": "8.0.0" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -494,7 +501,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )", + "NATS.Client.KeyValueStore": "[3.0.1, )", "System.Diagnostics.DiagnosticSource": "[10.0.9, )" } } diff --git a/util/NatsAppHost/Program.cs b/util/NatsAppHost/Program.cs index 5e18f27..f198570 100644 --- a/util/NatsAppHost/Program.cs +++ b/util/NatsAppHost/Program.cs @@ -18,7 +18,7 @@ var natsResource = new NatsResource("Nats"); builder.AddResource(natsResource) .WithImage("nats") - .WithImageTag("2.12.3") + .WithImageTag("2.14.3") .WithBindMount(natsConfigDir, "/etc/nats-config", isReadOnly: true) .WithArgs("-c", "/etc/nats-config/nats.conf") .WithEndpoint(port: 14222, targetPort: 4222, name: NatsResource.NatsEndpointName, scheme: "tcp"); diff --git a/util/NatsAppHost/packages.linux-arm64.lock.json b/util/NatsAppHost/packages.linux-arm64.lock.json index 19565d8..d190c87 100644 --- a/util/NatsAppHost/packages.linux-arm64.lock.json +++ b/util/NatsAppHost/packages.linux-arm64.lock.json @@ -609,34 +609,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -766,7 +769,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/util/NatsAppHost/packages.linux-x64.lock.json b/util/NatsAppHost/packages.linux-x64.lock.json index ee2825b..442b05d 100644 --- a/util/NatsAppHost/packages.linux-x64.lock.json +++ b/util/NatsAppHost/packages.linux-x64.lock.json @@ -609,34 +609,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -766,7 +769,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/util/NatsAppHost/packages.osx-arm64.lock.json b/util/NatsAppHost/packages.osx-arm64.lock.json index 6b0f717..04d7ac0 100644 --- a/util/NatsAppHost/packages.osx-arm64.lock.json +++ b/util/NatsAppHost/packages.osx-arm64.lock.json @@ -609,34 +609,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -766,7 +769,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/util/NatsAppHost/packages.win-x64.lock.json b/util/NatsAppHost/packages.win-x64.lock.json index 91c433c..269d1b0 100644 --- a/util/NatsAppHost/packages.win-x64.lock.json +++ b/util/NatsAppHost/packages.win-x64.lock.json @@ -609,34 +609,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -766,7 +769,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/util/PerfTest/PerfTest.csproj b/util/PerfTest/PerfTest.csproj index 7ec1bd5..f9537ce 100644 --- a/util/PerfTest/PerfTest.csproj +++ b/util/PerfTest/PerfTest.csproj @@ -11,7 +11,7 @@ - + diff --git a/util/PerfTest/packages.linux-arm64.lock.json b/util/PerfTest/packages.linux-arm64.lock.json index bc68931..45c7760 100644 --- a/util/PerfTest/packages.linux-arm64.lock.json +++ b/util/PerfTest/packages.linux-arm64.lock.json @@ -57,18 +57,19 @@ }, "NATS.Net": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "StyleCop.Analyzers": { @@ -822,76 +823,89 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.NKeys": { @@ -1081,7 +1095,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -1115,7 +1129,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } diff --git a/util/PerfTest/packages.linux-x64.lock.json b/util/PerfTest/packages.linux-x64.lock.json index 2a206f7..820a580 100644 --- a/util/PerfTest/packages.linux-x64.lock.json +++ b/util/PerfTest/packages.linux-x64.lock.json @@ -57,18 +57,19 @@ }, "NATS.Net": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "StyleCop.Analyzers": { @@ -822,76 +823,89 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.NKeys": { @@ -1081,7 +1095,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -1115,7 +1129,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } diff --git a/util/PerfTest/packages.osx-arm64.lock.json b/util/PerfTest/packages.osx-arm64.lock.json index 0cad4f7..3ab8f81 100644 --- a/util/PerfTest/packages.osx-arm64.lock.json +++ b/util/PerfTest/packages.osx-arm64.lock.json @@ -57,18 +57,19 @@ }, "NATS.Net": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "StyleCop.Analyzers": { @@ -822,76 +823,89 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.NKeys": { @@ -1081,7 +1095,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -1115,7 +1129,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } diff --git a/util/PerfTest/packages.win-x64.lock.json b/util/PerfTest/packages.win-x64.lock.json index 5fa2687..7a06ee4 100644 --- a/util/PerfTest/packages.win-x64.lock.json +++ b/util/PerfTest/packages.win-x64.lock.json @@ -57,18 +57,19 @@ }, "NATS.Net": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "EMVo1u6WlaG5i5ncTdh6ez55TCgcgG4M7G2mXMa3KUKf0aDEYl3RZ0NTYwxlXKgZzVf0bboaM27KEylw8SMZ6w==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Hosting": "3.0.1", + "NATS.Client.JetStream": "3.0.1", + "NATS.Client.KeyValueStore": "3.0.1", + "NATS.Client.ObjectStore": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1", + "NATS.Client.Services": "3.0.1", + "NATS.Client.Simplified": "3.0.1", + "NATS.Extensions.Microsoft.DependencyInjection": "3.0.1" } }, "StyleCop.Analyzers": { @@ -822,76 +823,89 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.Hosting": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", + "resolved": "3.0.1", + "contentHash": "0nhUB7/3YD26LDPKjTYLLv+FmMmdYp5mHX84ZDqXuQJLsgs6PIoqeG0ZCN8mkHoi8aq0Lyv6i7o02ILyMZGxoA==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.ObjectStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", + "resolved": "3.0.1", + "contentHash": "Blv7piRaXE2ovf4kOiTG0guyzWKC/YaZkwnQCUFXbNDq0jT+TmERS4uFirNl8Zmy7HZeeo8C2ZxvmhatiXWSNA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Abstractions": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Services": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "Ra3RwF/RD7BPvxv0E4Sl9PZChMu9gFaTx3aGVvaFvqYb1xXXw/uOkWCxpYZEqui261eQxMsa8lapT+TLRJDCVA==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" + } + }, + "NATS.Extensions.Microsoft.DependencyInjection": { + "type": "Transitive", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", + "dependencies": { + "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", + "Microsoft.Extensions.Options": "8.0.2", + "NATS.Client.Simplified": "3.0.1" } }, "NATS.NKeys": { @@ -1081,7 +1095,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { @@ -1115,7 +1129,7 @@ "dependencies": { "CodeCargo.Nats.HybridCacheExtensions": "[1.0.0, )", "Microsoft.Extensions.Logging": "[10.0.9, )", - "NATS.Net": "[2.8.2, )", + "NATS.Net": "[3.0.1, )", "xunit.v3.assert": "[3.2.2, )", "xunit.v3.extensibility.core": "[3.2.2, )" } diff --git a/util/ReadmeExample/ReadmeExample.csproj b/util/ReadmeExample/ReadmeExample.csproj index 5723f67..2ebf6cc 100644 --- a/util/ReadmeExample/ReadmeExample.csproj +++ b/util/ReadmeExample/ReadmeExample.csproj @@ -10,7 +10,7 @@ - + diff --git a/util/ReadmeExample/packages.linux-arm64.lock.json b/util/ReadmeExample/packages.linux-arm64.lock.json index e992888..3ad6475 100644 --- a/util/ReadmeExample/packages.linux-arm64.lock.json +++ b/util/ReadmeExample/packages.linux-arm64.lock.json @@ -45,13 +45,13 @@ }, "NATS.Extensions.Microsoft.DependencyInjection": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "M5XtnsCumMJh7ye8b2RVIb2n/xrTNHw5OJms9puBFPInLvOir2mLMHpLP1AXU8r0dX1xc+ymhGBQ3zYgXlsDRg==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", "Microsoft.Extensions.Options": "8.0.2", - "NATS.Net": "2.8.2" + "NATS.Client.Simplified": "3.0.1" } }, "StyleCop.Analyzers": { @@ -753,91 +753,54 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, - "NATS.Client.Hosting": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", - "dependencies": { - "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" - } - }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" - } - }, - "NATS.Client.ObjectStore": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", - "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", - "dependencies": { - "NATS.Client.Abstractions": "2.8.2" - } - }, - "NATS.Client.Services": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", - "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" - } - }, - "NATS.Net": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" } }, "NATS.NKeys": { @@ -991,7 +954,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/util/ReadmeExample/packages.linux-x64.lock.json b/util/ReadmeExample/packages.linux-x64.lock.json index 29bbf5a..189b9bd 100644 --- a/util/ReadmeExample/packages.linux-x64.lock.json +++ b/util/ReadmeExample/packages.linux-x64.lock.json @@ -45,13 +45,13 @@ }, "NATS.Extensions.Microsoft.DependencyInjection": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "M5XtnsCumMJh7ye8b2RVIb2n/xrTNHw5OJms9puBFPInLvOir2mLMHpLP1AXU8r0dX1xc+ymhGBQ3zYgXlsDRg==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", "Microsoft.Extensions.Options": "8.0.2", - "NATS.Net": "2.8.2" + "NATS.Client.Simplified": "3.0.1" } }, "StyleCop.Analyzers": { @@ -753,91 +753,54 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, - "NATS.Client.Hosting": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", - "dependencies": { - "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" - } - }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" - } - }, - "NATS.Client.ObjectStore": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", - "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", - "dependencies": { - "NATS.Client.Abstractions": "2.8.2" - } - }, - "NATS.Client.Services": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", - "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" - } - }, - "NATS.Net": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" } }, "NATS.NKeys": { @@ -991,7 +954,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/util/ReadmeExample/packages.osx-arm64.lock.json b/util/ReadmeExample/packages.osx-arm64.lock.json index 637bf5f..b15c04f 100644 --- a/util/ReadmeExample/packages.osx-arm64.lock.json +++ b/util/ReadmeExample/packages.osx-arm64.lock.json @@ -45,13 +45,13 @@ }, "NATS.Extensions.Microsoft.DependencyInjection": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "M5XtnsCumMJh7ye8b2RVIb2n/xrTNHw5OJms9puBFPInLvOir2mLMHpLP1AXU8r0dX1xc+ymhGBQ3zYgXlsDRg==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", "Microsoft.Extensions.Options": "8.0.2", - "NATS.Net": "2.8.2" + "NATS.Client.Simplified": "3.0.1" } }, "StyleCop.Analyzers": { @@ -753,91 +753,54 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, - "NATS.Client.Hosting": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", - "dependencies": { - "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" - } - }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" - } - }, - "NATS.Client.ObjectStore": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", - "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", - "dependencies": { - "NATS.Client.Abstractions": "2.8.2" - } - }, - "NATS.Client.Services": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", - "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" - } - }, - "NATS.Net": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" } }, "NATS.NKeys": { @@ -991,7 +954,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/util/ReadmeExample/packages.win-x64.lock.json b/util/ReadmeExample/packages.win-x64.lock.json index 3fde94f..5d525ad 100644 --- a/util/ReadmeExample/packages.win-x64.lock.json +++ b/util/ReadmeExample/packages.win-x64.lock.json @@ -45,13 +45,13 @@ }, "NATS.Extensions.Microsoft.DependencyInjection": { "type": "Direct", - "requested": "[2.8.2, )", - "resolved": "2.8.2", - "contentHash": "M5XtnsCumMJh7ye8b2RVIb2n/xrTNHw5OJms9puBFPInLvOir2mLMHpLP1AXU8r0dX1xc+ymhGBQ3zYgXlsDRg==", + "requested": "[3.0.1, )", + "resolved": "3.0.1", + "contentHash": "FNdg0BmE9IMpuXoJjEh+EXTGL0r7EXAYZk5Z5JSfIpIv2/BYiuWdOsGVXExzlpXtqxK2LVRncYS+7elCcVOYvg==", "dependencies": { "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", "Microsoft.Extensions.Options": "8.0.2", - "NATS.Net": "2.8.2" + "NATS.Client.Simplified": "3.0.1" } }, "StyleCop.Analyzers": { @@ -753,91 +753,54 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, - "NATS.Client.Hosting": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2UeW1YUEOxDlyYau9JQQpXrpjFy+818UeOrBbQPP+l9Y0KMxd2oE4MoaVoNu/bAYibNCuIJqj0yhIBykvPO8wQ==", - "dependencies": { - "Microsoft.Extensions.Hosting.Abstractions": "8.0.0", - "NATS.Client.Core": "2.8.2" - } - }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" - } - }, - "NATS.Client.ObjectStore": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "RSArUdK9sZ0bh97eVIJJ5T9aR1MiRdP8SY90b0v0umEzcmI0hE/LnkkoWritC/vAOGNa1ybYmoFfA4z2UNtPQA==", - "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.Client.Serializers.Json": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "Cd+4OkKFpgzfRUYhY3OkJ/IpMNvveSWcyWSMliwnGnLvnFIXTKtV22PwOFKDrZgPifsesggYfoDjzq5LeGUmrQ==", - "dependencies": { - "NATS.Client.Abstractions": "2.8.2" - } - }, - "NATS.Client.Services": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "2zV306iSkyWoF2Zy+AFIzIb+NJ0SttBJuQzxkMasuNuHQlayEuWLiytLAfecdF7URgXIKgU2XVjrFMToTYVYzQ==", + "resolved": "3.0.1", + "contentHash": "JSZKXk35vqKjxyYhr9eJzzKPJ8wNVu4UwOtA/ZJHKAXaqfcFSZROJkYTK9dsVbWBtoBa8pRa2wsDnf4JuR0OYQ==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Abstractions": "3.0.1" } }, "NATS.Client.Simplified": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "JUJCIZ+IQzIhyE8uCSSRWkhp2BBk6O6GMAkRVo8gfbyKRelStt8tpBUMfYYR6Ru3tfAOCiVDOYSnXsJnilOiww==", - "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2" - } - }, - "NATS.Net": { - "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aDeKcnk4y3ZYSHnudVlWmo/59IgLBO7YRt23W9cYDVQbxonCOaRZWQ7q5XcDuOooBG7JipFjKcZC9y9YANwIww==", + "resolved": "3.0.1", + "contentHash": "Iu3/mqGpFqMrAWVxrFdkHV6dR8HYDxyIGbio+JRiX1f02aYu1C24e7X9+HOP7vlFqmrwQMQTEzPWyQjyFL4cyw==", "dependencies": { - "NATS.Client.Core": "2.8.2", - "NATS.Client.Hosting": "2.8.2", - "NATS.Client.JetStream": "2.8.2", - "NATS.Client.KeyValueStore": "2.8.2", - "NATS.Client.ObjectStore": "2.8.2", - "NATS.Client.Serializers.Json": "2.8.2", - "NATS.Client.Services": "2.8.2", - "NATS.Client.Simplified": "2.8.2" + "NATS.Client.Core": "3.0.1", + "NATS.Client.Serializers.Json": "3.0.1" } }, "NATS.NKeys": { @@ -991,7 +954,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/util/RedisAppHost/packages.linux-arm64.lock.json b/util/RedisAppHost/packages.linux-arm64.lock.json index 442f5e6..1340b71 100644 --- a/util/RedisAppHost/packages.linux-arm64.lock.json +++ b/util/RedisAppHost/packages.linux-arm64.lock.json @@ -657,34 +657,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -829,7 +832,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/util/RedisAppHost/packages.linux-x64.lock.json b/util/RedisAppHost/packages.linux-x64.lock.json index 6890599..6d195dd 100644 --- a/util/RedisAppHost/packages.linux-x64.lock.json +++ b/util/RedisAppHost/packages.linux-x64.lock.json @@ -657,34 +657,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -829,7 +832,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/util/RedisAppHost/packages.osx-arm64.lock.json b/util/RedisAppHost/packages.osx-arm64.lock.json index 7e43331..5e5aff5 100644 --- a/util/RedisAppHost/packages.osx-arm64.lock.json +++ b/util/RedisAppHost/packages.osx-arm64.lock.json @@ -657,34 +657,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -829,7 +832,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { diff --git a/util/RedisAppHost/packages.win-x64.lock.json b/util/RedisAppHost/packages.win-x64.lock.json index a9a6e43..def9d97 100644 --- a/util/RedisAppHost/packages.win-x64.lock.json +++ b/util/RedisAppHost/packages.win-x64.lock.json @@ -657,34 +657,37 @@ }, "NATS.Client.Abstractions": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "yzYxLYvNaVy4p1Pxm0q2RtVmHi1Ijzdl0Hnw4E4sT0KWhVYQuOCF7PiuJ1EHR/0yBEwKfPjzpl6cS4A/2NdsTA==" + "resolved": "3.0.1", + "contentHash": "uqpvjqHhlHIfuqtucpSanjZZ0XZV7enjPYxOxTW8BRE0epqGLEKlwb2990yH82QSuMreR+y04IhfgY0pjDxZ4A==", + "dependencies": { + "Microsoft.Extensions.Primitives": "6.0.0" + } }, "NATS.Client.Core": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "w3ijnp07CrILhYp2Hkyi1u8hNN9czdhwYGxTf9bi23jMEQoYh7X3y1NDA2VkQW3UAq7bYMq3hr403wCdzj+YaA==", + "resolved": "3.0.1", + "contentHash": "QmBnIttS2cYof+13NYuPoJdymkzJCQWNftTGv2fwy2rGLFsBVkhpv1Lej2kXhdOdVic8gaaZsx7S3J8c1Ye/xA==", "dependencies": { "Microsoft.Extensions.Logging.Abstractions": "6.0.1", "Microsoft.Extensions.Primitives": "6.0.0", - "NATS.Client.Abstractions": "2.8.2", + "NATS.Client.Abstractions": "3.0.1", "NATS.NKeys": "1.0.1" } }, "NATS.Client.JetStream": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "aL3916K5JboqTuUFHyG+OmIZgeUYaLASSkHaKDxRiLKbRWeKCbH/lqvqFEJOPHpKkFa46CXEXAD+iuZ5txko3w==", + "resolved": "3.0.1", + "contentHash": "pFwXvBBcPCxpItN8PfqYWjl8kYhkqrQwncAA1A8NuJiawo+DQHdUEQJ2e+y5k9b7e62ZOUdY1fGpgyjP04k0ng==", "dependencies": { - "NATS.Client.Core": "2.8.2" + "NATS.Client.Core": "3.0.1" } }, "NATS.Client.KeyValueStore": { "type": "Transitive", - "resolved": "2.8.2", - "contentHash": "IyMOmkagPQf94vtf3Q/5HyiAm5tN8tv1TVp/k0GcH6i5K7uXaOK3uz94RtbUmVzEvGtrsJ+hzbycxOPh0dk7CA==", + "resolved": "3.0.1", + "contentHash": "jvRdbF9qhxOYQmRRqddOUoAMwcABMEYdRneRe8aIhFGymcjockex3gGTXracYjaOZQFhS57ZpP+M1GFxgYr+tA==", "dependencies": { - "NATS.Client.JetStream": "2.8.2" + "NATS.Client.JetStream": "3.0.1" } }, "NATS.NKeys": { @@ -829,7 +832,7 @@ "Microsoft.Extensions.Caching.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Logging.Abstractions": "[10.0.9, )", "Microsoft.Extensions.Options": "[10.0.9, )", - "NATS.Client.KeyValueStore": "[2.8.2, )" + "NATS.Client.KeyValueStore": "[3.0.1, )" } }, "CodeCargo.Nats.HybridCacheExtensions": { From a6c41d18dc65800e216c5136b4b7290276ba3a33 Mon Sep 17 00:00:00 2001 From: Matthew DeVenny Date: Mon, 20 Jul 2026 14:22:40 -0700 Subject: [PATCH 3/4] #39 Scope the telemetry "no allocation" claim to per-operation The docs claimed nothing is measured, timed, or allocated until a listener subscribes. The first two hold, but each cache instance builds its meter, two instruments, and four span-name strings on first use regardless of listeners, so the blanket allocation claim over-promised. Reword the README, the NatsCacheTelemetryNames XML docs, both options doc comments, and the ReadmeExample snippet to promise no *per-operation* allocation, and state the one-time setup cost explicitly. The behavior is unchanged; UnsubscribedScopeAllocatesNothing already pinned the per-operation guarantee this wording now describes. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Matthew DeVenny --- README.md | 6 ++++-- src/NatsDistributedCache/NatsCacheOptions.cs | 6 +++--- src/NatsDistributedCache/NatsCacheTelemetryNames.cs | 5 +++-- src/NatsDistributedCache/NatsCacheTelemetryOptions.cs | 2 +- util/ReadmeExample/DistributedCache.cs | 6 +++--- 5 files changed, 14 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index d0f92ee..55cafb9 100644 --- a/README.md +++ b/README.md @@ -188,8 +188,10 @@ so it cannot discard entries written by a newer node still being rolled out. ## Telemetry Metrics and traces are emitted through `System.Diagnostics.Metrics` and `System.Diagnostics.ActivitySource`. -**This package takes no dependency on OpenTelemetry.** Nothing is measured, timed, or allocated until a -listener subscribes, so registering the names below is the opt-in: +**This package takes no dependency on OpenTelemetry.** No measurement is recorded, no duration is timed, +and no per-operation allocation occurs until a listener subscribes, so registering the names below is the +opt-in. (Each cache instance does build its meter, two instruments, and four span-name strings once on +first use, whether or not anything is listening — a fixed setup cost, not a per-operation one.) ```csharp builder.Services.AddOpenTelemetry() diff --git a/src/NatsDistributedCache/NatsCacheOptions.cs b/src/NatsDistributedCache/NatsCacheOptions.cs index 798fd7a..5b6b7bd 100644 --- a/src/NatsDistributedCache/NatsCacheOptions.cs +++ b/src/NatsDistributedCache/NatsCacheOptions.cs @@ -58,9 +58,9 @@ public class NatsCacheOptions : IOptions public Func? ConfigureBucketOnCreate { get; set; } /// - /// Telemetry configuration. Metrics and traces are inert until a listener subscribes to the meter or - /// activity source named by , so these options tune what is - /// emitted rather than whether telemetry is enabled. + /// Telemetry configuration. No metrics or traces are recorded until a listener subscribes to the + /// meter or activity source named by , so these options tune + /// what is emitted rather than whether telemetry is enabled. /// /// /// Get-only so it can never be null: configure it in place diff --git a/src/NatsDistributedCache/NatsCacheTelemetryNames.cs b/src/NatsDistributedCache/NatsCacheTelemetryNames.cs index 433648d..ab07813 100644 --- a/src/NatsDistributedCache/NatsCacheTelemetryNames.cs +++ b/src/NatsDistributedCache/NatsCacheTelemetryNames.cs @@ -6,8 +6,9 @@ namespace CodeCargo.Nats.DistributedCache; /// /// /// Telemetry is emitted through System.Diagnostics.Metrics and System.Diagnostics.ActivitySource -/// only; this package takes no dependency on OpenTelemetry. Nothing is measured, timed, or allocated until a -/// listener subscribes, so registering these names is the opt-in: +/// only; this package takes no dependency on OpenTelemetry. No measurement is recorded, no duration is timed, +/// and no per-operation allocation occurs until a listener subscribes, so registering these names is the +/// opt-in: /// /// /// builder.Services.AddOpenTelemetry() diff --git a/src/NatsDistributedCache/NatsCacheTelemetryOptions.cs b/src/NatsDistributedCache/NatsCacheTelemetryOptions.cs index d3e3e51..a1e48c0 100644 --- a/src/NatsDistributedCache/NatsCacheTelemetryOptions.cs +++ b/src/NatsDistributedCache/NatsCacheTelemetryOptions.cs @@ -4,7 +4,7 @@ namespace CodeCargo.Nats.DistributedCache; /// Telemetry configuration for . /// /// -/// Telemetry is inert until a listener subscribes to the meter or activity source named by +/// No telemetry is recorded until a listener subscribes to the meter or activity source named by /// ; these options only tune what is emitted once something is /// listening, they are not the opt-in switch. /// diff --git a/util/ReadmeExample/DistributedCache.cs b/util/ReadmeExample/DistributedCache.cs index 1a7e647..2201725 100644 --- a/util/ReadmeExample/DistributedCache.cs +++ b/util/ReadmeExample/DistributedCache.cs @@ -42,9 +42,9 @@ public static async Task RunAsync(string[] args) natsBuilder.ConfigureOptions(optsBuilder => optsBuilder.Configure(opts => opts.Opts = opts.Opts with { Url = natsConnectionString }))); - // The cache emits metrics and traces via System.Diagnostics; they are inert until a listener - // subscribes. To collect them, add the OpenTelemetry packages and register the names (see the - // Telemetry section of the README): + // The cache emits metrics and traces via System.Diagnostics; it records nothing and allocates + // nothing per operation until a listener subscribes. To collect them, add the OpenTelemetry + // packages and register the names (see the Telemetry section of the README): // services.AddOpenTelemetry() // .WithMetrics(m => m.AddMeter(NatsCacheTelemetryNames.MeterName)) // .WithTracing(t => t.AddSource(NatsCacheTelemetryNames.ActivitySourceName)); From d3953becf42fa50b932288cdbd00f0c4e89a123c Mon Sep 17 00:00:00 2001 From: Matthew DeVenny Date: Tue, 21 Jul 2026 11:36:25 -0700 Subject: [PATCH 4/4] #39 Fix README PromQL series names for the default Prometheus exporter The example queries used nats_cache_operation_duration_count / _bucket, but the OTel->Prometheus exporter appends the unit and a _total suffix by default (add_metric_suffixes = true): the histogram's `s` unit makes the real series nats_cache_operation_duration_seconds_count / _seconds_bucket, and the counter becomes nats_cache_misses_total. As written the examples returned nothing on a stock exporter. Use the suffixed names, note the add_metric_suffixes toggle, and add a miss-rate-by-reason example. Co-Authored-By: Claude Opus 4.8 (1M context) Signed-off-by: Matthew DeVenny --- README.md | 14 +++++++++++--- 1 file changed, 11 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 55cafb9..84efa0a 100644 --- a/README.md +++ b/README.md @@ -233,15 +233,23 @@ two caches in the same process distinguishable. Spans carry the same tags, plus ### Example queries +The series names below assume the default Prometheus exporter, which appends the unit and a `_total` +suffix (`add_metric_suffixes = true`): the histogram's unit `s` makes it `..._seconds_bucket` / +`..._seconds_count`, and the misses counter becomes `nats_cache_misses_total`. If you set +`add_metric_suffixes = false`, drop the `_seconds` infix and the `_total` suffix. + ```promql # Hit ratio. Both selectors must filter on the same operation — leaving it off the numerator would # fold refresh hits into a denominator that counts only gets, producing a ratio above 1. -sum(rate(nats_cache_operation_duration_count{nats_cache_operation="get",nats_cache_result="hit"}[5m])) - / sum(rate(nats_cache_operation_duration_count{nats_cache_operation="get"}[5m])) +sum(rate(nats_cache_operation_duration_seconds_count{nats_cache_operation="get",nats_cache_result="hit"}[5m])) + / sum(rate(nats_cache_operation_duration_seconds_count{nats_cache_operation="get"}[5m])) # p99 latency by operation histogram_quantile(0.99, sum by (le, nats_cache_operation) - (rate(nats_cache_operation_duration_bucket[5m]))) + (rate(nats_cache_operation_duration_seconds_bucket[5m]))) + +# Miss rate by reason +sum by (nats_cache_miss_reason) (rate(nats_cache_misses_total[5m])) ``` ### Notes