Handle logging arguments in provider's getEngineAddress (#536)

Passing a --logflow argument to the CLI will make it pass all its
arguments to providers. This PR ports this [Node.js
implementation](https://github.com/pulumi/pulumi/blob/05970ff66567eeed7723d7b6ee2c37d3b464f580/sdk/nodejs/provider/internals.ts#L30-L53)
and [Java
implementation](pulumi/pulumi-java#1708) that
discards known logging parameters from engine address calculation.

~This change now requires an address while previously it was optional. I
believe this is a correct change, again in line with other SDKs, but let
me know if there are legit cases when address is not passed.~

Author: mikhailshilkov

.changes/unreleased/bug-fixes-536.yaml

@@ -0,0 +1,6 @@
+component: sdk/provider
+kind: bug-fixes
+body: Handle logging arguments in provider's getEngineAddress
+time: 2025-03-10T11:10:52.170215+01:00
+custom:
+    PR: "536"

sdk/Pulumi.Tests/Provider/ProviderTests.cs

@@ -86,4 +86,88 @@ public async Task NotImplementedErrorIncludesName()
             Assert.Contains("GetSchema", exc.Message);
         }
     }
+
+    public class ProviderEngineAddressTests
+    {
+        private static string? GetEngineAddress(string[] args)
+        {
+            // Helper method to access the private static method for testing
+            var method = typeof(Pulumi.Experimental.Provider.Provider).GetMethod(
+                "GetEngineAddress",
+                System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
+
+            try
+            {
+                return (string?)method?.Invoke(null, new object[] { args });
+            }
+            catch (System.Reflection.TargetInvocationException ex)
+            {
+                if (ex.InnerException != null)
+                    throw ex.InnerException;
+                throw;
+            }
+        }
+
+        [Fact]
+        public void GetEngineAddress_WithValidAddress_ReturnsAddress()
+        {
+            var args = new[] { "127.0.0.1:51776" };
+            var address = GetEngineAddress(args);
+            Assert.Equal("127.0.0.1:51776", address);
+        }
+
+        [Fact]
+        public void GetEngineAddress_WithLoggingArgs_ReturnsAddress()
+        {
+            var args = new[] {
+                "--logtostderr",
+                "-v=3",
+                "127.0.0.1:51776",
+                "--logflow"
+            };
+            var address = GetEngineAddress(args);
+            Assert.Equal("127.0.0.1:51776", address);
+        }
+
+        [Fact]
+        public void GetEngineAddress_WithTracingArg_ReturnsAddress()
+        {
+            var args = new[] {
+                "--tracing",
+                "1",
+                "127.0.0.1:51776"
+            };
+            var address = GetEngineAddress(args);
+            Assert.Equal("127.0.0.1:51776", address);
+        }
+
+        [Fact]
+        public void GetEngineAddress_WithNoArgs_ReturnsNull()
+        {
+            var args = Array.Empty<string>();
+            var address = GetEngineAddress(args);
+            Assert.Null(address);
+        }
+
+        [Fact]
+        public void GetEngineAddress_WithOnlyLoggingArgs_ReturnsNull()
+        {
+            var args = new[] { "--logtostderr", "-v10", "--logflow" };
+            var address = GetEngineAddress(args);
+            Assert.Null(address);
+        }
+
+        [Fact]
+        public void GetEngineAddress_WithMultipleAddresses_ThrowsException()
+        {
+            var args = new[] {
+                "127.0.0.1:51776",
+                "127.0.0.1:51777"
+            };
+            var ex = Assert.Throws<ArgumentException>(() => GetEngineAddress(args));
+            Assert.Equal(
+                "Expected at most one engine address argument, but got 2 non-logging arguments",
+                ex.Message);
+        }
+    }
 }

sdk/Pulumi/Provider/Provider.cs

@@ -542,6 +542,8 @@ internal static Microsoft.Extensions.Hosting.IHost BuildHost(
             // maxRpcMessageSize raises the gRPC Max message size from `4194304` (4mb) to `419430400` (400mb)
             var maxRpcMessageSize = 400 * 1024 * 1024;
 
+            var engineAddress = GetEngineAddress(args);
+
             return Host.CreateDefaultBuilder()
                 .ConfigureWebHostDefaults(webBuilder =>
                 {
@@ -560,9 +562,9 @@ internal static Microsoft.Extensions.Hosting.IHost BuildHost(
                             config.Sources.Clear();
 
                             var memConfig = new Dictionary<string, string?>();
-                            if (args.Length > 0)
+                            if (engineAddress != null)
                             {
-                                memConfig.Add("Host", args[0]);
+                                memConfig.Add("Host", engineAddress);
                             }
                             if (version != null)
                             {
@@ -600,6 +602,41 @@ internal static Microsoft.Extensions.Hosting.IHost BuildHost(
                 })
                 .Build();
         }
+
+        private static string? GetEngineAddress(string[] args)
+        {
+            var cleanArgs = new List<string>();
+
+            for (int i = 0; i < args.Length; i++)
+            {
+                var arg = args[i];
+
+                // Skip logging-related arguments
+                if (arg == "--logtostderr") continue;
+                if (arg.StartsWith("-v")) continue;
+                if (arg == "--logflow") continue;
+                if (arg == "--tracing")
+                {
+                    i++; // Skip the tracing value
+                    continue;
+                }
+
+                cleanArgs.Add(arg);
+            }
+
+            if (cleanArgs.Count == 0)
+            {
+                return null;
+            }
+
+            if (cleanArgs.Count > 1)
+            {
+                throw new ArgumentException(
+                    $"Expected at most one engine address argument, but got {cleanArgs.Count} non-logging arguments");
+            }
+
+            return cleanArgs[0];
+        }
     }
 
     class ResourceProviderService : ResourceProvider.ResourceProviderBase, IDisposable