Added Counter Interceptor Sample

README.md

@@ -17,6 +17,7 @@ Prerequisites:
 * [ActivityWorker](src/ActivityWorker) - Use .NET activities from a workflow in another language.
 * [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.
+* [CounterInterceptor](src/CounterInterceptor/) - Simple Workflow and Client Interceptors example.
 * [ContextPropagation](src/ContextPropagation) - Context propagation via interceptors.
 * [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.

src/CounterInterceptor/ClientCounter.cs

@@ -0,0 +1,89 @@
+namespace TemporalioSamples.CounterInterceptor;
+
+using System.Numerics;
+
+public class ClientCounter
+{
+    private const string NumberOfWorkflowExecutions = "numOfWorkflowExec";
+    private const string NumberOfSignals = "numOfSignals";
+    private const string NumberOfQueries = "numOfQueries";
+    private static Dictionary<string, Dictionary<string, BigInteger?>> perWorkflowIdDictionary =
+        new Dictionary<string, Dictionary<string, BigInteger?>>();
+
+    public static string Info()
+    {
+        string result = string.Empty;
+        foreach (var item in perWorkflowIdDictionary)
+        {
+            var info = item.Value;
+            result = result +
+                "\n** Workflow ID: " + item.Key +
+                "\n\tTotal Number of Workflow Exec: " + info[NumberOfWorkflowExecutions] +
+                "\n\tTotal Number of Signals: " + info[NumberOfSignals] +
+                "\n\tTotal Number of Queries: " + info[NumberOfQueries];
+        }
+
+        return result;
+    }
+
+    public static BigInteger? NumOfWorkflowExecutions(string workflowId)
+    {
+        return perWorkflowIdDictionary[workflowId][NumberOfWorkflowExecutions];
+    }
+
+    public static BigInteger? NumOfSignals(string workflowId)
+    {
+        return perWorkflowIdDictionary[workflowId][NumberOfSignals];
+    }
+
+    public static BigInteger? NumOfQueries(string workflowId)
+    {
+        return perWorkflowIdDictionary[workflowId][NumberOfQueries];
+    }
+
+    public void AddStartInvocation(string workflowId)
+    {
+        Add(workflowId, NumberOfWorkflowExecutions);
+    }
+
+    public void AddSignalInvocation(string workflowId)
+    {
+        Add(workflowId, NumberOfSignals);
+    }
+
+    public void AddQueryInvocation(string workflowId)
+    {
+        Add(workflowId, NumberOfQueries);
+    }
+
+    // Creates a default counter info map for a workflowid
+    private static Dictionary<string, BigInteger?> GetDefaultInfoMap()
+    {
+        return new Dictionary<string, BigInteger?>()
+        {
+            { NumberOfWorkflowExecutions, 0 },
+            { NumberOfSignals, 0 },
+            { NumberOfQueries, 0 },
+        };
+    }
+
+    private void Add(string workflowId, string type)
+    {
+        if (!perWorkflowIdDictionary.TryGetValue(workflowId, out Dictionary<string, BigInteger?>? value))
+        {
+            value = GetDefaultInfoMap();
+            perWorkflowIdDictionary.Add(workflowId, value);
+        }
+
+        if (value[type] == null)
+        {
+            value[type] = 1;
+        }
+        else
+        {
+            var current = value[type];
+            var next = current + 1;
+            value[type] = next;
+        }
+    }
+}

src/CounterInterceptor/Constants.cs

@@ -0,0 +1,7 @@
+namespace TemporalioSamples.CounterInterceptor;
+
+public static class Constants
+{
+    public const string TaskQueue = "counter-interceptor-sample";
+    public const string ChildWorkflowId = "TestInterceptorChildWorkflow";
+}

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,21 @@
+namespace TemporalioSamples.CounterInterceptor;
+
+using Temporalio.Workflows;
+
+[Workflow]
+public class MyChildWorkflow
+{
+    private readonly ActivityOptions activityOptions = new()
+    {
+        StartToCloseTimeout = TimeSpan.FromSeconds(10),
+    };
+
+    [WorkflowRun]
+    public async Task<string> ExecChildAsync(string name, string title)
+    {
+        string result = await Workflow.ExecuteActivityAsync((MyActivities act) => act.SayHello(name, title), activityOptions);
+        result += await Workflow.ExecuteActivityAsync((MyActivities act) => act.SayGoodBye(name, title), activityOptions);
+
+        return result;
+    }
+}

src/CounterInterceptor/MyWorkflow.workflow.cs

@@ -0,0 +1,56 @@
+namespace TemporalioSamples.CounterInterceptor;
+
+using Temporalio.Workflows;
+
+[Workflow]
+public class MyWorkflow
+{
+    private string name = string.Empty;
+    private string title = string.Empty;
+    private bool exit; // automatically defaults to false
+
+    [WorkflowRun]
+    public async Task<string> ExecAsync()
+    {
+        // wait for greeting info
+        await Workflow.WaitConditionAsync(() => name != null && title != null);
+
+        // Execute Child Workflow
+        string result = await Workflow.ExecuteChildWorkflowAsync(
+            (MyChildWorkflow wf) => wf.ExecChildAsync(name, title),
+            new()
+            {
+                Id = Constants.ChildWorkflowId,
+            });
+
+        // Wait for exit signal
+        await Workflow.WaitConditionAsync(() => exit != false);
+
+        return result;
+    }
+
+    [WorkflowSignal]
+    public async Task SignalNameAndTitleAsync(string name, string title)
+    {
+        this.name = name;
+        this.title = title;
+    }
+
+    [WorkflowQuery]
+    public string QueryName()
+    {
+        return name;
+    }
+
+    [WorkflowQuery]
+    public string QueryTitle()
+    {
+        return title;
+    }
+
+    [WorkflowSignal]
+    public async Task ExitAsync()
+    {
+        this.exit = true;
+    }
+}

src/CounterInterceptor/Program.cs

@@ -0,0 +1,108 @@
+namespace TemporalioSamples.CounterInterceptor;
+
+using Temporalio.Client;
+using Temporalio.Worker;
+
+internal class Program
+{
+    private static async Task Main(string[] args)
+    {
+        static string GetEnvVarWithDefault(string envName, string defaultValue)
+        {
+            string? value = Environment.GetEnvironmentVariable(envName);
+            if (string.IsNullOrEmpty(value))
+            {
+                return defaultValue;
+            }
+            return value;
+        }
+
+        var address = GetEnvVarWithDefault("TEMPORAL_ADDRESS", "127.0.0.1:7233");
+        var temporalNamespace = GetEnvVarWithDefault("TEMPORAL_NAMESPACE", "default");
+        var tlsCertPath = GetEnvVarWithDefault("TEMPORAL_TLS_CERT", string.Empty);
+        var tlsKeyPath = GetEnvVarWithDefault("TEMPORAL_TLS_KEY", string.Empty);
+        TlsOptions? tls = null;
+        if (!string.IsNullOrEmpty(tlsCertPath) && !string.IsNullOrEmpty(tlsKeyPath))
+        {
+            tls = new()
+            {
+                ClientCert = await File.ReadAllBytesAsync(tlsCertPath),
+                ClientPrivateKey = await File.ReadAllBytesAsync(tlsKeyPath),
+            };
+        }
+
+        var client = await TemporalClient.ConnectAsync(
+            options: new(address)
+            {
+                Namespace = temporalNamespace,
+                Tls = tls,
+                Interceptors = new[]
+                {
+                    new SimpleClientCallsInterceptor(),
+                },
+            });
+
+        using var tokenSource = new CancellationTokenSource();
+        Console.CancelKeyPress += (_, eventArgs) =>
+        {
+            tokenSource.Cancel();
+            eventArgs.Cancel = true;
+        };
+
+        var activities = new MyActivities();
+
+        var workerOptions = new TemporalWorkerOptions(Constants.TaskQueue).
+                AddAllActivities(activities).
+                AddWorkflow<MyWorkflow>().
+                AddWorkflow<MyChildWorkflow>();
+
+        workerOptions.Interceptors = new[] { new SimpleCounterWorkerInterceptor() };
+
+        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.ExecAsync(),
+                new(id: Guid.NewGuid().ToString(), taskQueue: Constants.TaskQueue));
+
+            Console.WriteLine("Sending name and title to workflow");
+            await handle.SignalAsync(wf => wf.SignalNameAndTitleAsync("John", "Customer"));
+
+            var name = await handle.QueryAsync(wf => wf.QueryName());
+            var title = await handle.QueryAsync(wf => wf.QueryTitle());
+
+            // 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("Name: " + name);
+            Console.WriteLine("Title: " + title);
+
+            // print worker counter info
+            Console.WriteLine("Collected Worker Counter Info: ");
+            Console.WriteLine(WorkerCounter.Info());
+
+            // print client counter info
+            Console.WriteLine();
+            Console.WriteLine("Collected Client Counter Info:");
+            Console.WriteLine(ClientCounter.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 simple Worker Workflow Interceptor that counts the number of Workflow Executions, Child Workflow Executions, and Activity Executions as well as 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 simple Client Workflow Interceptor that counts the number of Workflow Executions as well as 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
+```