Added Counter Interceptor Sample

README.md

@@ -18,6 +18,7 @@ Prerequisites:
 * [AspNet](src/AspNet) - Demonstration of a generic host worker and an ASP.NET workflow starter.
 * [ClientMtls](src/ClientMtls) - How to use client certificate authentication, e.g. for Temporal Cloud.
 * [ContextPropagation](src/ContextPropagation) - Context propagation via interceptors.
+* [CounterInterceptor](src/CounterInterceptor/) - Simple Workflow and Client Interceptors example.
 * [DependencyInjection](src/DependencyInjection) - How to inject dependencies in activities and use generic hosts for workers
 * [Encryption](src/Encryption) - End-to-end encryption with Temporal payload codecs.
 * [Mutex](src/Mutex) - How to implement a mutex as a workflow. Demonstrates how to avoid race conditions or parallel mutually exclusive operations on the same resource.

TemporalioSamples.sln

@@ -55,6 +55,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TemporalioSamples.WorkflowU
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TemporalioSamples.ContextPropagation", "src\ContextPropagation\TemporalioSamples.ContextPropagation.csproj", "{7B797D20-485F-441D-8E71-AF7E315FA9CF}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TemporalioSamples.CounterInterceptor", "src\CounterInterceptor\TemporalioSamples.CounterInterceptor.csproj", "{EB05B946-4DD3-4992-B84B-4438B5846ED5}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -149,6 +151,10 @@ Global
 		{7B797D20-485F-441D-8E71-AF7E315FA9CF}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{7B797D20-485F-441D-8E71-AF7E315FA9CF}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{7B797D20-485F-441D-8E71-AF7E315FA9CF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{EB05B946-4DD3-4992-B84B-4438B5846ED5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EB05B946-4DD3-4992-B84B-4438B5846ED5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EB05B946-4DD3-4992-B84B-4438B5846ED5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EB05B946-4DD3-4992-B84B-4438B5846ED5}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -178,5 +184,6 @@ Global
 		{B79F07F7-3429-4C58-84C3-08587F748B2D} = {1A647B41-53D0-4638-AE5A-6630BAAE45FC}
 		{B3DB7B8C-7BD3-4A53-A809-AB6279B1A630} = {1A647B41-53D0-4638-AE5A-6630BAAE45FC}
 		{7B797D20-485F-441D-8E71-AF7E315FA9CF} = {1A647B41-53D0-4638-AE5A-6630BAAE45FC}
+		{EB05B946-4DD3-4992-B84B-4438B5846ED5} = {1A647B41-53D0-4638-AE5A-6630BAAE45FC}
 	EndGlobalSection
 EndGlobal

src/CounterInterceptor/MyActivities.cs

@@ -0,0 +1,19 @@
+namespace TemporalioSamples.CounterInterceptor;
+
+using System.Diagnostics;
+using Temporalio.Activities;
+
+public class MyActivities
+{
+    [Activity]
+    public string SayHello(string name, string title)
+    {
+        return "Hello " + title + " " + name;
+    }
+
+    [Activity]
+    public string SayGoodBye(string name, string title)
+    {
+        return "Goodbye " + title + " " + name;
+    }
+}

src/CounterInterceptor/MyChildWorkflow.workflow.cs

@@ -0,0 +1,17 @@
+namespace TemporalioSamples.CounterInterceptor;
+
+using Temporalio.Workflows;
+
+[Workflow]
+public class MyChildWorkflow
+{
+    private readonly ActivityOptions activityOptions = new()
+    {
+        StartToCloseTimeout = TimeSpan.FromSeconds(10),
+    };
+
+    [WorkflowRun]
+    public async Task<string> RunAsync(string name, string title) =>
+        await Workflow.ExecuteActivityAsync((MyActivities act) => act.SayHello(name, title), activityOptions) +
+        await Workflow.ExecuteActivityAsync((MyActivities act) => act.SayGoodBye(name, title), activityOptions);
+}

src/CounterInterceptor/MyWorkflow.workflow.cs

@@ -0,0 +1,42 @@
+namespace TemporalioSamples.CounterInterceptor;
+
+using Temporalio.Workflows;
+
+[Workflow]
+public class MyWorkflow
+{
+    private bool exit; // Automatically defaults to false
+
+    [WorkflowRun]
+    public async Task<string> RunAsync()
+    {
+        // Wait for greeting info
+        await Workflow.WaitConditionAsync(() => Name != null && Title != null);
+
+        // Execute Child Workflow
+        var result = await Workflow.ExecuteChildWorkflowAsync(
+            (MyChildWorkflow wf) => wf.RunAsync(Name, Title),
+            new() { Id = "counter-interceptor-child" });
+
+        // Wait for exit signal
+        await Workflow.WaitConditionAsync(() => exit);
+
+        return result;
+    }
+
+    [WorkflowSignal]
+    public async Task SignalNameAndTitleAsync(string name, string title)
+    {
+        Name = name;
+        Title = title;
+    }
+
+    [WorkflowQuery]
+    public string Name { get; private set; } = string.Empty;
+
+    [WorkflowQuery]
+    public string Title { get; private set; } = string.Empty;
+
+    [WorkflowSignal]
+    public async Task ExitAsync() => exit = true;
+}

src/CounterInterceptor/Program.cs

@@ -0,0 +1,86 @@
+namespace TemporalioSamples.CounterInterceptor;
+
+using Temporalio.Client;
+using Temporalio.Worker;
+
+internal class Program
+{
+    private static async Task Main(string[] args)
+    {
+        var clientInterceptor = new SimpleClientCallsInterceptor();
+        var client = await TemporalClient.ConnectAsync(
+            options: new("localhost:7233")
+            {
+                Interceptors = new[]
+                {
+                    clientInterceptor,
+                },
+            });
+
+        using var tokenSource = new CancellationTokenSource();
+        Console.CancelKeyPress += (_, eventArgs) =>
+        {
+            tokenSource.Cancel();
+            eventArgs.Cancel = true;
+        };
+
+        var activities = new MyActivities();
+
+        var taskQueue = "CounterInterceptorTaskQueue";
+
+        var workerOptions = new TemporalWorkerOptions(taskQueue).
+                AddAllActivities(activities).
+                AddWorkflow<MyWorkflow>().
+                AddWorkflow<MyChildWorkflow>();
+
+        var workerInterceptor = new SimpleCounterWorkerInterceptor();
+        workerOptions.Interceptors = new[] { workerInterceptor };
+
+        using var worker = new TemporalWorker(
+            client,
+            workerOptions);
+
+        // Run worker until cancelled
+        Console.WriteLine("Running worker...");
+        try
+        {
+            // Start the workers
+            var workerResult = worker.ExecuteAsync(tokenSource.Token);
+
+            // Start the workflow
+            var handle = await client.StartWorkflowAsync(
+                (MyWorkflow wf) => wf.RunAsync(),
+                new(id: Guid.NewGuid().ToString(), taskQueue: taskQueue));
+
+            Console.WriteLine("Sending name and title to workflow");
+            await handle.SignalAsync(wf => wf.SignalNameAndTitleAsync("John", "Customer"));
+
+            var name = await handle.QueryAsync(wf => wf.Name);
+            var title = await handle.QueryAsync(wf => wf.Title);
+
+            // Send exit signal to workflow
+            await handle.SignalAsync(wf => wf.ExitAsync());
+
+            var result = await handle.GetResultAsync();
+
+            Console.WriteLine($"Workflow result is {result}", result);
+
+            Console.WriteLine("Query results: ");
+            Console.WriteLine($"\tName: {name}", name);
+            Console.WriteLine($"\tTitle: {title}", title);
+
+            // Print worker counter info
+            Console.WriteLine("Collected Worker Counter Info: ");
+            Console.WriteLine(workerInterceptor.Info());
+
+            // Print client counter info
+            Console.WriteLine();
+            Console.WriteLine("Collected Client Counter Info:");
+            Console.WriteLine(clientInterceptor.Info());
+        }
+        catch (OperationCanceledException)
+        {
+            Console.WriteLine("Worker cancelled");
+        }
+    }
+}

src/CounterInterceptor/README.md

@@ -0,0 +1,28 @@
+# dotnet-counter-interceptor
+The sample demonstrates: 
+- the use of a Worker Workflow Interceptor that counts the number of Workflow Executions, Child Workflow Executions, and Activity Executions and the number of Signals and Queries. It is based
+off of the [Java sample](https://github.com/temporalio/samples-java/tree/main) located [here](https://github.com/temporalio/samples-java/tree/main/core/src/main/java/io/temporal/samples/countinterceptor)
+- the use of a Client Workflow Interceptor that counts the number of Workflow Executions and the number of Signals and Queries.
+
+## Start local Temporal Server
+```bash
+# run only once
+temporal server start-dev
+```
+
+## Run Worker Locally
+```bash
+# make sure you have temporal server running (see section above)
+dotnet run
+```
+
+## Run Worker using Temporal Cloud
+```bash
+# set up environment variables
+export TEMPORAL_NAMESPACE=<namespace>.<accountId>
+export TEMPORAL_ADDRESS=<namespace>.<accountId>.tmprl.cloud:7233
+export TEMPORAL_TLS_CERT=/path/to/cert
+export TEMPORAL_TLS_KEY=/path/to/key
+# run the worker
+dotnet run
+```

src/CounterInterceptor/SimpleClientCallsInterceptor.cs

@@ -0,0 +1,97 @@
+namespace TemporalioSamples.CounterInterceptor;
+
+using Temporalio.Client;
+using Temporalio.Client.Interceptors;
+
+public record ClientCounts
+{
+    public uint Executions { get; internal set; }
+
+    public uint Signals { get; internal set; }
+
+    public uint Queries { get; internal set; }
+
+    public override string ToString() =>
+        $"\n\tTotal Number of Workflow Exec: {Executions}\n\t" +
+        $"Total Number of Signals: {Signals}\n\t" +
+        $"Total Number of Queries: {Queries}";
+}
+
+public class SimpleClientCallsInterceptor : IClientInterceptor
+{
+    private const string NumberOfWorkflowExecutions = "numOfWorkflowExec";
+    private const string NumberOfSignals = "numOfSignals";
+    private const string NumberOfQueries = "numOfQueries";
+    private static Dictionary<string, ClientCounts> clientDictionary = new();
+
+    public ClientOutboundInterceptor InterceptClient(ClientOutboundInterceptor nextInterceptor) =>
+        new ClientOutbound(this, nextInterceptor);
+
+    public string Info() =>
+        string.Join(
+            "\n",
+            clientDictionary.Select(kvp => $"** Workflow ID: {kvp.Key} {kvp.Value}"));
+
+    public uint NumOfWorkflowExecutions(string workflowId) =>
+        clientDictionary[workflowId].Executions;
+
+    public uint NumOfSignals(string workflowId) =>
+        clientDictionary[workflowId].Signals;
+
+    public uint NumOfQueries(string workflowId) =>
+        clientDictionary[workflowId].Queries;
+
+    private void Add(string workflowId, string type)
+    {
+        if (!clientDictionary.TryGetValue(workflowId, out ClientCounts? value))
+        {
+            value = new ClientCounts();
+            clientDictionary.Add(workflowId, value);
+        }
+
+        switch (type)
+        {
+            case NumberOfWorkflowExecutions:
+                value.Executions++;
+                break;
+            case NumberOfQueries:
+                value.Queries++;
+                break;
+            case NumberOfSignals:
+                value.Signals++;
+                break;
+            default:
+                throw new NotImplementedException("Unknown type: " + type);
+        }
+    }
+
+    private class ClientOutbound : ClientOutboundInterceptor
+    {
+        private SimpleClientCallsInterceptor root;
+
+        public ClientOutbound(SimpleClientCallsInterceptor root, ClientOutboundInterceptor next)
+            : base(next) => this.root = root;
+
+        public override Task<WorkflowHandle<TWorkflow, TResult>> StartWorkflowAsync<TWorkflow, TResult>(
+            StartWorkflowInput input)
+        {
+            var id = input.Options.Id ?? "None";
+            root.Add(id, NumberOfWorkflowExecutions);
+            return base.StartWorkflowAsync<TWorkflow, TResult>(input);
+        }
+
+        public override Task SignalWorkflowAsync(SignalWorkflowInput input)
+        {
+            var id = input.Id ?? "None";
+            root.Add(id, NumberOfSignals);
+            return base.SignalWorkflowAsync(input);
+        }
+
+        public override Task<TResult> QueryWorkflowAsync<TResult>(QueryWorkflowInput input)
+        {
+            var id = input.Id ?? "None";
+            root.Add(id, NumberOfQueries);
+            return base.QueryWorkflowAsync<TResult>(input);
+        }
+    }
+}