gcp-observability: Fixed slowness for GcpObservabilityTest.enableObservability test case

gcp-observability/src/main/java/io/grpc/gcp/observability/GcpObservability.java

@@ -146,6 +146,30 @@ public void close() {
     }
   }
 
+  /**
+   * Method to close along with sleep time explicitly.
+   *
+   * @param sleepTime sleepTime
+   */
+  protected void closeWithSleepTime(long sleepTime, TimeUnit timeUnit) {
+    synchronized (GcpObservability.class) {
+      if (instance == null) {
+        throw new IllegalStateException("GcpObservability already closed!");
+      }
+      sink.close();
+      if (config.isEnableCloudMonitoring() || config.isEnableCloudTracing()) {
+        try {
+          long sleepTimeMillis = TimeUnit.MILLISECONDS.convert(sleepTime, timeUnit);
+          Thread.sleep(sleepTimeMillis);
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+          logger.log(Level.SEVERE, "Caught exception during sleep", e);
+        }
+      }
+      instance = null;
+    }
+  }
+
   // TODO(dnvindhya): Remove <channel/server>InterceptorFactory and replace with respective
   // interceptors
   private void setProducer(

gcp-observability/src/test/java/io/grpc/gcp/observability/GcpObservabilityTest.java

@@ -49,6 +49,7 @@
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
+import java.util.concurrent.TimeUnit;
 
 @RunWith(JUnit4.class)
 public class GcpObservabilityTest {
@@ -196,9 +197,9 @@ public void run() {
           mock(InternalLoggingServerInterceptor.Factory.class);
       when(serverInterceptorFactory.create()).thenReturn(serverInterceptor);
 
-      try (GcpObservability unused =
-          GcpObservability.grpcInit(
-              sink, config, channelInterceptorFactory, serverInterceptorFactory)) {
+      try {
+        GcpObservability gcpObservability = GcpObservability.grpcInit(
+            sink, config, channelInterceptorFactory, serverInterceptorFactory);
         List<?> configurators = InternalConfiguratorRegistry.getConfigurators();
         assertThat(configurators).hasSize(1);
         ObservabilityConfigurator configurator = (ObservabilityConfigurator) configurators.get(0);
@@ -208,6 +209,13 @@ public void run() {
         assertThat(list.get(2)).isInstanceOf(ConditionalClientInterceptor.class);
         assertThat(configurator.serverInterceptors).hasSize(1);
         assertThat(configurator.tracerFactories).hasSize(2);
+        gcpObservability.closeWithSleepTime(3000, TimeUnit.MILLISECONDS);
+        try {
+          gcpObservability.close();
+          fail("Expected IllegalStateException to be thrown on second close");
+        } catch (IllegalStateException e) {
+          assertThat(e.getMessage()).isEqualTo("GcpObservability already closed!");
+        }
       } catch (Exception e) {
         fail("Encountered exception: " + e);
       }
@@ -261,4 +269,25 @@ public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(
       return next.startCall(call, headers);
     }
   }
+
+ // Test to verify the closeWithSleepTime method along with sleep time explicitly.
+  @Test
+  public void closeWithSleepTime() throws Exception {
+    long sleepTime = 1000L;
+    Sink sink = mock(Sink.class);
+    ObservabilityConfig observabilityConfig = mock(ObservabilityConfig.class);
+    when(observabilityConfig.isEnableCloudLogging()).thenReturn(false);
+    when(observabilityConfig.isEnableCloudMonitoring()).thenReturn(false);
+    when(observabilityConfig.isEnableCloudTracing()).thenReturn(false);
+    when(observabilityConfig.getSampler()).thenReturn(Samplers.neverSample());
+
+    InternalLoggingChannelInterceptor.Factory channelInterceptorFactory =
+        mock(InternalLoggingChannelInterceptor.Factory.class);
+    InternalLoggingServerInterceptor.Factory serverInterceptorFactory =
+        mock(InternalLoggingServerInterceptor.Factory.class);
+    GcpObservability gcpObservability =
+        GcpObservability.grpcInit(
+            sink, observabilityConfig, channelInterceptorFactory, serverInterceptorFactory);
+    gcpObservability.closeWithSleepTime(3000, TimeUnit.MILLISECONDS);
+  }
 }