Handle exceptions generated from ActivityTypeProviders

src/core/Elsa.Core/Services/Bookmarks/BookmarkIndexer.cs

@@ -146,23 +146,26 @@ private async Task<IEnumerable<Bookmark>> FindBookmarksAsync(string workflowInst
 
             foreach (var blockingActivity in blockingActivities)
             {
-                var activityExecutionContext = new ActivityExecutionContext(_serviceProvider, workflowExecutionContext, blockingActivity, null, false, cancellationToken);
-                var activityType = activityTypes[blockingActivity.Type];
-                var providerContext = new BookmarkProviderContext(activityExecutionContext, activityType, BookmarkIndexingMode.WorkflowInstance);
-                var providers = await FilterProvidersAsync(providerContext).ToListAsync(cancellationToken);
-
-                foreach (var provider in providers)
+                if(activityTypes.ContainsKey(blockingActivity.Type))
                 {
-                    var bookmarkResults = (await provider.GetBookmarksAsync(providerContext, cancellationToken)).ToList();
+                    var activityExecutionContext = new ActivityExecutionContext(_serviceProvider, workflowExecutionContext, blockingActivity, null, false, cancellationToken);
+                    var activityType = activityTypes[blockingActivity.Type];
+                    var providerContext = new BookmarkProviderContext(activityExecutionContext, activityType, BookmarkIndexingMode.WorkflowInstance);
+                    var providers = await FilterProvidersAsync(providerContext).ToListAsync(cancellationToken);
 
-                    bookmarkedWorkflows.AddRange(bookmarkResults.Select(bookmarkResult => new BookmarkedWorkflow
+                    foreach (var provider in providers)
                     {
-                        WorkflowBlueprint = workflowBlueprint,
-                        WorkflowInstanceId = workflowInstance.Id,
-                        ActivityType = bookmarkResult.ActivityTypeName ?? blockingActivity.Type,
-                        ActivityId = blockingActivity.Id,
-                        Bookmark = bookmarkResult.Bookmark
-                    }));
+                        var bookmarkResults = (await provider.GetBookmarksAsync(providerContext, cancellationToken)).ToList();
+
+                        bookmarkedWorkflows.AddRange(bookmarkResults.Select(bookmarkResult => new BookmarkedWorkflow
+                        {
+                            WorkflowBlueprint = workflowBlueprint,
+                            WorkflowInstanceId = workflowInstance.Id,
+                            ActivityType = bookmarkResult.ActivityTypeName ?? blockingActivity.Type,
+                            ActivityId = blockingActivity.Id,
+                            Bookmark = bookmarkResult.Bookmark
+                        }));
+                    }
                 }
             }
 

src/core/Elsa.Core/Services/Triggers/TriggersForActivityBlueprintAndWorkflowProvider.cs

@@ -39,19 +39,26 @@ public class TriggersForActivityBlueprintAndWorkflowProvider : IGetsTriggersForA
             IDictionary<string, ActivityType> activityTypes,
             CancellationToken cancellationToken = default)
         {
-            var bookmarkProviderContext = GetBookmarkProviderContext(activityBlueprint, workflowExecutionContext, cancellationToken, activityTypes);
-            var supportedBookmarkProviders = await GetSupportedBookmarkProvidersForContextAsync(bookmarkProviderContext)
-                .ToListAsync(cancellationToken);
+            if (activityTypes.ContainsKey(activityBlueprint.Type))
+            {
+                var bookmarkProviderContext = GetBookmarkProviderContext(activityBlueprint, workflowExecutionContext, cancellationToken, activityTypes);
+                var supportedBookmarkProviders = await GetSupportedBookmarkProvidersForContextAsync(bookmarkProviderContext)
+                    .ToListAsync(cancellationToken);
 
-            var tasksOfListsOfTriggers = supportedBookmarkProviders
-                .Select(bookmarkProvider => GetTriggersForBookmarkProvider(bookmarkProvider,
-                    bookmarkProviderContext,
-                    activityBlueprint,
-                    workflowExecutionContext.WorkflowBlueprint,
-                    cancellationToken));
-            return (await Task.WhenAll(tasksOfListsOfTriggers))
-                .SelectMany(x => x)
-                .ToList();
+                var tasksOfListsOfTriggers = supportedBookmarkProviders
+                    .Select(bookmarkProvider => GetTriggersForBookmarkProvider(bookmarkProvider,
+                        bookmarkProviderContext,
+                        activityBlueprint,
+                        workflowExecutionContext.WorkflowBlueprint,
+                        cancellationToken));
+                return (await Task.WhenAll(tasksOfListsOfTriggers))
+                    .SelectMany(x => x)
+                    .ToList();
+            }
+            else
+            {
+                return Enumerable.Empty<WorkflowTrigger>();
+            }
         }
 
         private BookmarkProviderContext GetBookmarkProviderContext(

src/core/Elsa.Core/Services/Workflows/ActivityTypeService.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
@@ -11,6 +12,7 @@
 using Elsa.Services.Models;
 using MediatR;
 using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Logging;
 
 namespace Elsa.Services.Workflows
 {
@@ -22,12 +24,15 @@ public class ActivityTypeService : IActivityTypeService
         private readonly IMediator _mediator;
         private readonly ICacheSignal _cacheSignal;
 
-        public ActivityTypeService(IEnumerable<IActivityTypeProvider> providers, IMemoryCache memoryCache, IMediator mediator, ICacheSignal cacheSignal)
+        private readonly ILogger _logger;
+
+        public ActivityTypeService(IEnumerable<IActivityTypeProvider> providers, IMemoryCache memoryCache, IMediator mediator, ICacheSignal cacheSignal, ILogger<ActivityTypeService> logger)
         {
             _providers = providers;
             _memoryCache = memoryCache;
             _mediator = mediator;
             _cacheSignal = cacheSignal;
+            _logger = logger;
         }
 
         public async ValueTask<IEnumerable<ActivityType>> GetActivityTypesAsync(CancellationToken cancellationToken) => (await GetDictionaryAsync(cancellationToken)).Values;
@@ -77,10 +82,20 @@ private async IAsyncEnumerable<ActivityType> GetActivityTypesInternalAsync([Enum
         {
             foreach (var provider in _providers)
             {
-                var types = await provider.GetActivityTypesAsync(cancellationToken);
+                IEnumerable<ActivityType> types = Enumerable.Empty<ActivityType>();
+
+                try
+                {
+                    types = await provider.GetActivityTypesAsync(cancellationToken);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "An error occured while generating activities from provider {provider}", provider.GetType());
+                }
 
                 foreach (var type in types)
                     yield return type;
+
             }
         }
     }