diff --git a/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/Retrying.java b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/Retrying.java index a3b48b90ac19..00d01d7511b3 100644 --- a/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/Retrying.java +++ b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/Retrying.java @@ -119,8 +119,7 @@ public Model run( Callable c, Decoder d, @Nullable StorageMetricsContext metricsContext) { - try (Scope ignore = - metricsContext != null ? metricsContext.getOtelContext().makeCurrent() : null) { + try (Scope ignore = metricsContext != null ? metricsContext.makeCurrent() : null) { if (metricsContext != null) { metricsContext.incrementAttempts(); } @@ -240,8 +239,7 @@ public Model run( Callable c, Decoder d, @Nullable StorageMetricsContext metricsContext) { - try (Scope ignore = - metricsContext != null ? metricsContext.getOtelContext().makeCurrent() : null) { + try (Scope ignore = metricsContext != null ? metricsContext.makeCurrent() : null) { RetryContext ctx = decorator.apply( RetryContext.of( diff --git a/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/StorageHttpMetricsInterceptor.java b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/StorageHttpMetricsInterceptor.java index 39d682c86dca..49d8891c4fd8 100644 --- a/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/StorageHttpMetricsInterceptor.java +++ b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/StorageHttpMetricsInterceptor.java @@ -26,9 +26,11 @@ import com.google.api.client.http.HttpResponseInterceptor; import com.google.api.client.http.HttpUnsuccessfulResponseHandler; import com.google.api.core.ApiClock; +import com.google.common.collect.ImmutableMap; import com.google.common.collect.ImmutableSet; import io.opentelemetry.context.Context; import java.io.IOException; +import java.util.Locale; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicLong; import org.jspecify.annotations.NullMarked; @@ -44,9 +46,9 @@ * for recording when the response body is closed). End-to-end download duration including body * transfer is captured by {@code gcp.client.request.duration}. * - *

{@code gcp.storage.client.ttfb} is recorded here for media download requests across all HTTP - * response status codes when response headers arrive (HTTP unary and upload TTFB are tracked for a - * follow-up). + *

{@code gcp.storage.client.ttfb} is recorded here across all HTTP operations and response + * status codes when response headers arrive, resolving {@code gcp.storage.operation} from {@link + * StorageMetricsContext#current()} when active or falling back to route-based resolution. */ @NullMarked final class StorageHttpMetricsInterceptor implements HttpRequestInitializer { @@ -54,6 +56,58 @@ final class StorageHttpMetricsInterceptor implements HttpRequestInitializer { private static final ImmutableSet OBJECT_SUB_RESOURCES = ImmutableSet.of("acl", "compose", "restore"); + private static final ImmutableMap ROUTE_OPERATIONS = + ImmutableMap.builder() + .put("POST /batch/storage/v1", "Batch") + .put("POST /storage/v1/b", "CreateBucket") + .put("GET /storage/v1/b", "ListBuckets") + .put("GET /storage/v1/b/{bucket}", "GetBucket") + .put("PATCH /storage/v1/b/{bucket}", "UpdateBucket") + .put("DELETE /storage/v1/b/{bucket}", "DeleteBucket") + .put("POST /storage/v1/b/{bucket}/lockRetentionPolicy", "LockBucketRetentionPolicy") + .put("GET /storage/v1/b/{bucket}/iam", "GetIamPolicy") + .put("PUT /storage/v1/b/{bucket}/iam", "SetIamPolicy") + .put("GET /storage/v1/b/{bucket}/iam/testPermissions", "TestIamPermissions") + .put("POST /storage/v1/b/{bucket}/acl", "CreateBucketACL") + .put("GET /storage/v1/b/{bucket}/acl", "ListBucketACLs") + .put("GET /storage/v1/b/{bucket}/acl/{entity}", "GetBucketACL") + .put("PATCH /storage/v1/b/{bucket}/acl/{entity}", "UpdateBucketACL") + .put("DELETE /storage/v1/b/{bucket}/acl/{entity}", "DeleteBucketACL") + .put("POST /storage/v1/b/{bucket}/defaultObjectAcl", "CreateDefaultObjectACL") + .put("GET /storage/v1/b/{bucket}/defaultObjectAcl", "ListDefaultObjectACLs") + .put("GET /storage/v1/b/{bucket}/defaultObjectAcl/{entity}", "GetDefaultObjectACL") + .put("PATCH /storage/v1/b/{bucket}/defaultObjectAcl/{entity}", "UpdateDefaultObjectACL") + .put("DELETE /storage/v1/b/{bucket}/defaultObjectAcl/{entity}", "DeleteDefaultObjectACL") + .put("POST /storage/v1/b/{bucket}/notificationConfigs", "CreateNotification") + .put("GET /storage/v1/b/{bucket}/notificationConfigs", "ListNotifications") + .put("GET /storage/v1/b/{bucket}/notificationConfigs/{notification}", "GetNotification") + .put( + "DELETE /storage/v1/b/{bucket}/notificationConfigs/{notification}", + "DeleteNotification") + .put("POST /storage/v1/b/{bucket}/o", "WriteObject") + .put("GET /storage/v1/b/{bucket}/o", "ListObjects") + .put("GET /storage/v1/b/{bucket}/o/{object}", "GetObject") + .put("PATCH /storage/v1/b/{bucket}/o/{object}", "UpdateObject") + .put("DELETE /storage/v1/b/{bucket}/o/{object}", "DeleteObject") + .put("POST /storage/v1/b/{bucket}/o/{object}/compose", "ComposeObject") + .put("POST /storage/v1/b/{bucket}/o/{object}/restore", "RestoreObject") + .put( + "POST /storage/v1/b/{bucket}/o/{object}/rewriteTo/b/{bucket}/o/{object}", + "RewriteObject") + .put("POST /storage/v1/b/{bucket}/o/{object}/moveTo/o/{object}", "MoveObject") + .put("POST /storage/v1/b/{bucket}/o/{object}/acl", "CreateObjectACL") + .put("GET /storage/v1/b/{bucket}/o/{object}/acl", "ListObjectACLs") + .put("GET /storage/v1/b/{bucket}/o/{object}/acl/{entity}", "GetObjectACL") + .put("PATCH /storage/v1/b/{bucket}/o/{object}/acl/{entity}", "UpdateObjectACL") + .put("DELETE /storage/v1/b/{bucket}/o/{object}/acl/{entity}", "DeleteObjectACL") + .put("POST /storage/v1/projects/{project}/hmacKeys", "CreateHMACKey") + .put("GET /storage/v1/projects/{project}/hmacKeys", "ListHMACKeys") + .put("GET /storage/v1/projects/{project}/hmacKeys/{access_id}", "GetHMACKey") + .put("PUT /storage/v1/projects/{project}/hmacKeys/{access_id}", "UpdateHMACKey") + .put("DELETE /storage/v1/projects/{project}/hmacKeys/{access_id}", "DeleteHMACKey") + .put("GET /storage/v1/projects/{project}/serviceAccount", "GetServiceAccount") + .build(); + @Nullable private final HttpRequestInitializer delegate; private final StorageClientMetrics metrics; private final ApiClock clock; @@ -119,11 +173,12 @@ public void initialize(HttpRequest request) throws IOException { request.setIOExceptionHandler( (req, supportsRetry) -> { if (recorded.compareAndSet(false, true)) { + double durationSeconds = (clock.nanoTime() - startTimeNanos.get()) / 1_000_000_000.0; recordDuration( req, - startTimeNanos.get(), - clock.nanoTime(), + durationSeconds, 0L, + extractUrlTemplate(req.getUrl()), StorageErrorTypeMapper.STATUS_CONNECTION_ERROR); } return existingIoHandler != null @@ -132,36 +187,42 @@ public void initialize(HttpRequest request) throws IOException { } private void recordResponse(HttpRequest request, long startNanos, long endNanos, int statusCode) { + double durationSeconds = (endNanos - startNanos) / 1_000_000_000.0; + String urlTemplate = extractUrlTemplate(request.getUrl()); String errorType = statusCode >= 400 ? StorageErrorTypeMapper.mapHttpResponseCode(statusCode) : StorageErrorTypeMapper.STATUS_OK; - recordDuration(request, startNanos, endNanos, statusCode, errorType); - // Evaluate isMediaDownloadRequest(request) at response time rather than in - // initialize(HttpRequest), because callers such as MediaHttpDownloader may append - // query parameters (e.g. alt=media) to request.getUrl() after buildGetRequest(). - if (isMediaDownloadRequest(request)) { - metrics.recordTtfb( - Context.current(), - "ReadObject", - (endNanos - startNanos) / 1_000_000_000.0, - StorageClientMetrics.NETWORK_PATH_CLOUDPATH); - } + recordDuration(request, durationSeconds, statusCode, urlTemplate, errorType); + // Evaluate request URL and query parameters at response time rather than in + // initialize(HttpRequest), because callers such as MediaHttpDownloader or MediaHttpUploader + // may append query parameters (e.g. alt=media, uploadType) after buildRequest(). + StorageMetricsContext ctx = StorageMetricsContext.current(); + Context otelContext = ctx != null ? ctx.getOtelContext() : Context.current(); + metrics.recordTtfb( + otelContext, + resolveOperationName(request, urlTemplate), + durationSeconds, + StorageClientMetrics.NETWORK_PATH_CLOUDPATH); } private void recordDuration( - HttpRequest request, long startNanos, long endNanos, long statusCode, String errorType) { - double durationSeconds = (endNanos - startNanos) / 1_000_000_000.0; + HttpRequest request, + double durationSeconds, + long statusCode, + String urlTemplate, + String errorType) { metrics.recordHttpRequestDuration( - durationSeconds, - request.getRequestMethod(), - statusCode, - extractUrlTemplate(request.getUrl()), - errorType); + durationSeconds, request.getRequestMethod(), statusCode, urlTemplate, errorType); + } + + static String resolveOperationName(HttpRequest request, String urlTemplate) { + StorageMetricsContext ctx = StorageMetricsContext.current(); + return ctx != null ? ctx.getOperationName() : defaultOperationName(request, urlTemplate); } static boolean isMediaDownloadRequest(HttpRequest request) { - if (!"GET".equalsIgnoreCase(request.getRequestMethod())) { + if (!"GET".equalsIgnoreCase(effectiveMethod(request))) { return false; } GenericUrl url = request.getUrl(); @@ -170,6 +231,18 @@ static boolean isMediaDownloadRequest(HttpRequest request) { || "media".equals(url.getFirst("alt")); } + static boolean isMediaUploadRequest(HttpRequest request) { + String method = effectiveMethod(request); + if (!"POST".equalsIgnoreCase(method) && !"PUT".equalsIgnoreCase(method)) { + return false; + } + GenericUrl url = request.getUrl(); + String path = url.getRawPath(); + return (path != null && path.startsWith("/upload/storage/v1/")) + || url.getFirst("uploadType") != null + || url.getFirst("upload_id") != null; + } + static String extractUrlTemplate(GenericUrl url) { String path = url.getRawPath(); if (path == null || path.isEmpty()) { @@ -204,6 +277,23 @@ static String extractUrlTemplate(GenericUrl url) { return parts.length == 1 ? "/{bucket}" : "/{bucket}/{object}"; } + private static String defaultOperationName(HttpRequest request, String urlTemplate) { + if (isMediaDownloadRequest(request)) { + return "ReadObject"; + } + if (isMediaUploadRequest(request)) { + return "WriteObject"; + } + return ROUTE_OPERATIONS.getOrDefault( + effectiveMethod(request).toUpperCase(Locale.ROOT) + " " + urlTemplate, + StorageErrorTypeMapper.STATUS_UNKNOWN); + } + + private static String effectiveMethod(HttpRequest request) { + String override = request.getHeaders().getFirstHeaderStringValue("X-HTTP-Method-Override"); + return override != null ? override : request.getRequestMethod(); + } + private static String extractV1UrlTemplate(String rest) { if ("b".equals(rest)) { return "/storage/v1/b"; diff --git a/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/StorageMetricsContext.java b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/StorageMetricsContext.java index 188195d69eb5..142f75c5d846 100644 --- a/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/StorageMetricsContext.java +++ b/java-storage/google-cloud-storage/src/main/java/com/google/cloud/storage/StorageMetricsContext.java @@ -43,6 +43,7 @@ final class StorageMetricsContext { static final CallOptions.Key GRPC_CALL_OPTIONS_KEY = CallOptions.Key.create("storage-metrics-context"); + private static final ThreadLocal CURRENT = new ThreadLocal<>(); private static final long HTTP_STATUS_OK = 200L; private static final long HTTP_STATUS_UNSET = 0L; @@ -175,6 +176,27 @@ static StorageMetricsContext createForMultiStep( metrics, operationName, baseAttributes, clock, clock.nanoTime(), otelContext, false); } + static @Nullable StorageMetricsContext current() { + return CURRENT.get(); + } + + Scope makeCurrent() { + Scope otelScope = otelContext.makeCurrent(); + StorageMetricsContext prev = CURRENT.get(); + CURRENT.set(this); + return () -> { + try { + otelScope.close(); + } finally { + if (prev == null) { + CURRENT.remove(); + } else { + CURRENT.set(prev); + } + } + }; + } + boolean shouldRecordOperationOnRetrierExit() { return recordOperationOnRetrierExit; } diff --git a/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/RetryingMetricsTest.java b/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/RetryingMetricsTest.java index 670f9f1d31d9..06fce76f2973 100644 --- a/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/RetryingMetricsTest.java +++ b/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/RetryingMetricsTest.java @@ -43,10 +43,13 @@ import com.google.cloud.storage.Retrying.Retrier; import com.google.cloud.storage.Retrying.RetrierWithAlg; import com.google.cloud.storage.Retrying.RetryingDependencies; +import com.google.common.collect.ImmutableList; import io.grpc.Status; import io.grpc.StatusRuntimeException; import io.opentelemetry.api.common.AttributeKey; +import io.opentelemetry.api.common.Attributes; import io.opentelemetry.context.Context; +import io.opentelemetry.context.ContextKey; import io.opentelemetry.sdk.metrics.SdkMeterProvider; import io.opentelemetry.sdk.metrics.data.HistogramPointData; import io.opentelemetry.sdk.metrics.data.LongPointData; @@ -362,19 +365,44 @@ public void run_withCustomMetricsContext_recordsOperationOnRetriesAndErrors() { @Test public void run_withCustomMetricsContext_propagatesOtelContextScope() { - StorageMetricsContext customContext = StorageMetricsContext.create("GetObject"); - Context[] observedContext = new Context[1]; - - baseRetrier.run( - Retrying.neverRetry(), - () -> { - observedContext[0] = Context.current(); - return "ok"; - }, - Decoder.identity(), - customContext); - - assertThat(observedContext[0]).isEqualTo(customContext.getOtelContext()); + ContextKey key = ContextKey.named("retrying-scope-key"); + Context expectedOtelContext = Context.root().with(key, "expected"); + + for (Retrier retrier : ImmutableList.of(baseRetrier, Retrier.attemptOnce())) { + StorageMetricsContext customContext = + StorageMetricsContext.create("GetObject", Attributes.empty(), expectedOtelContext); + Context[] observedContext = new Context[1]; + StorageMetricsContext[] observedMetricsContext = new StorageMetricsContext[1]; + + retrier.run( + Retrying.neverRetry(), + () -> { + observedContext[0] = Context.current(); + observedMetricsContext[0] = StorageMetricsContext.current(); + return "ok"; + }, + Decoder.identity(), + customContext); + + assertThat(observedContext[0]).isSameInstanceAs(customContext.getOtelContext()); + assertThat(observedMetricsContext[0]).isSameInstanceAs(customContext); + assertThat(StorageMetricsContext.current()).isNull(); + + StorageMetricsContext[] observedOnFailure = new StorageMetricsContext[1]; + assertThrows( + StorageException.class, + () -> + retrier.run( + Retrying.neverRetry(), + () -> { + observedOnFailure[0] = StorageMetricsContext.current(); + throw new StorageException(503, "Unavailable"); + }, + Decoder.identity(), + customContext)); + assertThat(observedOnFailure[0]).isSameInstanceAs(customContext); + assertThat(StorageMetricsContext.current()).isNull(); + } } @Test diff --git a/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/StorageHttpMetricsInterceptorTest.java b/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/StorageHttpMetricsInterceptorTest.java index 5570101e51e4..0e11c6a49a0e 100644 --- a/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/StorageHttpMetricsInterceptorTest.java +++ b/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/StorageHttpMetricsInterceptorTest.java @@ -34,15 +34,25 @@ import com.google.api.client.testing.http.MockLowLevelHttpResponse; import com.google.api.core.ApiClock; import com.google.cloud.NoCredentials; +import com.google.cloud.ServiceOptions; +import com.google.cloud.WriteChannel; +import com.google.cloud.http.HttpTransportOptions; import com.google.common.collect.ImmutableList; -import com.google.common.collect.ImmutableMap; import io.opentelemetry.api.common.Attributes; +import io.opentelemetry.api.trace.Span; +import io.opentelemetry.api.trace.SpanContext; +import io.opentelemetry.api.trace.TraceFlags; +import io.opentelemetry.api.trace.TraceState; +import io.opentelemetry.context.Context; +import io.opentelemetry.context.Scope; import io.opentelemetry.sdk.metrics.SdkMeterProvider; +import io.opentelemetry.sdk.metrics.data.DoubleExemplarData; import io.opentelemetry.sdk.metrics.data.HistogramPointData; import io.opentelemetry.sdk.testing.exporter.InMemoryMetricReader; import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; import java.util.List; -import java.util.Map; import java.util.Objects; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicLong; @@ -195,15 +205,265 @@ public void isMediaDownloadRequest_cases() throws IOException { } } + @Test + public void isMediaUploadRequest_cases() throws IOException { + HttpRequestFactory factory = new MockHttpTransport().createRequestFactory(); + Object[][] cases = { + { + "POST", + "https://storage.googleapis.com/upload/storage/v1/b/my-b/o?uploadType=multipart", + true + }, + { + "POST", + "https://storage.googleapis.com/upload/storage/v1/b/my-b/o?uploadType=resumable", + true + }, + { + "PUT", + "https://storage.googleapis.com/upload/storage/v1/b/my-b/o?uploadType=resumable&upload_id=u1", + true + }, + {"POST", "https://storage.googleapis.com/my-b/my-obj?uploadType=resumable", true}, + {"PUT", "https://storage.googleapis.com/my-b/my-obj?upload_id=u1", true}, + {"POST", "https://storage.googleapis.com/storage/v1/b/my-b/o", false}, + {"GET", "https://storage.googleapis.com/upload/storage/v1/b/my-b/o", false}, + {"DELETE", "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj", false}, + }; + + for (Object[] testCase : cases) { + String method = (String) testCase[0]; + String url = (String) testCase[1]; + boolean expected = (boolean) testCase[2]; + HttpRequest request = factory.buildRequest(method, new GenericUrl(url), null); + assertWithMessage("%s %s", method, url) + .that(StorageHttpMetricsInterceptor.isMediaUploadRequest(request)) + .isEqualTo(expected); + } + } + + @Test + public void resolveOperationName_cases() throws IOException { + HttpRequestFactory factory = new MockHttpTransport().createRequestFactory(); + String[][] cases = { + {"GET", "https://storage.googleapis.com/download/storage/v1/b/my-b/o/my-obj", "ReadObject"}, + {"GET", "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj?alt=media", "ReadObject"}, + { + "POST", + "https://storage.googleapis.com/upload/storage/v1/b/my-b/o?uploadType=multipart", + "WriteObject" + }, + { + "PUT", + "https://storage.googleapis.com/upload/storage/v1/b/my-b/o?uploadType=resumable&upload_id=u1", + "WriteObject" + }, + {"PUT", "https://storage.googleapis.com/my-b/my-obj?upload_id=u1", "WriteObject"}, + {"POST", "https://storage.googleapis.com/batch/storage/v1", "Batch"}, + {"POST", "https://storage.googleapis.com/storage/v1/b", "CreateBucket"}, + {"GET", "https://storage.googleapis.com/storage/v1/b", "ListBuckets"}, + {"GET", "https://storage.googleapis.com/storage/v1/b/my-b", "GetBucket"}, + {"PATCH", "https://storage.googleapis.com/storage/v1/b/my-b", "UpdateBucket"}, + {"DELETE", "https://storage.googleapis.com/storage/v1/b/my-b", "DeleteBucket"}, + { + "POST", + "https://storage.googleapis.com/storage/v1/b/my-b/lockRetentionPolicy", + "LockBucketRetentionPolicy" + }, + {"GET", "https://storage.googleapis.com/storage/v1/b/my-b/iam", "GetIamPolicy"}, + {"PUT", "https://storage.googleapis.com/storage/v1/b/my-b/iam", "SetIamPolicy"}, + { + "GET", + "https://storage.googleapis.com/storage/v1/b/my-b/iam/testPermissions", + "TestIamPermissions" + }, + {"POST", "https://storage.googleapis.com/storage/v1/b/my-b/acl", "CreateBucketACL"}, + {"GET", "https://storage.googleapis.com/storage/v1/b/my-b/acl", "ListBucketACLs"}, + {"GET", "https://storage.googleapis.com/storage/v1/b/my-b/acl/allUsers", "GetBucketACL"}, + {"PATCH", "https://storage.googleapis.com/storage/v1/b/my-b/acl/allUsers", "UpdateBucketACL"}, + { + "DELETE", "https://storage.googleapis.com/storage/v1/b/my-b/acl/allUsers", "DeleteBucketACL" + }, + { + "POST", + "https://storage.googleapis.com/storage/v1/b/my-b/defaultObjectAcl", + "CreateDefaultObjectACL" + }, + { + "GET", + "https://storage.googleapis.com/storage/v1/b/my-b/defaultObjectAcl", + "ListDefaultObjectACLs" + }, + { + "GET", + "https://storage.googleapis.com/storage/v1/b/my-b/defaultObjectAcl/allUsers", + "GetDefaultObjectACL" + }, + { + "PATCH", + "https://storage.googleapis.com/storage/v1/b/my-b/defaultObjectAcl/allUsers", + "UpdateDefaultObjectACL" + }, + { + "DELETE", + "https://storage.googleapis.com/storage/v1/b/my-b/defaultObjectAcl/allUsers", + "DeleteDefaultObjectACL" + }, + { + "POST", + "https://storage.googleapis.com/storage/v1/b/my-b/notificationConfigs", + "CreateNotification" + }, + { + "GET", + "https://storage.googleapis.com/storage/v1/b/my-b/notificationConfigs", + "ListNotifications" + }, + { + "GET", + "https://storage.googleapis.com/storage/v1/b/my-b/notificationConfigs/n1", + "GetNotification" + }, + { + "DELETE", + "https://storage.googleapis.com/storage/v1/b/my-b/notificationConfigs/n1", + "DeleteNotification" + }, + {"POST", "https://storage.googleapis.com/storage/v1/b/my-b/o", "WriteObject"}, + {"GET", "https://storage.googleapis.com/storage/v1/b/my-b/o", "ListObjects"}, + {"GET", "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj", "GetObject"}, + {"PATCH", "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj", "UpdateObject"}, + {"DELETE", "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj", "DeleteObject"}, + { + "POST", "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj/compose", "ComposeObject" + }, + { + "POST", "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj/restore", "RestoreObject" + }, + { + "POST", + "https://storage.googleapis.com/storage/v1/b/b1/o/o1/rewriteTo/b/b2/o/o2", + "RewriteObject" + }, + {"POST", "https://storage.googleapis.com/storage/v1/b/b1/o/o1/moveTo/o/o2", "MoveObject"}, + {"POST", "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj/acl", "CreateObjectACL"}, + {"GET", "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj/acl", "ListObjectACLs"}, + { + "GET", + "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj/acl/allUsers", + "GetObjectACL" + }, + { + "PATCH", + "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj/acl/allUsers", + "UpdateObjectACL" + }, + { + "DELETE", + "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj/acl/allUsers", + "DeleteObjectACL" + }, + {"POST", "https://storage.googleapis.com/storage/v1/projects/my-p/hmacKeys", "CreateHMACKey"}, + {"GET", "https://storage.googleapis.com/storage/v1/projects/my-p/hmacKeys", "ListHMACKeys"}, + {"GET", "https://storage.googleapis.com/storage/v1/projects/my-p/hmacKeys/k1", "GetHMACKey"}, + { + "PUT", + "https://storage.googleapis.com/storage/v1/projects/my-p/hmacKeys/k1", + "UpdateHMACKey" + }, + { + "DELETE", + "https://storage.googleapis.com/storage/v1/projects/my-p/hmacKeys/k1", + "DeleteHMACKey" + }, + { + "GET", + "https://storage.googleapis.com/storage/v1/projects/my-p/serviceAccount", + "GetServiceAccount" + }, + {"POST", "https://storage.googleapis.com/my-b/my-obj?uploadType=resumable", "WriteObject"}, + {"PUT", "https://my-b.storage.googleapis.com/my-obj?upload_id=u1", "WriteObject"}, + {"GET", "https://storage.googleapis.com/my-b/my-obj?uploadId=u1", "UNKNOWN"}, + {"GET", "https://storage.googleapis.com/", "UNKNOWN"}, + }; + + for (String[] testCase : cases) { + String method = testCase[0]; + String url = testCase[1]; + String expectedOp = testCase[2]; + GenericUrl genericUrl = new GenericUrl(url); + HttpRequest request = factory.buildRequest(method, genericUrl, null); + String urlTemplate = StorageHttpMetricsInterceptor.extractUrlTemplate(genericUrl); + assertWithMessage("%s %s", method, url) + .that(StorageHttpMetricsInterceptor.resolveOperationName(request, urlTemplate)) + .isEqualTo(expectedOp); + } + + // Verify X-HTTP-Method-Override (applied by MethodOverride on NetHttpTransport for PATCH and + // >2048-char GET URLs) resolves to the logical HTTP method rather than wire POST. + String[][] overrideCases = { + {"PATCH", "https://storage.googleapis.com/storage/v1/b/my-b", "UpdateBucket"}, + {"PATCH", "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj", "UpdateObject"}, + {"GET", "https://storage.googleapis.com/storage/v1/b/my-b/o", "ListObjects"}, + {"GET", "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj?alt=media", "ReadObject"}, + }; + for (String[] testCase : overrideCases) { + String logicalMethod = testCase[0]; + String url = testCase[1]; + String expectedOp = testCase[2]; + GenericUrl genericUrl = new GenericUrl(url); + HttpRequest request = factory.buildPostRequest(genericUrl, null); + request.getHeaders().set("X-HTTP-Method-Override", logicalMethod); + String urlTemplate = StorageHttpMetricsInterceptor.extractUrlTemplate(genericUrl); + assertWithMessage("override=%s %s", logicalMethod, url) + .that(StorageHttpMetricsInterceptor.resolveOperationName(request, urlTemplate)) + .isEqualTo(expectedOp); + } + + GenericUrl bucketUrl = new GenericUrl("https://storage.googleapis.com/storage/v1/b/my-b"); + HttpRequest bucketGet = factory.buildGetRequest(bucketUrl); + String bucketTemplate = StorageHttpMetricsInterceptor.extractUrlTemplate(bucketUrl); + try (Scope ignore = StorageMetricsContext.create("UpdateBucket").makeCurrent()) { + assertThat(StorageHttpMetricsInterceptor.resolveOperationName(bucketGet, bucketTemplate)) + .isEqualTo("UpdateBucket"); + } + assertThat(StorageHttpMetricsInterceptor.resolveOperationName(bucketGet, bucketTemplate)) + .isEqualTo("GetBucket"); + } + @Test public void initialize_statusCodes_recordsDurationAndErrorType() throws IOException { - Map cases = - ImmutableMap.of( - 308, "OK", - 503, "UNAVAILABLE", - 200, "OK"); + Object[][] cases = { + { + 308, + "PUT", + "https://storage.googleapis.com/upload/storage/v1/b/my-b/o?uploadType=resumable&upload_id=u1", + "/upload/storage/v1/b/{bucket}/o", + "OK", + "WriteObject" + }, + { + 503, + "GET", + "https://storage.googleapis.com/storage/v1/b/my-b", + "/storage/v1/b/{bucket}", + "UNAVAILABLE", + "GetBucket" + }, + { + 200, + "GET", + "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj?alt=media", + "/storage/v1/b/{bucket}/o/{object}", + "OK", + "ReadObject" + }, + }; - for (int statusCode : cases.keySet()) { + for (Object[] testCase : cases) { + int statusCode = (int) testCase[0]; + String method = (String) testCase[1]; + String url = (String) testCase[2]; AtomicBoolean delegateCalled = new AtomicBoolean(false); AtomicBoolean execCalled = new AtomicBoolean(false); AtomicBoolean respCalled = new AtomicBoolean(false); @@ -220,12 +480,10 @@ public void initialize_statusCodes_recordsDurationAndErrorType() throws IOExcept HttpRequestInitializer interceptor = httpOptions.decorateWithMetrics(delegate); HttpTransport transport = createAdvancingTransport(statusCode, 250_000_000L); - String url = - statusCode == 200 - ? "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj?alt=media" - : "https://storage.googleapis.com/storage/v1/b/my-b/o/my-obj"; HttpRequest request = - transport.createRequestFactory(interceptor).buildGetRequest(new GenericUrl(url)); + transport + .createRequestFactory(interceptor) + .buildRequest(method, new GenericUrl(url), null); if (statusCode != 200) { request.setThrowExceptionOnExecuteError(false); } @@ -234,15 +492,20 @@ public void initialize_statusCodes_recordsDurationAndErrorType() throws IOExcept assertWithMessage("status=%s", statusCode).that(delegateCalled.get()).isTrue(); assertWithMessage("status=%s", statusCode).that(execCalled.get()).isTrue(); assertWithMessage("status=%s", statusCode).that(respCalled.get()).isTrue(); - if (statusCode != 200) { - assertWithMessage("status=%s", statusCode).that(ttfbPoints()).isEmpty(); - } } List points = durationPoints(); - assertThat(points).hasSize(cases.size()); - for (Map.Entry entry : cases.entrySet()) { - long statusCode = entry.getKey(); + assertThat(points).hasSize(cases.length); + List ttfb = ttfbPoints(); + assertThat(ttfb).hasSize(cases.length); + + for (Object[] testCase : cases) { + long statusCode = (int) testCase[0]; + String expectedMethod = (String) testCase[1]; + String expectedTemplate = (String) testCase[3]; + String expectedErrorType = (String) testCase[4]; + String expectedOperation = (String) testCase[5]; + HistogramPointData point = findPointByStatus(points, statusCode); assertWithMessage("status=%s", statusCode).that(point.getCount()).isEqualTo(1L); assertWithMessage("status=%s", statusCode).that(point.getSum()).isWithin(1e-6).of(0.25); @@ -255,42 +518,42 @@ public void initialize_statusCodes_recordsDurationAndErrorType() throws IOExcept assertThat(attrs.get(StorageClientMetrics.KEY_GCP_CLIENT_ARTIFACT)) .isEqualTo(StorageClientMetrics.ARTIFACT_STORAGE); assertThat(attrs.get(StorageClientMetrics.KEY_RPC_SYSTEM_NAME)).isEqualTo("http"); - assertThat(attrs.get(StorageClientMetrics.KEY_HTTP_REQUEST_METHOD)).isEqualTo("GET"); + assertThat(attrs.get(StorageClientMetrics.KEY_HTTP_REQUEST_METHOD)).isEqualTo(expectedMethod); assertThat(attrs.get(StorageClientMetrics.KEY_HTTP_RESPONSE_STATUS_CODE)) .isEqualTo(statusCode); assertThat(attrs.get(StorageClientMetrics.KEY_NETWORK_PATH)) .isEqualTo(StorageClientMetrics.NETWORK_PATH_CLOUDPATH); - assertThat(attrs.get(StorageClientMetrics.KEY_URL_TEMPLATE)) - .isEqualTo("/storage/v1/b/{bucket}/o/{object}"); + assertThat(attrs.get(StorageClientMetrics.KEY_URL_TEMPLATE)).isEqualTo(expectedTemplate); assertThat(attrs.get(StorageClientMetrics.KEY_SERVER_ADDRESS)) .isEqualTo("storage.googleapis.com"); assertWithMessage("status=%s", statusCode) .that(attrs.get(StorageClientMetrics.KEY_ERROR_TYPE)) - .isEqualTo(entry.getValue()); - } + .isEqualTo(expectedErrorType); - List ttfb = ttfbPoints(); - assertThat(ttfb).hasSize(1); - HistogramPointData ttfbPoint = ttfb.get(0); - assertThat(ttfbPoint.getCount()).isEqualTo(1L); - assertThat(ttfbPoint.getSum()).isWithin(1e-6).of(0.25); - assertThat(ttfbPoint.getAttributes()) - .isEqualTo( - Attributes.builder() - .put( - StorageClientMetrics.KEY_GCP_CLIENT_SERVICE, - StorageClientMetrics.SERVICE_STORAGE) - .put(StorageClientMetrics.KEY_GCP_CLIENT_VERSION, StorageOptions.version()) - .put( - StorageClientMetrics.KEY_GCP_CLIENT_ARTIFACT, - StorageClientMetrics.ARTIFACT_STORAGE) - .put(StorageClientMetrics.KEY_RPC_SYSTEM_NAME, "http") - .put(StorageClientMetrics.KEY_GCP_STORAGE_OPERATION, "ReadObject") - .put( - StorageClientMetrics.KEY_NETWORK_PATH, - StorageClientMetrics.NETWORK_PATH_CLOUDPATH) - .put(StorageClientMetrics.KEY_SERVER_ADDRESS, "storage.googleapis.com") - .build()); + HistogramPointData ttfbPoint = findTtfbPointByOperation(ttfb, expectedOperation); + assertWithMessage("op=%s", expectedOperation).that(ttfbPoint.getCount()).isEqualTo(1L); + assertWithMessage("op=%s", expectedOperation) + .that(ttfbPoint.getSum()) + .isWithin(1e-6) + .of(0.25); + assertThat(ttfbPoint.getAttributes()) + .isEqualTo( + Attributes.builder() + .put( + StorageClientMetrics.KEY_GCP_CLIENT_SERVICE, + StorageClientMetrics.SERVICE_STORAGE) + .put(StorageClientMetrics.KEY_GCP_CLIENT_VERSION, StorageOptions.version()) + .put( + StorageClientMetrics.KEY_GCP_CLIENT_ARTIFACT, + StorageClientMetrics.ARTIFACT_STORAGE) + .put(StorageClientMetrics.KEY_RPC_SYSTEM_NAME, "http") + .put(StorageClientMetrics.KEY_GCP_STORAGE_OPERATION, expectedOperation) + .put( + StorageClientMetrics.KEY_NETWORK_PATH, + StorageClientMetrics.NETWORK_PATH_CLOUDPATH) + .put(StorageClientMetrics.KEY_SERVER_ADDRESS, "storage.googleapis.com") + .build()); + } } @Test @@ -419,7 +682,13 @@ public LowLevelHttpResponse execute() throws IOException { assertThat(okPoint.getAttributes().get(StorageClientMetrics.KEY_ERROR_TYPE)) .isEqualTo(StorageErrorTypeMapper.STATUS_OK); - assertThat(ttfbPoints()).isEmpty(); + List ttfb = ttfbPoints(); + assertThat(ttfb).hasSize(1); + HistogramPointData ttfbPoint = ttfb.get(0); + assertThat(ttfbPoint.getCount()).isEqualTo(1L); + assertThat(ttfbPoint.getSum()).isWithin(1e-6).of(0.20); + assertThat(ttfbPoint.getAttributes().get(StorageClientMetrics.KEY_GCP_STORAGE_OPERATION)) + .isEqualTo("GetBucket"); } @Test @@ -589,7 +858,116 @@ public void onFailure(Void e, HttpHeaders responseHeaders) { assertThat(attrs.get(StorageClientMetrics.KEY_HTTP_RESPONSE_STATUS_CODE)).isEqualTo(200L); assertThat(attrs.get(StorageClientMetrics.KEY_ERROR_TYPE)) .isEqualTo(StorageErrorTypeMapper.STATUS_OK); - assertThat(ttfbPoints()).isEmpty(); + + List ttfb = ttfbPoints(); + assertThat(ttfb).hasSize(1); + HistogramPointData batchTtfb = findTtfbPointByOperation(ttfb, "Batch"); + assertThat(batchTtfb.getCount()).isEqualTo(2L); + assertThat(batchTtfb.getSum()).isWithin(1e-6).of(0.20); + } + + @Test + public void endToEnd_storageImplUnaryAndResumableWrite_recordsHttpTtfb() throws Exception { + byte[] directPayload = "hello".getBytes(StandardCharsets.UTF_8); + byte[] resumablePayload = new byte[300 * 1024]; + String uploadId = + "https://storage.googleapis.com/upload/storage/v1/b/my-b/o?uploadType=resumable&upload_id=session-1"; + String traceId = "0123456789abcdef0123456789abcdef"; + String spanId = "0123456789abcdef"; + Context tracedContext = + Context.root() + .with( + Span.wrap( + SpanContext.create( + traceId, spanId, TraceFlags.getSampled(), TraceState.getDefault()))); + + HttpTransport transport = + new MockHttpTransport() { + @Override + public LowLevelHttpRequest buildRequest(String method, String url) { + return new MockLowLevelHttpRequest(url) { + @Override + public LowLevelHttpResponse execute() { + clock.advanceNanos(100_000_000L); + MockLowLevelHttpResponse resp = new MockLowLevelHttpResponse(); + if ("GET".equals(method) && url.contains("/storage/v1/b/my-b")) { + resp.setStatusCode(200); + resp.setContentType("application/json; charset=UTF-8"); + resp.setContent("{\"name\":\"my-b\"}"); + } else if ("POST".equals(method) && url.contains("uploadType=multipart")) { + resp.setStatusCode(200); + resp.setContentType("application/json; charset=UTF-8"); + resp.setContent( + "{\"bucket\":\"my-b\",\"name\":\"direct.txt\",\"size\":\"" + + directPayload.length + + "\"}"); + } else if ("POST".equals(method) && url.contains("uploadType=resumable")) { + resp.setStatusCode(200); + resp.addHeader("Location", uploadId); + } else if ("PUT".equals(method) && url.contains("upload_id=session-1")) { + String contentRange = getFirstHeaderValue("Content-Range"); + if (contentRange != null && contentRange.endsWith("/*")) { + resp.setStatusCode(308); + resp.addHeader("Range", "bytes=0-262143"); + } else { + resp.setStatusCode(200); + resp.setContentType("application/json; charset=UTF-8"); + resp.addHeader("Content-Type", "application/json; charset=UTF-8"); + resp.setContent( + "{\"bucket\":\"my-b\",\"name\":\"resumable.txt\",\"size\":\"" + + resumablePayload.length + + "\"}"); + } + } else { + throw new AssertionError("Unexpected request: " + method + " " + url); + } + return resp; + } + }; + } + }; + + try (Storage storage = + httpOptions.toBuilder() + .setTransportOptions( + HttpTransportOptions.newBuilder().setHttpTransportFactory(() -> transport).build()) + .setRetrySettings(ServiceOptions.getNoRetrySettings()) + .build() + .getService()) { + // 1. Unmodified BucketInfo.update executes GET /storage/v1/b/my-b with "UpdateBucket" context + // and propagates the active trace exemplar through StorageMetricsContext.makeCurrent(). + try (Scope ignore = tracedContext.makeCurrent()) { + Bucket updated = storage.update(BucketInfo.of("my-b")); + assertThat(updated.getName()).isEqualTo("my-b"); + } + + // 2. Direct upload executes multipart POST + Blob created = + storage.create(BlobInfo.newBuilder("my-b", "direct.txt").build(), directPayload); + assertThat(created.getName()).isEqualTo("direct.txt"); + + // 3. Resumable upload executes open POST + 256 KiB chunk PUT (308) + final PUT (200) + try (WriteChannel writer = + storage.writer(BlobInfo.newBuilder("my-b", "resumable.txt").build())) { + writer.setChunkSize(256 * 1024); + writer.write(ByteBuffer.wrap(resumablePayload)); + } + + List ttfb = ttfbPoints(); + assertThat(ttfb).hasSize(2); + + HistogramPointData updateBucketTtfb = findTtfbPointByOperation(ttfb, "UpdateBucket"); + assertThat(updateBucketTtfb.getCount()).isEqualTo(1L); + assertThat(updateBucketTtfb.getSum()).isWithin(1e-6).of(0.10); + assertThat(updateBucketTtfb.getExemplars()).isNotEmpty(); + DoubleExemplarData exemplar = (DoubleExemplarData) updateBucketTtfb.getExemplars().get(0); + assertThat(exemplar.getSpanContext().getTraceId()).isEqualTo(traceId); + assertThat(exemplar.getSpanContext().getSpanId()).isEqualTo(spanId); + + HistogramPointData writeObjectTtfb = findTtfbPointByOperation(ttfb, "WriteObject"); + assertThat(writeObjectTtfb.getCount()).isEqualTo(4L); + assertThat(writeObjectTtfb.getSum()).isWithin(1e-6).of(0.40); + } } private List durationPoints() { @@ -620,6 +998,18 @@ private static HistogramPointData findPointByStatus( .orElseThrow(() -> new AssertionError("No point for status " + statusCode)); } + private static HistogramPointData findTtfbPointByOperation( + List points, String operationName) { + return points.stream() + .filter( + p -> + Objects.equals( + p.getAttributes().get(StorageClientMetrics.KEY_GCP_STORAGE_OPERATION), + operationName)) + .findFirst() + .orElseThrow(() -> new AssertionError("No TTFB point for operation " + operationName)); + } + private HttpTransport createAdvancingTransport(int statusCode, long advanceNanos) { return new MockHttpTransport() { @Override diff --git a/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/StorageMetricsContextTest.java b/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/StorageMetricsContextTest.java index dde1e3397412..55d348add115 100644 --- a/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/StorageMetricsContextTest.java +++ b/java-storage/google-cloud-storage/src/test/java/com/google/cloud/storage/StorageMetricsContextTest.java @@ -36,6 +36,7 @@ import com.google.api.core.ApiClock; import com.google.api.core.ApiFuture; import com.google.api.core.ApiFutures; +import com.google.api.core.NanoClock; import com.google.api.gax.grpc.GrpcCallContext; import com.google.api.gax.grpc.GrpcStatusCode; import com.google.api.gax.retrying.RetrySettings; @@ -80,6 +81,8 @@ import io.opentelemetry.api.common.AttributeKey; import io.opentelemetry.api.common.Attributes; import io.opentelemetry.context.Context; +import io.opentelemetry.context.ContextKey; +import io.opentelemetry.context.Scope; import io.opentelemetry.sdk.metrics.SdkMeterProvider; import io.opentelemetry.sdk.metrics.data.HistogramPointData; import io.opentelemetry.sdk.metrics.data.LongPointData; @@ -294,6 +297,38 @@ public void transportAttachment_grpcCallContext() { assertThat(StorageMetricsContext.from(GrpcCallContext.createDefault())).isNull(); } + @Test + public void makeCurrent_setsAndRestoresThreadLocalAndOtelContext() { + assertThat(StorageMetricsContext.current()).isNull(); + Context initialOtelContext = Context.current(); + + ContextKey key = ContextKey.named("storage-metrics-context-test"); + Context outerOtel = Context.root().with(key, "outer"); + Context innerOtel = Context.root().with(key, "inner"); + StorageMetricsContext outer = + StorageMetricsContext.create( + metrics, "GetBucket", Attributes.empty(), outerOtel, NanoClock.getDefaultClock()); + StorageMetricsContext inner = + StorageMetricsContext.create( + metrics, "UpdateBucket", Attributes.empty(), innerOtel, NanoClock.getDefaultClock()); + + try (Scope outerScope = outer.makeCurrent()) { + assertThat(StorageMetricsContext.current()).isSameInstanceAs(outer); + assertThat(Context.current()).isSameInstanceAs(outerOtel); + + try (Scope innerScope = inner.makeCurrent()) { + assertThat(StorageMetricsContext.current()).isSameInstanceAs(inner); + assertThat(Context.current()).isSameInstanceAs(innerOtel); + } + + assertThat(StorageMetricsContext.current()).isSameInstanceAs(outer); + assertThat(Context.current()).isSameInstanceAs(outerOtel); + } + + assertThat(StorageMetricsContext.current()).isNull(); + assertThat(Context.current()).isSameInstanceAs(initialOtelContext); + } + @Test public void multiStepContext_behavior() { StorageMetricsContext context1 = StorageMetricsContext.createForMultiStep("WriteObject");