core: exclude client and hedging cancellations from callcounters for outlier-detection

api/src/main/java/io/grpc/ClientStreamTracer.java

@@ -99,6 +99,15 @@ public void inboundTrailers(Metadata trailers) {
   public void addOptionalLabel(String key, String value) {
   }
 
+  /**
+   * The stream was cancelled from the client side before a normal response was received.
+   *
+   * @param status the cancellation status
+   * @since 1.84.0
+   */
+  public void cancelled(Status status) {
+  }
+
   /**
    * Factory class for {@link ClientStreamTracer}.
    */

binder/src/main/java/io/grpc/binder/internal/Inbound.java

@@ -268,6 +268,9 @@ private final void deliverInternal() {
 
   @GuardedBy("this")
   final void closeOnCancel(Status status) {
+    if (!isClosed() && statsTraceContext != null) {
+      statsTraceContext.clientCancelled(status);
+    }
     closeAbnormal(Status.CANCELLED, status, false);
   }
 

core/src/main/java/io/grpc/internal/AbstractClientStream.java

@@ -457,6 +457,9 @@ private void closeListener(
         Status status, RpcProgress rpcProgress, Metadata trailers) {
       if (!listenerClosed) {
         listenerClosed = true;
+        if (status.getCode() == Status.Code.CANCELLED) {
+          statsTraceCtx.clientCancelled(status);
+        }
         statsTraceCtx.streamClosed(status);
         if (getTransportTracer() != null) {
           getTransportTracer().reportStreamClosed(status.isOk());

core/src/main/java/io/grpc/internal/ForwardingClientStreamTracer.java

@@ -64,6 +64,11 @@ public void addOptionalLabel(String key, String value) {
     delegate().addOptionalLabel(key, value);
   }
 
+  @Override
+  public void cancelled(Status status) {
+    delegate().cancelled(status);
+  }
+
   @Override
   public void streamClosed(Status status) {
     delegate().streamClosed(status);

core/src/main/java/io/grpc/internal/StatsTraceContext.java

@@ -167,6 +167,19 @@ public void serverCallMethodResolved(MethodDescriptor<?, ?> method) {
     }
   }
 
+  /**
+   * See {@link ClientStreamTracer#cancelled}. For client-side only.
+   *
+   * <p>Called from abstract stream implementations.
+   */
+  public void clientCancelled(Status status) {
+    for (StreamTracer tracer : tracers) {
+      if (tracer instanceof ClientStreamTracer) {
+        ((ClientStreamTracer) tracer).cancelled(status);
+      }
+    }
+  }
+
   /**
    * See {@link StreamTracer#streamClosed}. This may be called multiple times, and only the first
    * value will be taken.

core/src/test/java/io/grpc/internal/AbstractClientStreamTest.java

@@ -39,6 +39,7 @@
 
 import io.grpc.Attributes;
 import io.grpc.CallOptions;
+import io.grpc.ClientStreamTracer;
 import io.grpc.Codec;
 import io.grpc.Deadline;
 import io.grpc.Grpc;
@@ -155,6 +156,47 @@ public void cancel(Status errorStatus) {
     verify(mockListener).closed(any(Status.class), same(PROCESSED), any(Metadata.class));
   }
 
+  @Test
+  public void cancel_notifiesStatsTraceContext() {
+    ClientStreamTracer mockTracer = mock(ClientStreamTracer.class);
+    StatsTraceContext customStatsTraceCtx = new StatsTraceContext(new StreamTracer[] {mockTracer});
+    final BaseTransportState state = new BaseTransportState(customStatsTraceCtx, transportTracer);
+    AbstractClientStream stream = new BaseAbstractClientStream(allocator, state, new BaseSink() {
+      @Override
+      public void cancel(Status errorStatus) {
+        state.transportReportStatus(errorStatus, true, new Metadata());
+      }
+    }, customStatsTraceCtx, transportTracer);
+    stream.start(mockListener);
+
+    Status cancelStatus = Status.CANCELLED.withDescription("Cancelled by test");
+    stream.cancel(cancelStatus);
+
+    verify(mockTracer).cancelled(cancelStatus);
+  }
+
+  @Test
+  public void transportReportStatus_okFirst_lateCancellationDoesNotNotifyTracerCancelled() {
+    ClientStreamTracer mockTracer = mock(ClientStreamTracer.class);
+    StatsTraceContext customStatsTraceCtx = new StatsTraceContext(new StreamTracer[] {mockTracer});
+    final BaseTransportState state = new BaseTransportState(customStatsTraceCtx, transportTracer);
+    AbstractClientStream stream = new BaseAbstractClientStream(allocator, state, new BaseSink() {
+      @Override
+      public void cancel(Status errorStatus) {
+        state.transportReportStatus(errorStatus, true, new Metadata());
+      }
+    }, customStatsTraceCtx, transportTracer);
+    stream.start(mockListener);
+
+    // Report Status.OK first
+    state.transportReportStatus(Status.OK, false, new Metadata());
+
+    // Subsequent late cancellation
+    stream.cancel(Status.CANCELLED.withDescription("Late cancel"));
+
+    verify(mockTracer, never()).cancelled(any(Status.class));
+  }
+
   @Test
   public void startFailsOnNullListener() {
     AbstractClientStream stream =

core/src/test/java/io/grpc/internal/StatsTraceContextTest.java

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2026 The gRPC Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.grpc.internal;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoInteractions;
+
+import io.grpc.ClientStreamTracer;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.StreamTracer;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link StatsTraceContext}. */
+@RunWith(JUnit4.class)
+public class StatsTraceContextTest {
+
+  @Test
+  public void clientCancelled_notifiesClientStreamTracers() {
+    ClientStreamTracer clientTracer = mock(ClientStreamTracer.class);
+    ServerStreamTracer serverTracer = mock(ServerStreamTracer.class);
+
+    StatsTraceContext statsTraceCtx = new StatsTraceContext(
+        new StreamTracer[] {clientTracer, serverTracer});
+
+    Status cancelledStatus = Status.CANCELLED.withDescription("Client cancelled");
+    statsTraceCtx.clientCancelled(cancelledStatus);
+
+    verify(clientTracer).cancelled(cancelledStatus);
+    verifyNoInteractions(serverTracer);
+  }
+}

inprocess/src/main/java/io/grpc/inprocess/InProcessTransport.java

@@ -846,6 +846,7 @@ public void cancel(Status reason) {
         if (!internalCancel(serverStatus, serverStatus)) {
           return;
         }
+        statsTraceCtx.clientCancelled(reason);
         serverStream.clientCancelled(reason);
         streamClosed();
       }

inprocess/src/test/java/io/grpc/inprocess/InProcessTransportTest.java

@@ -236,6 +236,54 @@ public void basicStreamInProcess() throws Exception {
     serverStream.close(status, new Metadata());
   }
 
+  @Test
+  public void clientStream_cancel_notifiesTracerCancelled() throws Exception {
+    server = newServer(Arrays.asList(serverStreamTracerFactory));
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener =
+        serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    io.grpc.ClientStreamTracer mockTracer = org.mockito.Mockito.mock(io.grpc.ClientStreamTracer.class);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), CallOptions.DEFAULT,
+        new io.grpc.ClientStreamTracer[] {mockTracer});
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+
+    Status cancelStatus = Status.CANCELLED.withDescription("Client cancelled");
+    clientStream.cancel(cancelStatus);
+
+    org.mockito.Mockito.verify(mockTracer).cancelled(cancelStatus);
+  }
+
+  @Test
+  public void clientStream_cancelAfterServerClose_doesNotNotifyTracerCancelled() throws Exception {
+    server = newServer(Arrays.asList(serverStreamTracerFactory));
+    client = newClientTransport(server);
+    startTransport(client, mockClientTransportListener);
+    MockServerTransportListener serverTransportListener =
+        serverListener.takeListenerOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    serverTransport = serverTransportListener.transport;
+
+    io.grpc.ClientStreamTracer mockTracer = org.mockito.Mockito.mock(io.grpc.ClientStreamTracer.class);
+    ClientStream clientStream = client.newStream(
+        methodDescriptor, new Metadata(), CallOptions.DEFAULT,
+        new io.grpc.ClientStreamTracer[] {mockTracer});
+    ClientStreamListenerBase clientStreamListener = new ClientStreamListenerBase();
+    clientStream.start(clientStreamListener);
+    StreamCreation serverStreamCreation =
+        serverTransportListener.takeStreamOrFail(TIMEOUT_MS, TimeUnit.MILLISECONDS);
+    ServerStream serverStream = serverStreamCreation.stream;
+
+    serverStream.close(Status.OK, new Metadata());
+    clientStream.cancel(Status.CANCELLED.withDescription("Late cancellation"));
+
+    org.mockito.Mockito.verify(mockTracer, org.mockito.Mockito.never())
+        .cancelled(org.mockito.Mockito.any(Status.class));
+  }
+
   private void assertAssumedMessageSize(
       TestStreamTracer streamTracerSender, TestStreamTracer streamTracerReceiver) {
     if (isEnabledSupportTracingMessageSizes()) {

util/src/main/java/io/grpc/util/ForwardingClientStreamTracer.java

@@ -63,6 +63,11 @@ public void addOptionalLabel(String key, String value) {
     delegate().addOptionalLabel(key, value);
   }
 
+  @Override
+  public void cancelled(Status status) {
+    delegate().cancelled(status);
+  }
+
   @Override
   public void streamClosed(Status status) {
     delegate().streamClosed(status);

util/src/main/java/io/grpc/util/OutlierDetectionLoadBalancer.java

@@ -477,22 +477,41 @@ public ClientStreamTracer newClientStreamTracer(StreamInfo info, Metadata header
         if (delegateFactory != null) {
           ClientStreamTracer delegateTracer = delegateFactory.newClientStreamTracer(info, headers);
           return new ForwardingClientStreamTracer() {
+            private volatile boolean cancelled;
+
             @Override
             protected ClientStreamTracer delegate() {
               return delegateTracer;
             }
 
+            @Override
+            public void cancelled(Status status) {
+              cancelled = true;
+              delegate().cancelled(status);
+            }
+
             @Override
             public void streamClosed(Status status) {
-              tracker.incrementCallCount(status.isOk());
+              if (!cancelled) {
+                tracker.incrementCallCount(status.isOk());
+              }
               delegate().streamClosed(status);
             }
           };
         } else {
           return new ClientStreamTracer() {
+            private volatile boolean cancelled;
+
+            @Override
+            public void cancelled(Status status) {
+              cancelled = true;
+            }
+
             @Override
             public void streamClosed(Status status) {
-              tracker.incrementCallCount(status.isOk());
+              if (!cancelled) {
+                tracker.incrementCallCount(status.isOk());
+              }
             }
           };
         }