	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Cloud Platforms > Google Cloud Platform (GCP) > Cloud Trace

Cloud Trace

Author: Venkata Sudhakar

Google Cloud Trace is a distributed tracing system that collects latency data from your applications and displays it in the Google Cloud Console. It helps you understand how requests propagate through your distributed system and identify performance bottlenecks.

Key Features:

1. End-to-end tracing - Track requests across multiple services, databases, and APIs.

2. Latency analysis - Identify slow spans and bottlenecks in your request path.

3. Automatic instrumentation - Auto-traces for App Engine, Cloud Run, and GKE with no code changes.

4. OpenTelemetry support - Industry-standard instrumentation for custom tracing.

5. Trace comparison - Compare latency distributions across different time periods or versions.

The below example shows how to instrument a Java application with Cloud Trace using OpenTelemetry.

import io.opentelemetry.api.GlobalOpenTelemetry;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.api.trace.StatusCode;
import io.opentelemetry.api.trace.Tracer;
import io.opentelemetry.context.Scope;

public class CloudTraceExample {
    private static final Tracer tracer =
        GlobalOpenTelemetry.getTracer("my-service", "1.0.0");

public static void main(String[] args) throws Exception {
        // Create a root span for the request
        Span rootSpan = tracer.spanBuilder("process-order")
            .setAttribute("order.id", "order-789")
            .setAttribute("user.id", "user-123")
            .startSpan();

try (Scope scope = rootSpan.makeCurrent()) {
            // Child span for database call
            Span dbSpan = tracer.spanBuilder("db.query.get-order")
                .setAttribute("db.system", "postgresql")
                .setAttribute("db.statement", "SELECT * FROM orders WHERE id=?")
                .startSpan();
            try (Scope dbScope = dbSpan.makeCurrent()) {
                Thread.sleep(45); // Simulate DB query
                dbSpan.setAttribute("db.rows_returned", 1);
            } finally {
                dbSpan.end();
            }

// Child span for payment service call
            Span paymentSpan = tracer.spanBuilder("http.post.payment-service")
                .setAttribute("http.url", "https://payment-service/charge")
                .setAttribute("http.method", "POST")
                .startSpan();
            try (Scope paymentScope = paymentSpan.makeCurrent()) {
                Thread.sleep(120); // Simulate payment API call
                paymentSpan.setAttribute("http.status_code", 200);
            } finally {
                paymentSpan.end();
            }

rootSpan.setStatus(StatusCode.OK);
            System.out.println("Order processed successfully");
        } finally {
            rootSpan.end();
        }
    }
}

It gives the following output in Cloud Trace UI,

Trace: process-order
Total latency: 168ms
  |-- db.query.get-order          45ms  (26.8%)
  |-- http.post.payment-service  120ms  (71.4%)
Bottleneck: payment-service call (120ms)
Recommendation: Optimize payment API or add caching

Cloud Trace vs Cloud Profiler:

Cloud Trace - Shows the flow of a single request across multiple services (distributed tracing). Answers "where did this request spend its time across services?"

Cloud Profiler - Shows aggregate CPU/memory usage patterns across many requests within a single service. Answers "which functions in my code consume the most resources overall?"

Send your comments, suggestions or queries regarding this site to [email protected].