Contexte de demandes

Il RequestContext s’agit d’une Orleans fonctionnalité permettant aux métadonnées d’application, telles qu’un ID de trace, de circuler avec des requêtes. Vous pouvez ajouter des métadonnées d'application sur le client ; elles accompagnent les requêtes Orleans envoyées au grain de réception. La fonctionnalité est implémentée par une classe statique publique, RequestContext, dans l’espace de noms Orleans. Cette classe expose deux méthodes simples :

void Set(string key, object value)

Utilisez l’API précédente pour stocker une valeur dans le contexte de la requête. La valeur peut être de n’importe quel type sérialisable.

object Get(string key)

Utilisez l’API précédente pour récupérer une valeur à partir du contexte de requête actuel.

Le stockage de sauvegarde pour RequestContext est un stockage local asynchrone. Lorsqu'un appelant (côté client ou au sein Orleans) envoie une demande, le contenu de l’appelant est inclus dans le message RequestContext pour la demande. Lorsque le code de grain reçoit la requête, ces métadonnées sont accessibles à partir du code local RequestContext. Si le code de grain ne modifie pas RequestContext, alors tout grain qu’il demande reçoit les mêmes métadonnées, et ainsi de suite.

Les métadonnées d’application sont également conservées lorsque vous planifiez un calcul futur à l’aide StartNew ou ContinueWith. Dans les deux cas, la continuation s’exécute avec les mêmes métadonnées que le code de planification lorsque le calcul a été planifié. Autrement dit, le système copie les métadonnées actuelles et le transmet à la continuation, de sorte que la continuation ne verra pas les modifications apportées après l’appel à StartNew ou ContinueWith.

Par exemple, pour définir un ID de trace dans le client à un nouvel Guid, appelez :

RequestContext.Set("TraceId", Guid.NewGuid());

Dans le code grain (ou tout autre code exécuté Orleans sur un thread de planificateur), vous pouvez utiliser l’ID de trace de la demande cliente d’origine, par exemple lors de l’écriture d’un journal :

Logger.LogInformation(
    "Currently processing external request {TraceId}",
    RequestContext.Get("TraceId"));

Bien que vous puissiez envoyer n’importe quelle valeur sérialisable object en tant que métadonnées d’application, il est important de mentionner que les objets volumineux ou complexes peuvent ajouter une surcharge notable au temps de sérialisation des messages. Pour cette raison, nous vous recommandons d’utiliser des types simples (chaînes, GUID ou types numériques).

Exemple de code de grain

Pour illustrer l’utilisation du contexte de requête, tenez compte de l’exemple de code de grain suivant :

using GrainInterfaces;
using Microsoft.Extensions.Logging;

namespace Grains;

public class HelloGrain(ILogger<HelloGrain> logger) : Grain, IHelloGrain
{
    ValueTask<string> IHelloGrain.SayHello(string greeting)
    {
        _logger.LogInformation("""
            SayHello message received: greeting = "{Greeting}"
            """,
            greeting);
        
        var traceId = RequestContext.Get("TraceId") as string 
            ?? "No trace ID";

        return ValueTask.FromResult($"""
            TraceID: {traceId}
            Client said: "{greeting}", so HelloGrain says: Hello!
            """);
    }
}

public interface IHelloGrain : IGrainWithStringKey
{
    ValueTask<string> SayHello(string greeting);
}

La SayHello méthode enregistre le paramètre entrant greeting , puis récupère l’ID de trace à partir du contexte de requête. Si aucun ID de trace n’est trouvé, le grain enregistre « Aucun ID de trace ».

Exemple de code client

Le client peut définir l’ID de trace dans le contexte de la demande avant d’appeler la SayHello méthode sur le HelloGrain. Le code client suivant montre comment définir un ID de trace dans le contexte de la requête et appeler la SayHello méthode sur :HelloGrain

using GrainInterfaces;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

using var host = Host.CreateDefaultBuilder(args)
    .UseOrleansClient(clientBuilder =>
        clientBuilder.UseLocalhostClustering())
    .Build();

await host.StartAsync();

var client = host.Services.GetRequiredService<IClusterClient>();

var grain = client.GetGrain<IHelloGrain>("friend");

var id = "example-id-set-by-client";

RequestContext.Set("TraceId", id);

var message = await friend.SayHello("Good morning!");

Console.WriteLine(message);
// Output:
//   TraceID: example-id-set-by-client
//   Client said: "Good morning!", so HelloGrain says: Hello!

Dans cet exemple, le client définit l’ID de trace sur « example-id-set-by-client » avant d’appeler la SayHello méthode sur le HelloGrain. Le grain récupère l’ID de trace à partir du contexte de la requête et l’enregistre.