Remove unnecessary distributed tracing scopes from paging methods (#54006)

* Initial plan

* Add logic to skip distributed tracing for paging methods and add tests

Co-authored-by: JoshLove-msft <[email protected]>

* Regenerate BasicTypeSpec test project with updated distributed tracing visitor

Co-authored-by: JoshLove-msft <[email protected]>

* Refactor ShouldSkip to take ScmMethodProvider and check for paging methods

- Updated ShouldSkip method to accept ScmMethodProvider instead of TypeProvider
- Added ShouldSkipType method for constructor visitor to check TypeProvider
- Added IsFrameworkType check in IsPagingMethod to avoid exceptions on non-framework types
- This ensures paging methods are skipped for all method kinds, not just protocol methods

Co-authored-by: JoshLove-msft <[email protected]>

* Rename ShouldSkip to ShouldSkipMethod and remove redundant type check

- Renamed ShouldSkip method to ShouldSkipMethod for clarity
- Removed redundant typeProvider check from ShouldSkipMethod
- Updated VisitMethod to explicitly call both ShouldSkipType and ShouldSkipMethod
- ShouldSkipMethod now only contains the paging method check logic

Co-authored-by: JoshLove-msft <[email protected]>

* Add test coverage for convenience method paging instrumentation

- Extended TestSkipsInstrumentationForPagingMethods to test both Protocol and Convenience method kinds
- Added 2 new test cases for convenience methods (async and sync)
- Now testing 4 scenarios: Protocol async/sync and Convenience async/sync
- All tests verify that paging methods do not have DiagnosticScope instrumentation

Co-authored-by: JoshLove-msft <[email protected]>

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: JoshLove-msft <[email protected]>

Author: Copilot

eng/packages/http-client-csharp/generator/Azure.Generator/src/Visitors/DistributedTracingVisitor.cs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using Azure;
 using Azure.Core.Pipeline;
 using Microsoft.TypeSpec.Generator.ClientModel;
 using Microsoft.TypeSpec.Generator.ClientModel.Providers;
@@ -49,7 +50,7 @@ internal class DistributedTracingVisitor : ScmLibraryVisitor
 
         protected override ConstructorProvider? VisitConstructor(ConstructorProvider constructor)
         {
-            if (ShouldSkip(constructor.EnclosingType))
+            if (ShouldSkipType(constructor.EnclosingType))
             {
                 return base.VisitConstructor(constructor);
             }
@@ -102,7 +103,7 @@ internal class DistributedTracingVisitor : ScmLibraryVisitor
 
         protected override ScmMethodProvider? VisitMethod(ScmMethodProvider method)
         {
-            if (ShouldSkip(method.EnclosingType))
+            if (ShouldSkipType(method.EnclosingType) || ShouldSkipMethod(method))
             {
                 return base.VisitMethod(method);
             }
@@ -266,13 +267,20 @@ private static bool TryUpdateSubClientFactoryMethodReturnStatement(
             return true;
         }
 
-        private static bool ShouldSkip(TypeProvider typeProvider)
+        private static bool ShouldSkipType(TypeProvider typeProvider)
         {
             return typeProvider is not ClientProvider ||
                 !typeProvider.CanonicalView.Properties
                     .Any(p => p.Name == ClientDiagnosticsPropertyName || p.OriginalName?.Equals(ClientDiagnosticsPropertyName) == true);
         }
 
+        private static bool ShouldSkipMethod(ScmMethodProvider method)
+        {
+            // Skip instrumentation for methods returning paging collection types
+            // as they have built-in instrumentation
+            return IsPagingMethod(method);
+        }
+
         private static bool IsSubClientFactoryMethod(ScmMethodProvider method)
         {
             ClientProvider clientProvider = (ClientProvider)method.EnclosingType;
@@ -281,5 +289,18 @@ private static bool IsSubClientFactoryMethod(ScmMethodProvider method)
             return methodReturnType != null &&
                 clientProvider.SubClients.Any(subClient => methodReturnType.Equals(subClient.Type));
         }
+
+        private static bool IsPagingMethod(ScmMethodProvider method)
+        {
+            var returnType = method.Signature.ReturnType;
+            if (returnType == null || !returnType.IsFrameworkType)
+            {
+                return false;
+            }
+
+            // Check if the return type is Pageable<T> or AsyncPageable<T>
+            return returnType.FrameworkType == typeof(Pageable<>) ||
+                   returnType.FrameworkType == typeof(AsyncPageable<>);
+        }
     }
 }

eng/packages/http-client-csharp/generator/Azure.Generator/test/Visitors/DistributedTracingVisitorTests.cs

@@ -1,6 +1,8 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+using System;
+using Azure;
 using Azure.Core.Pipeline;
 using Azure.Generator.Tests.Common;
 using Azure.Generator.Tests.TestHelpers;
@@ -164,6 +166,59 @@ public void TestUpdatesProtocolMethods(bool isProtocolMethod)
             Assert.AreEqual(Helpers.GetExpectedFromFile(isProtocolMethod.ToString()), result);
         }
 
+        [TestCase(true, ScmMethodKind.Protocol)]
+        [TestCase(false, ScmMethodKind.Protocol)]
+        [TestCase(true, ScmMethodKind.Convenience)]
+        [TestCase(false, ScmMethodKind.Convenience)]
+        public void TestSkipsInstrumentationForPagingMethods(bool isAsync, ScmMethodKind methodKind)
+        {
+            var visitor = new TestDistributedTracingVisitor();
+
+            // load the input
+            List<InputMethodParameter> parameters =
+            [
+                InputFactory.MethodParameter(
+                "context",
+                InputPrimitiveType.String)
+            ];
+            var basicOperation = InputFactory.Operation(
+                "listItems",
+                parameters: parameters);
+            var basicServiceMethod = InputFactory.BasicServiceMethod("listItems", basicOperation, parameters: parameters);
+            var inputClient = InputFactory.Client("TestClient", methods: [basicServiceMethod]);
+            MockHelpers.LoadMockGenerator(clients: () => [inputClient]);
+            // create the client provider
+            var clientProvider = AzureClientGenerator.Instance.TypeFactory.CreateClient(inputClient);
+            Assert.IsNotNull(clientProvider);
+
+            // create a paging method to test the visitor
+            var pagingReturnType = isAsync
+                ? new CSharpType(typeof(AsyncPageable<>), typeof(BinaryData))
+                : new CSharpType(typeof(Pageable<>), typeof(BinaryData));
+
+            var methodSignature = new MethodSignature(
+                isAsync ? "ListItemsAsync" : "ListItems",
+                null,
+                MethodSignatureModifiers.Public | MethodSignatureModifiers.Virtual,
+                pagingReturnType,
+                $"The pageable response returned from the service.",
+                [new ParameterProvider("context", $"The request context", AzureClientGenerator.Instance.TypeFactory.RequestContentApi.RequestContentType)]);
+            var bodyStatements = Return(New.Instance(pagingReturnType));
+            var method = new ScmMethodProvider(methodSignature, bodyStatements, clientProvider!, methodKind);
+
+            var updatedMethod = visitor.InvokeVisitMethod(method!);
+            Assert.IsNotNull(updatedMethod?.BodyStatements);
+
+            var result = updatedMethod!.BodyStatements!.ToDisplayString();
+            // Verify that the method body does NOT contain DiagnosticScope instrumentation
+            Assert.IsFalse(result.Contains("DiagnosticScope"),
+                $"Paging method should not have DiagnosticScope instrumentation. Method: {(isAsync ? "AsyncPageable" : "Pageable")}, Kind: {methodKind}");
+            Assert.IsFalse(result.Contains("scope.Start()"),
+                $"Paging method should not have scope.Start() call. Method: {(isAsync ? "AsyncPageable" : "Pageable")}, Kind: {methodKind}");
+            Assert.IsFalse(result.Contains("scope.Failed"),
+                $"Paging method should not have scope.Failed() call. Method: {(isAsync ? "AsyncPageable" : "Pageable")}, Kind: {methodKind}");
+        }
+
         private static IEnumerable<TestCaseData> TestUpdatesConstructorsTestCases
         {
             get