[Do Not Merge] Change default of external event publishing

docs/usage-report.md

@@ -133,7 +133,7 @@ The primary's `TransportEnvironmentDataProvider` emits `Transport.Type` and adds
 | --- | --- | --- | --- |
 | `Features.IntegratedServicePulse` | `Enabled`, `Disabled` | `ServiceControl/EnableIntegratedServicePulse` | 6.13.0 |
 | `Features.MessageEditing` | `Enabled`, `Disabled` | `ServiceControl/AllowMessageEditing` | 6.20.0 |
-| `Features.ExternalIntegrationsPublishing` | `Enabled`, `Disabled` | `ServiceControl/DisableExternalIntegrationsPublishing`, inverted | 6.20.0 |
+| `Features.ExternalIntegrationsPublishing` | `Enabled`, `Disabled` | `ServiceControl/EnableExternalIntegrationsPublishing`, or the legacy `ServiceControl/DisableExternalIntegrationsPublishing` inverted | 6.20.0 |
 | `Features.ForwardErrorMessages` | `Enabled`, `Disabled` | `ServiceControl/ForwardErrorMessages` | 6.20.0 |
 | `Features.EmailNotifications` | `Enabled`, `Disabled`, `NotConfigured` | the stored email settings | 6.20.0 |
 | `Features.ErrorIngestion` | `Enabled`, `Disabled` | `ServiceControl/IngestErrorMessages` | Unreleased |

src/ServiceControl.AcceptanceTests/Monitoring/ExternalIntegration/When_a_custom_check_fails.cs

@@ -19,6 +19,7 @@ class When_a_custom_check_fails : AcceptanceTest
         public async Task Should_publish_notification()
         {
             var externalProcessorSubscribed = false;
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomConfiguration = config => config.OnEndpointSubscribed<MyContext>((s, ctx) =>
             {
                 if (s.SubscriberReturnAddress.IndexOf("ExternalProcessor", StringComparison.OrdinalIgnoreCase) >= 0)

src/ServiceControl.AcceptanceTests/Monitoring/ExternalIntegration/When_a_custom_check_succeeds.cs

@@ -19,6 +19,7 @@ class When_a_custom_check_succeeds : AcceptanceTest
         public async Task Should_publish_notification()
         {
             var externalProcessorSubscribed = false;
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomConfiguration = config => config.OnEndpointSubscribed<MyContext>((s, ctx) =>
             {
                 if (s.SubscriberReturnAddress.IndexOf("ExternalProcessor", StringComparison.OrdinalIgnoreCase) >= 0)

src/ServiceControl.AcceptanceTests/Monitoring/ExternalIntegration/When_heartbeat_is_restored.cs

@@ -24,6 +24,7 @@ public async Task Should_publish_notification()
         {
             var externalProcessorSubscribed = false;
 
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomConfiguration = config => config.OnEndpointSubscribed<MyContext>((s, ctx) =>
             {
                 if (s.SubscriberReturnAddress.IndexOf("ExternalProcessor", StringComparison.OrdinalIgnoreCase) >= 0)

src/ServiceControl.AcceptanceTests/Monitoring/ExternalIntegration/When_heartbeat_loss_is_detected.cs

@@ -25,6 +25,7 @@ public async Task Should_publish_notification()
         {
             var externalProcessorSubscribed = false;
 
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomConfiguration = config => config.OnEndpointSubscribed<MyContext>((s, ctx) =>
             {
                 if (s.SubscriberReturnAddress.IndexOf("ExternalProcessor", StringComparison.OrdinalIgnoreCase) >= 0)

src/ServiceControl.AcceptanceTests/Recoverability/ExternalIntegration/When_a_failed_edit_is_resolved_by_retry.cs

@@ -18,6 +18,7 @@ class When_a_failed_edit_is_resolved_by_retry : AcceptanceTest
         [Test]
         public async Task Should_publish_notification()
         {
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomConfiguration = config => config.OnEndpointSubscribed<EditMessageResolutionContext>((s, ctx) =>
             {
                 ctx.ExternalProcessorSubscribed = s.SubscriberReturnAddress.Contains(nameof(MessageReceiver));

src/ServiceControl.AcceptanceTests/Recoverability/ExternalIntegration/When_a_failed_message_is_archived.cs

@@ -16,6 +16,7 @@ class When_a_failed_message_is_archived : ExternalIntegrationAcceptanceTest
         [Test]
         public async Task Should_publish_notification()
         {
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomConfiguration = config => config.OnEndpointSubscribed<Context>((s, ctx) =>
             {
                 ctx.ExternalProcessorSubscribed = s.SubscriberReturnAddress.Contains(nameof(ExternalProcessor));

src/ServiceControl.AcceptanceTests/Recoverability/ExternalIntegration/When_a_failed_message_is_resolved_by_retry.cs

@@ -16,6 +16,7 @@ class When_a_failed_message_is_resolved_by_retry : ExternalIntegrationAcceptance
         [Test]
         public async Task Should_publish_notification()
         {
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomConfiguration = config => config.OnEndpointSubscribed<Context>((s, ctx) =>
             {
                 ctx.ExternalProcessorSubscribed = s.SubscriberReturnAddress.Contains(nameof(ExternalProcessor));

src/ServiceControl.AcceptanceTests/Recoverability/ExternalIntegration/When_a_failed_message_is_resolved_manually.cs

@@ -18,6 +18,7 @@ class When_a_failed_message_is_resolved_manually : ExternalIntegrationAcceptance
         [Test]
         public async Task Should_publish_notification()
         {
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomConfiguration = config => config.OnEndpointSubscribed<Context>((s, ctx) =>
             {
                 if (s.SubscriberReturnAddress.IndexOf("ExternalProcessor", StringComparison.OrdinalIgnoreCase) >= 0)

src/ServiceControl.AcceptanceTests/Recoverability/ExternalIntegration/When_a_failed_message_is_unarchived.cs

@@ -18,6 +18,7 @@ class When_a_failed_message_is_unarchived : ExternalIntegrationAcceptanceTest
         [Test]
         public async Task Should_publish_notification()
         {
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomConfiguration = config => config.OnEndpointSubscribed<Context>((s, ctx) =>
             {
                 if (s.SubscriberReturnAddress.IndexOf("ExternalProcessor", StringComparison.OrdinalIgnoreCase) >= 0)

src/ServiceControl.AcceptanceTests/Recoverability/ExternalIntegration/When_a_failed_msg_is_resolved_by_edit.cs

@@ -17,6 +17,7 @@ class When_a_failed_msg_is_resolved_by_edit : AcceptanceTest
         [Test]
         public async Task Should_publish_notification()
         {
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomConfiguration = config => config.OnEndpointSubscribed<EditMessageResolutionContext>((s, ctx) =>
             {
                 ctx.ExternalProcessorSubscribed = s.SubscriberReturnAddress.Contains(nameof(MessageReceiver));

src/ServiceControl.AcceptanceTests/Recoverability/ExternalIntegration/When_a_group_is_archived.cs

@@ -18,6 +18,7 @@ class When_a_group_is_archived : ExternalIntegrationAcceptanceTest
         [Test]
         public async Task Should_publish_notification()
         {
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomConfiguration = config => config.OnEndpointSubscribed<Context>((s, ctx) =>
             {
                 if (s.SubscriberReturnAddress.IndexOf("ExternalProcessor", StringComparison.OrdinalIgnoreCase) >= 0)

src/ServiceControl.AcceptanceTests/Recoverability/ExternalIntegration/When_a_message_has_failed_detected.cs

@@ -16,6 +16,7 @@ class When_a_message_has_failed_detected : AcceptanceTest
         [Test]
         public async Task Should_publish_notification()
         {
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomConfiguration = config => config.OnEndpointSubscribed<MyContext>((s, ctx) =>
             {
                 if (s.SubscriberReturnAddress.IndexOf("ExternalProcessor", StringComparison.OrdinalIgnoreCase) >= 0)

src/ServiceControl.AcceptanceTests/Recoverability/ExternalIntegration/When_a_reedit_solves_a_failed_msg.cs

@@ -18,6 +18,7 @@ class When_a_reedit_solves_a_failed_msg : AcceptanceTest
         [Test]
         public async Task Should_publish_notification()
         {
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomConfiguration = config => config.OnEndpointSubscribed<EditMessageResolutionContext>((s, ctx) =>
             {
                 ctx.ExternalProcessorSubscribed = s.SubscriberReturnAddress.Contains(nameof(MessageReceiver));

src/ServiceControl.AcceptanceTests/Recoverability/ExternalIntegration/When_encountered_an_error.cs

@@ -29,6 +29,7 @@ public async Task Should_restart_dispatch_thread()
         {
             var externalProcessorSubscribed = false;
 
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomizeHostBuilder = builder => builder.Services.AddSingleton<IEventPublisher, FaultyPublisher>();
 
             CustomConfiguration = config =>

src/ServiceControl.AcceptanceTests/Recoverability/When_edited_message_fails_to_process.cs

@@ -19,6 +19,7 @@ class When_edited_message_fails_to_process : AcceptanceTest
         [Test]
         public async Task A_new_message_failure_is_created()
         {
+            SetSettings = settings => settings.EnableExternalIntegrationsPublishing = true;
             CustomConfiguration = config => config.OnEndpointSubscribed<EditMessageFailureContext>((s, ctx) =>
             {
                 ctx.ExternalProcessorSubscribed = s.SubscriberReturnAddress.Contains(nameof(FailingEditedMessageReceiver));

src/ServiceControl.UnitTests/ApprovalFiles/APIApprovals.PlatformSampleSettings.approved.txt

@@ -49,7 +49,7 @@
   "EmailDropFolder": null,
   "ValidateConfiguration": true,
   "ExternalIntegrationsDispatchingBatchSize": 100,
-  "DisableExternalIntegrationsPublishing": false,
+  "EnableExternalIntegrationsPublishing": false,
   "RunCleanupBundle": false,
   "RootUrl": "http://localhost:8888/",
   "ApiUrl": "http://localhost:8888/api",

src/ServiceControl.UnitTests/Infrastructure/Settings/ExternalIntegrationsPublishingSettingsTests.cs

@@ -0,0 +1,68 @@
+namespace ServiceControl.UnitTests.Infrastructure.Settings;
+
+using System;
+using NUnit.Framework;
+using ServiceBus.Management.Infrastructure.Settings;
+
+[TestFixture]
+[NonParallelizable]
+class ExternalIntegrationsPublishingSettingsTests
+{
+    const string Variable = "SERVICECONTROL_ENABLEEXTERNALINTEGRATIONSPUBLISHING";
+    const string LegacyVariable = "SERVICECONTROL_DISABLEEXTERNALINTEGRATIONSPUBLISHING";
+
+    string originalValue;
+    string originalLegacyValue;
+
+    [SetUp]
+    public void SetUp()
+    {
+        originalValue = Environment.GetEnvironmentVariable(Variable);
+        originalLegacyValue = Environment.GetEnvironmentVariable(LegacyVariable);
+        Environment.SetEnvironmentVariable(Variable, null);
+        Environment.SetEnvironmentVariable(LegacyVariable, null);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        Environment.SetEnvironmentVariable(Variable, originalValue);
+        Environment.SetEnvironmentVariable(LegacyVariable, originalLegacyValue);
+    }
+
+    [Test]
+    public void Is_disabled_when_neither_setting_is_configured() =>
+        Assert.That(new Settings().EnableExternalIntegrationsPublishing, Is.False);
+
+    [TestCase("true", true)]
+    [TestCase("false", false)]
+    public void Reads_the_enable_setting(string value, bool expected)
+    {
+        Environment.SetEnvironmentVariable(Variable, value);
+
+        Assert.That(new Settings().EnableExternalIntegrationsPublishing, Is.EqualTo(expected));
+    }
+
+    [TestCase("true", false)]
+    [TestCase("false", true)]
+    public void Treats_the_legacy_setting_as_the_inverse(string value, bool expected)
+    {
+        Environment.SetEnvironmentVariable(LegacyVariable, value);
+
+        Assert.That(new Settings().EnableExternalIntegrationsPublishing, Is.EqualTo(expected));
+    }
+
+    [TestCase("true", "true")]
+    [TestCase("true", "false")]
+    [TestCase("false", "true")]
+    [TestCase("false", "false")]
+    public void Rejects_both_settings_being_configured(string enable, string disable)
+    {
+        Environment.SetEnvironmentVariable(Variable, enable);
+        Environment.SetEnvironmentVariable(LegacyVariable, disable);
+
+        var ex = Assert.Throws<Exception>(() => _ = new Settings());
+
+        Assert.That(ex.Message, Does.Contain("cannot both be configured"));
+    }
+}

src/ServiceControl.UnitTests/Licensing/ServiceControlErrorInstanceEnvironmentDataProviderTests.cs

@@ -93,6 +93,19 @@ public async Task Should_report_feature_switches_from_configuration()
         }
     }
 
+    [TestCase("SERVICECONTROL_ENABLEEXTERNALINTEGRATIONSPUBLISHING", "true", "Enabled")]
+    [TestCase("SERVICECONTROL_ENABLEEXTERNALINTEGRATIONSPUBLISHING", "false", "Disabled")]
+    [TestCase("SERVICECONTROL_DISABLEEXTERNALINTEGRATIONSPUBLISHING", "false", "Enabled")]
+    [TestCase("SERVICECONTROL_DISABLEEXTERNALINTEGRATIONSPUBLISHING", "true", "Disabled")]
+    public async Task Should_report_external_integrations_publishing_from_either_key(string variable, string value, string expected)
+    {
+        Environment.SetEnvironmentVariable(variable, value);
+
+        var data = await GetData();
+
+        Assert.That(data["Features.ExternalIntegrationsPublishing"], Is.EqualTo(expected));
+    }
+
     [Test]
     public async Task Should_report_otlp_metrics_export_without_the_endpoint()
     {
@@ -158,6 +171,8 @@ public Task SaveSettings(NotificationsSettings settings, CancellationToken cance
         "DEFAULT_ROUTE",
         "SHOW_PENDING_RETRY",
         "SERVICECONTROL_INGESTERRORMESSAGES",
-        "SERVICECONTROL_VIRTUALDIRECTORY"
+        "SERVICECONTROL_VIRTUALDIRECTORY",
+        "SERVICECONTROL_ENABLEEXTERNALINTEGRATIONSPUBLISHING",
+        "SERVICECONTROL_DISABLEEXTERNALINTEGRATIONSPUBLISHING"
     ];
 }

src/ServiceControl/CustomChecks/CustomChecksComponent.cs

@@ -14,7 +14,7 @@ class CustomChecksComponent : ServiceControlComponent
         public override void Setup(Settings settings, IComponentInstallationContext context, IHostApplicationBuilder hostBuilder)
         {
             // Integration Events
-            if (!settings.DisableExternalIntegrationsPublishing)
+            if (settings.EnableExternalIntegrationsPublishing)
             {
                 context.AddEventPublished<CustomCheckFailed>();
                 context.AddEventPublished<CustomCheckSucceeded>();

src/ServiceControl/ExternalIntegrations/ExternalIntegrationsComponent.cs

@@ -14,7 +14,7 @@ public override void Configure(Settings settings, ITransportCustomization transp
             var services = hostBuilder.Services;
             services.AddEventLogMapping<ExternalIntegrationEventFailedToBePublishedDefinition>();
 
-            if (!settings.DisableExternalIntegrationsPublishing)
+            if (settings.EnableExternalIntegrationsPublishing)
             {
                 services.AddDomainEventHandler<IntegrationEventWriter>();
 

src/ServiceControl/HostApplicationBuilderExtensions.cs

@@ -211,6 +211,7 @@ Audit Retention Period (optional):  {settings.AuditRetentionPeriod}
 ServiceControl Logging Level:       {settings.LoggingSettings.LogLevel}
 Selected Transport Customization:   {settings.TransportType}
 Integrated ServicePulse:            {(settings.EnableIntegratedServicePulse ? "Enabled" : "Disabled")}
+External Integrations Publishing:   {(settings.EnableExternalIntegrationsPublishing ? "Enabled" : "Disabled")}
 -------------------------------------------------------------";
 
             var logger = LoggerUtil.CreateStaticLogger(typeof(HostApplicationBuilderExtensions), settings.LoggingSettings.LogLevel);

src/ServiceControl/Infrastructure/NServiceBusFactory.cs

@@ -41,7 +41,7 @@ public static void Configure(Settings.Settings settings, ITransportCustomization
             configuration.GetSettings().Set(settings.LoggingSettings);
             configuration.SetDiagnosticsPath(settings.LoggingSettings.LogPath);
 
-            if (!settings.DisableExternalIntegrationsPublishing)
+            if (settings.EnableExternalIntegrationsPublishing)
             {
                 configuration.EnableFeature<ExternalIntegrationsFeature>();
             }

src/ServiceControl/Infrastructure/Settings/Settings.cs

@@ -84,7 +84,7 @@ public Settings(
             ErrorIngestionBatchSize = IngestionSettingsReader.ReadBatchSize(SettingsRootNamespace, nameof(ErrorIngestionBatchSize), ValidateConfiguration);
             ErrorIngestionMaxParallelWriters = IngestionSettingsReader.ReadMaxParallelWriters(SettingsRootNamespace, nameof(ErrorIngestionMaxParallelWriters), ValidateConfiguration);
             ErrorIngestionBatchTimeout = IngestionSettingsReader.ReadBatchTimeout(SettingsRootNamespace, nameof(ErrorIngestionBatchTimeout), ValidateConfiguration);
-            DisableExternalIntegrationsPublishing = SettingsReader.Read(SettingsRootNamespace, "DisableExternalIntegrationsPublishing", false);
+            EnableExternalIntegrationsPublishing = ReadEnableExternalIntegrationsPublishing();
             TrackInstancesInitialValue = SettingsReader.Read(SettingsRootNamespace, "TrackInstancesInitialValue", true);
             ShutdownTimeout = SettingsReader.Read(SettingsRootNamespace, ShutdownTimeoutKey, ShutdownTimeout);
             AssemblyLoadContextResolver = static assemblyPath => new PluginAssemblyLoadContext(assemblyPath);
@@ -132,7 +132,7 @@ public Settings(
 
         public int ExternalIntegrationsDispatchingBatchSize => SettingsReader.Read(SettingsRootNamespace, ExternalIntegrationsDispatchingBatchSizeKey, 100);
 
-        public bool DisableExternalIntegrationsPublishing { get; set; }
+        public bool EnableExternalIntegrationsPublishing { get; set; }
 
         public bool RunCleanupBundle { get; set; }
 
@@ -305,6 +305,21 @@ TimeSpan GetEventRetentionPeriod()
             return SettingsReader.Read(SettingsRootNamespace, "EventsRetentionPeriod", TimeSpan.FromDays(14));
         }
 
+        bool ReadEnableExternalIntegrationsPublishing()
+        {
+            var legacyConfigured = SettingsReader.TryRead<bool>(SettingsRootNamespace, "DisableExternalIntegrationsPublishing", out var disable);
+            var configured = SettingsReader.TryRead<bool>(SettingsRootNamespace, "EnableExternalIntegrationsPublishing", out var enable);
+
+            if (legacyConfigured && configured)
+            {
+                const string message = "EnableExternalIntegrationsPublishing and the legacy DisableExternalIntegrationsPublishing settings cannot both be configured, please remove DisableExternalIntegrationsPublishing";
+                logger.LogCritical(message);
+                throw new Exception(message);
+            }
+
+            return legacyConfigured ? !disable : enable;
+        }
+
         TimeSpan GetErrorRetentionPeriod()
         {
             string message;

src/ServiceControl/Monitoring/HeartbeatMonitoringComponent.cs

@@ -20,7 +20,7 @@ class HeartbeatMonitoringComponent : ServiceControlComponent
         public override void Setup(Settings settings, IComponentInstallationContext context, IHostApplicationBuilder hostBuilder)
         {
             // Integration Events
-            if (!settings.DisableExternalIntegrationsPublishing)
+            if (settings.EnableExternalIntegrationsPublishing)
             {
                 context.AddEventPublished<HeartbeatRestored>();
                 context.AddEventPublished<HeartbeatStopped>();

src/ServiceControl/Recoverability/RecoverabilityComponent.cs

@@ -42,7 +42,7 @@ public override void Setup(Settings settings, IComponentInstallationContext cont
             }
 
             // Integration Events
-            if (!settings.DisableExternalIntegrationsPublishing)
+            if (settings.EnableExternalIntegrationsPublishing)
             {
                 context.AddEventPublished<FailedMessagesArchived>();
                 context.AddEventPublished<FailedMessagesUnArchived>();

src/ServiceControl/ServiceControlErrorInstanceEnvironmentDataProvider.cs

@@ -19,7 +19,7 @@ public IEnumerable<EnvironmentDatum> GetData() =>
     [
         Value("Features.IntegratedServicePulse", () => Toggle(settings.EnableIntegratedServicePulse)),
         Value("Features.MessageEditing", () => Toggle(settings.AllowMessageEditing)),
-        Value("Features.ExternalIntegrationsPublishing", () => Toggle(!settings.DisableExternalIntegrationsPublishing)),
+        Value("Features.ExternalIntegrationsPublishing", () => Toggle(settings.EnableExternalIntegrationsPublishing)),
         Value("Features.ForwardErrorMessages", () => Toggle(settings.ForwardErrorMessages)),
         Value("Features.ErrorIngestion", () => Toggle(settings.IngestErrorMessages)),
         Value("Features.ConfigurationValidation", () => Toggle(settings.ValidateConfiguration)),