fix(tracing): execute completion callbacks in reverse LIFO order

Author: blakeli0

sdk-platform-java/gax-java/gax/src/main/java/com/google/api/gax/tracing/CompositeTracer.java

@@ -89,22 +89,22 @@ public Scope inScope() {
 
   @Override
   public void operationSucceeded() {
-    for (ApiTracer child : children) {
-      child.operationSucceeded();
+    for (int i = children.size() - 1; i >= 0; i--) {
+      children.get(i).operationSucceeded();
     }
   }
 
   @Override
   public void operationCancelled() {
-    for (ApiTracer child : children) {
-      child.operationCancelled();
+    for (int i = children.size() - 1; i >= 0; i--) {
+      children.get(i).operationCancelled();
     }
   }
 
   @Override
   public void operationFailed(Throwable error) {
-    for (ApiTracer child : children) {
-      child.operationFailed(error);
+    for (int i = children.size() - 1; i >= 0; i--) {
+      children.get(i).operationFailed(error);
     }
   }
 
@@ -132,71 +132,71 @@ public void attemptStarted(Object request, int attemptNumber) {
 
   @Override
   public void attemptSucceeded() {
-    for (ApiTracer child : children) {
-      child.attemptSucceeded();
+    for (int i = children.size() - 1; i >= 0; i--) {
+      children.get(i).attemptSucceeded();
     }
   }
 
   @Override
   public void attemptCancelled() {
-    for (ApiTracer child : children) {
-      child.attemptCancelled();
+    for (int i = children.size() - 1; i >= 0; i--) {
+      children.get(i).attemptCancelled();
     }
   }
 
   @Override
   public void attemptFailed(Throwable error, org.threeten.bp.Duration delay) {
-    for (ApiTracer child : children) {
-      child.attemptFailed(error, delay);
+    for (int i = children.size() - 1; i >= 0; i--) {
+      children.get(i).attemptFailed(error, delay);
     }
   }
 
   @Override
   public void attemptFailedDuration(Throwable error, java.time.Duration delay) {
-    for (ApiTracer child : children) {
-      child.attemptFailedDuration(error, delay);
+    for (int i = children.size() - 1; i >= 0; i--) {
+      children.get(i).attemptFailedDuration(error, delay);
     }
   }
 
   @Override
   public void attemptFailedRetriesExhausted(Throwable error) {
-    for (ApiTracer child : children) {
-      child.attemptFailedRetriesExhausted(error);
+    for (int i = children.size() - 1; i >= 0; i--) {
+      children.get(i).attemptFailedRetriesExhausted(error);
     }
   }
 
   @Override
   public void attemptPermanentFailure(Throwable error) {
-    for (ApiTracer child : children) {
-      child.attemptPermanentFailure(error);
+    for (int i = children.size() - 1; i >= 0; i--) {
+      children.get(i).attemptPermanentFailure(error);
     }
   }
 
   @Override
   public void lroStartFailed(Throwable error) {
-    for (ApiTracer child : children) {
-      child.lroStartFailed(error);
+    for (int i = children.size() - 1; i >= 0; i--) {
+      children.get(i).lroStartFailed(error);
     }
   }
 
   @Override
   public void lroStartSucceeded() {
-    for (ApiTracer child : children) {
-      child.lroStartSucceeded();
+    for (int i = children.size() - 1; i >= 0; i--) {
+      children.get(i).lroStartSucceeded();
     }
   }
 
   @Override
   public void responseReceived() {
-    for (ApiTracer child : children) {
-      child.responseReceived();
+    for (int i = children.size() - 1; i >= 0; i--) {
+      children.get(i).responseReceived();
     }
   }
 
   @Override
   public void responseHeadersReceived(Map<String, Object> headers) {
-    for (ApiTracer child : children) {
-      child.responseHeadersReceived(headers);
+    for (int i = children.size() - 1; i >= 0; i--) {
+      children.get(i).responseHeadersReceived(headers);
     }
   }
 

sdk-platform-java/gax-java/gax/src/test/java/com/google/api/gax/tracing/CompositeTracerTest.java

@@ -122,23 +122,26 @@ void testInScope_childScopeCloseThrows() {
   @Test
   void testOperationSucceeded() {
     compositeTracer.operationSucceeded();
-    verify(child1).operationSucceeded();
-    verify(child2).operationSucceeded();
+    InOrder inOrder = inOrder(child2, child1);
+    inOrder.verify(child2).operationSucceeded();
+    inOrder.verify(child1).operationSucceeded();
   }
 
   @Test
   void testOperationCancelled() {
     compositeTracer.operationCancelled();
-    verify(child1).operationCancelled();
-    verify(child2).operationCancelled();
+    InOrder inOrder = inOrder(child2, child1);
+    inOrder.verify(child2).operationCancelled();
+    inOrder.verify(child1).operationCancelled();
   }
 
   @Test
   void testOperationFailed() {
     Throwable error = new RuntimeException("test error");
     compositeTracer.operationFailed(error);
-    verify(child1).operationFailed(error);
-    verify(child2).operationFailed(error);
+    InOrder inOrder = inOrder(child2, child1);
+    inOrder.verify(child2).operationFailed(error);
+    inOrder.verify(child1).operationFailed(error);
   }
 
   @Test
@@ -168,15 +171,17 @@ void testAttemptStarted() {
   @Test
   void testAttemptSucceeded() {
     compositeTracer.attemptSucceeded();
-    verify(child1).attemptSucceeded();
-    verify(child2).attemptSucceeded();
+    InOrder inOrder = inOrder(child2, child1);
+    inOrder.verify(child2).attemptSucceeded();
+    inOrder.verify(child1).attemptSucceeded();
   }
 
   @Test
   void testAttemptCancelled() {
     compositeTracer.attemptCancelled();
-    verify(child1).attemptCancelled();
-    verify(child2).attemptCancelled();
+    InOrder inOrder = inOrder(child2, child1);
+    inOrder.verify(child2).attemptCancelled();
+    inOrder.verify(child1).attemptCancelled();
   }
 
   @Test
@@ -185,63 +190,71 @@ void testAttemptFailedDeprecated() {
     Throwable error = new RuntimeException("test error");
     org.threeten.bp.Duration delay = org.threeten.bp.Duration.ofSeconds(1);
     compositeTracer.attemptFailed(error, delay);
-    verify(child1).attemptFailed(error, delay);
-    verify(child2).attemptFailed(error, delay);
+    InOrder inOrder = inOrder(child2, child1);
+    inOrder.verify(child2).attemptFailed(error, delay);
+    inOrder.verify(child1).attemptFailed(error, delay);
   }
 
   @Test
   void testAttemptFailedDuration() {
     Throwable error = new RuntimeException("test error");
     java.time.Duration delay = java.time.Duration.ofSeconds(1);
     compositeTracer.attemptFailedDuration(error, delay);
-    verify(child1).attemptFailedDuration(error, delay);
-    verify(child2).attemptFailedDuration(error, delay);
+    InOrder inOrder = inOrder(child2, child1);
+    inOrder.verify(child2).attemptFailedDuration(error, delay);
+    inOrder.verify(child1).attemptFailedDuration(error, delay);
   }
 
   @Test
   void testAttemptFailedRetriesExhausted() {
     Throwable error = new RuntimeException("test error");
     compositeTracer.attemptFailedRetriesExhausted(error);
-    verify(child1).attemptFailedRetriesExhausted(error);
-    verify(child2).attemptFailedRetriesExhausted(error);
+    InOrder inOrder = inOrder(child2, child1);
+    inOrder.verify(child2).attemptFailedRetriesExhausted(error);
+    inOrder.verify(child1).attemptFailedRetriesExhausted(error);
   }
 
   @Test
   void testAttemptPermanentFailure() {
     Throwable error = new RuntimeException("test error");
     compositeTracer.attemptPermanentFailure(error);
-    verify(child1).attemptPermanentFailure(error);
-    verify(child2).attemptPermanentFailure(error);
+    InOrder inOrder = inOrder(child2, child1);
+    inOrder.verify(child2).attemptPermanentFailure(error);
+    inOrder.verify(child1).attemptPermanentFailure(error);
   }
 
   @Test
   void testLroStartFailed() {
     Throwable error = new RuntimeException("test error");
     compositeTracer.lroStartFailed(error);
-    verify(child1).lroStartFailed(error);
-    verify(child2).lroStartFailed(error);
+    InOrder inOrder = inOrder(child2, child1);
+    inOrder.verify(child2).lroStartFailed(error);
+    inOrder.verify(child1).lroStartFailed(error);
   }
 
   @Test
   void testLroStartSucceeded() {
     compositeTracer.lroStartSucceeded();
-    verify(child1).lroStartSucceeded();
-    verify(child2).lroStartSucceeded();
+    InOrder inOrder = inOrder(child2, child1);
+    inOrder.verify(child2).lroStartSucceeded();
+    inOrder.verify(child1).lroStartSucceeded();
   }
 
   @Test
   void testResponseReceived() {
     compositeTracer.responseReceived();
-    verify(child1).responseReceived();
-    verify(child2).responseReceived();
+    InOrder inOrder = inOrder(child2, child1);
+    inOrder.verify(child2).responseReceived();
+    inOrder.verify(child1).responseReceived();
   }
 
   @Test
   void testResponseHeadersReceived() {
     Map<String, Object> headers = ImmutableMap.<String, Object>of("testHeader", "testValue");
     compositeTracer.responseHeadersReceived(headers);
-    verify(child1).responseHeadersReceived(headers);
-    verify(child2).responseHeadersReceived(headers);
+    InOrder inOrder = inOrder(child2, child1);
+    inOrder.verify(child2).responseHeadersReceived(headers);
+    inOrder.verify(child1).responseHeadersReceived(headers);
   }
 
   @Test