Durable Functions Monitor

The repository contains several packages that serve different deployment and integration needs:

• durablefunctionsmonitor.dotnetbackend: A .NET InProc backend that implements RESTful APIs on top of the Durable Task Framework and serves the React UI statics.
• durablefunctionsmonitor.dotnetisolated.core: A .NET Isolated backend implementation. This is the package you should "inject" into your own .NET Isolated Function projects.
• durablefunctionsmonitor.dotnetisolated: A complete .NET Isolated Function project that can be deployed as a standalone Function App instance.
• durablefunctionsmonitor.react: The client-side React application (TypeScript) that provides the monitoring UI.
• durablefunctionsmonitor-vscodeext: The implementation for the VS Code extension.
• custom-backends: Implementations for older framework versions or non-default storage providers like MSSQL or Netherite.

You can deploy a standalone .NET 7 Isolated version of the DurableFunctionsMonitor backend to your Azure Subscription using the provided ARM template.

Prerequisites:

• An existing Azure Active Directory (AAD) application.
• The Client ID of your AAD application.

Deployment Steps:

1. Use the Deploy to Azure button to start the deployment wizard.
2. When prompted for template parameters, provide the Client Id of your AAD application.
3. Note that the instance will be deployed to the location of your selected Resource Group. The Region parameter in the Azure Portal wizard only affects deployment metadata and does not control the actual deployment location.

This deployment installs the backend from the DurableFunctionsMonitor.DotNetIsolated NuGet package.

To run the Netherite storage provider backend locally, follow these steps:

1. Clone the repository.
2. Create a local.settings.json file in the project folder with the required connection strings, or set them as environment variables.
3. Edit the host.json file to specify the taskhub name that matches the application you wish to monitor.
4. Navigate to the Dfm.Netherite directory in your terminal and run func start.
5. Access the monitor at http://localhost:7072/ (or the port specified in Properties/launchSettings.json).

Important Note: The monitored function app must be running for DFM to display information. If the monitored application is unresponsive, DFM will also be unresponsive. This differs from Azure Storage or SQL providers where the storage service can be queried directly.

{
  "IsEncrypted": false,
  "Values": {
    "DFM_NONCE": "i_sure_know_what_i_am_doing",
    "AzureWebJobsStorage": "insert-azure-storage-connection-string-here",
    "EventHubsConnection": "insert-eventhubs-sas-connection-string-here"
  },
  "Host": {
    "LocalHttpPort": 7072
  }
}

Durable Functions Monitor is a VS Code extension that allows you to list, monitor, and debug Azure Durable Functions.

Setup

1. Install the extension from the VS Code Marketplace or via a VSIX file.
2. Once installed, a DURABLE FUNCTIONS tab will appear in the AZURE view container.
   • Note: If you do not have the Azure Account extension installed, the tab will appear in the default EXPLORER view container instead.

Connecting to Task Hubs

The extension automatically discovers Task Hubs from:

• Your Azure Subscriptions (if signed in via Azure: Sign In).
• Your currently opened Azure Functions project.
• A running Local Storage Emulator.

To connect to an arbitrary storage account or database (Microsoft SQL Server/Azure SQL), use the Attach to Task Hub... command or click the attach button in the extension view. You will need to provide:

• A Connection String (Azure Storage or Microsoft SQL Server).
• A Task Hub name.

Connection strings are securely stored using the VS Code SecretStorage API.

By default, the monitor endpoint is served at http://localhost:7071/my-api-route-prefix/durable-functions-monitor. To serve it from a different route (such as the root), implement a custom class that inherits from ServeStatics and define an Azure Function with an HttpTrigger that calls this.DfmServeStaticsFunction.

namespace DurableFunctionsMonitor.DotNetIsolated
{
    public class MyCustomDfMonEndpoint: ServeStatics
    {
        public MyCustomDfMonEndpoint(DfmSettings dfmSettings, DfmExtensionPoints extensionPoints, ILoggerFactory loggerFactory) : 
            base(dfmSettings, extensionPoints, loggerFactory)
        {
        }

        [Function(nameof(MyCustomDfMonEndpoint))]
        public Task<HttpResponseData> ServeDfMonStatics(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "/{p1?}/{p2?}/{p3?}")] HttpRequestData req,
            string p1,
            string p2,
            string p3
        )
        {
            return this.DfmServeStaticsFunction(req, p1, p2, p3);
        }
    }
}