Tyto.Rpc.Caching 0.1.0-alpha.2

Tyto.Rpc.Caching

Caches the answers of RPC calls, without the request contracts knowing anything about it.

tyto.AddRpc(rpc => rpc.AddClient(client => client
    .UseInProcess(...)
    .UseCaching(caching => {
        caching.For<GetCategoriesRpcRequest, GetCategoriesRpcResponse>("categories", policy => policy
            .WithKey(request => request.AppId.ToString())
            .WithTtl(TimeSpan.FromMinutes(15))
            .WithStaleWhileRevalidate(TimeSpan.FromMinutes(13)));

        caching.For<ValidateAppAccessRpcRequest, ValidateAppAccessRpcResponse>("app-access", policy => policy
            .WithKey(request => $"{request.OrganizationId}:{request.AppId}:{request.ClientId}")
            .WithTtl(TimeSpan.FromMinutes(30))
            .WithTags("app-access")
            .CacheErrors<NotFoundError>());
    })));

A key is required

WithKey must name everything that can change the answer. A field left out of the key is a field whose value the first caller decides for everyone — a request that asked about one channel filling the entry every later channel then reads. A policy without a key is refused when it is configured.

A request that genuinely has one answer for the whole application says so:

policy.SingleEntry();

There is no default key. There used to be: the request type's name, so forgetting WithKey gave every request of that type one shared entry and nobody was told.

Cached errors keep their type

CacheErrors<TError>() stores the error with the entry and hands it back as it was:

RpcResult<ProfileResponse> result = await client.CallAsync(new GetProfileRequest(org, user));
// result.Error is NotFoundError { ResourceType = "Recipient", ResourceId = "42" } — from the cache too

Errors used to be stored as "nothing" and served back as a generic not-found about the response type, so the resource and its id were gone and one business error could not be told from another.

Errors the policy does not name — timeouts, unavailable services, transport failures — are never stored; they reach the caller and the next call tries again.

Invalidation

The cache stores a wrapper around the response, so removing an entry does not go through ICache<string, TResponse>. Use the profile's invalidator, or tags:

await cacheFactory.GetInvalidator("app-access").InvalidateAsync($"{organizationId}:{appId}:{clientId}");

endpoint.InvalidateCache("app-access")
        .On<AppCredentialRevokedIntegrationEvent>(e => $"{e.OrganizationId}:{e.AppId}:{e.ClientId}");

What you get from Tyto.Caching

The policy's TTL, sliding expiration, stale-while-revalidate and tags are that library's, and so is the rest: one factory per key, a cancellation that does not cancel the other callers, a circuit breaker in front of the distributed layer, and an invalidation that says so when it cannot be delivered. See src/Caching/README.md.