Clientseitige Messwerte zur Fehlerbehebung bei hoher Latenz verwenden

Memorystore for Redis bietet zwar serverseitige Echtzeitmesswerte zur Überwachung von Durchsatz, CPU-Auslastung und Speichernutzung, aber diese Daten allein erklären möglicherweise nicht, warum Ihre Clientanwendung in komplexen verteilten Systemen eine hohe Latenz aufweist.

Clientseitige Messwerte lösen dieses Problem, indem sie Transparenz über den gesamten Anfrage-Antwort-Zyklus bieten. Sie messen einen Befehl ab dem Zeitpunkt, an dem die Anwendung ihn initiiert, bis zu dem Zeitpunkt, an dem die Anwendung die Antwort verarbeitet. Durch das Erfassen dieser Datenpunkte können Sie genau feststellen, ob die Latenz von der Anwendungslogik, dem Netzwerkpfad oder dem Redis-Server verursacht wird.

Hinweis

Achten Sie darauf, dass Ihre Clientanwendung ein Dienstkonto verwendet und ihm die folgenden IAM-Rollen (Identity and Access Management) zugewiesen sind:

  • roles/cloudtrace.agent (Cloud Trace-Agent)
  • roles/monitoring.metricWriter (Monitoring-Messwert-Autor)

Weitere Informationen zum Zuweisen von Rollen finden Sie in der Kurzanleitung IAM-Rolle über die Google Cloud -Console zuweisen.

Cloud Monitoring API aktivieren

Wenn Sie clientseitige Messwerte in Monitoring exportieren möchten, müssen Sie in Ihrer Anwendung die Monitoring API aktivieren. Wenn Sie diese Messwerte in Monitoring exportieren und visualisieren, können Sie die Ursache von Engpässen ermitteln und feststellen, wo die Latenz entsteht.

So aktivieren Sie die Monitoring API:

  1. Rufen Sie in der Google Cloud Console die Seite APIs und Dienste auf.

    Zu „APIs und Dienste“

  2. Wählen Sie das Projekt aus, in dem Sie die Memorystore for Redis-Instanz erstellt haben.

  3. Klicken Sie auf APIs und Dienste aktivieren.

  4. Suchen Sie nach monitoring.

  5. Klicken Sie in den Suchergebnissen auf Cloud Monitoring API.

  6. Wenn API aktiviert angezeigt wird, ist die API bereits aktiviert. Klicken Sie andernfalls auf Aktivieren.

Cloud Trace API aktivieren

Wenn Sie verteilte Traces in Trace ansehen möchten, müssen Sie die Trace API aktivieren. Anschließend können Sie mit Trace Explorer diese Traces ansehen, Engpässe diagnostizieren und die Latenzquelle in Ihrer Anwendung isolieren.

So aktivieren Sie die Trace API:

  1. Rufen Sie in der Google Cloud Console die Seite APIs und Dienste auf.

    Zu „APIs und Dienste“

  2. Wählen Sie das Projekt aus, in dem Sie die Memorystore for Redis-Instanz erstellt haben.

  3. Klicken Sie auf APIs und Dienste aktivieren.

  4. Suchen Sie nach trace.

  5. Klicken Sie in den Suchergebnissen auf Cloud Trace API.

  6. Wenn API aktiviert angezeigt wird, ist die API bereits aktiviert. Klicken Sie andernfalls auf Aktivieren.

Telemetry API aktivieren

Wenn Sie clientseitige Messwerte mit dem OpenTelemetry Protocol (OTLP) exportieren möchten, müssen Sie die Telemetry API aktivieren. Anschließend können Sie in Ihrem Clientcode Standard-OTLP-Exporter anstelle von anbieterspezifischen Google Cloud -Exportern verwenden.

Standard-OTLP-Exporter verhindern Datenverlust. Außerdem werden Ihre Abhängigkeiten vereinfacht und Ihre Daten bleiben auf anderen Beobachtbarkeitsplattformen übertragbar. Nachdem Sie Ihren Telemetriecode einmal geschrieben haben, können Sie Ihre Daten an jede dieser Plattformen weiterleiten, indem Sie Ihre Konfiguration aktualisieren. Sie müssen Ihren Code nicht für jede Plattform mit einem neuen Satz proprietärer Bibliotheken umschreiben.

So aktivieren Sie die Telemetry API:

  1. Rufen Sie in der Google Cloud Console die Seite APIs und Dienste auf.

    Zu „APIs und Dienste“

  2. Wählen Sie das Projekt aus, in dem Sie die Memorystore for Redis-Instanz erstellt haben.

  3. Klicken Sie auf APIs und Dienste aktivieren.

  4. Suchen Sie nach telemetry.

  5. Klicken Sie in den Suchergebnissen auf Telemetry API.

  6. Wenn API aktiviert angezeigt wird, ist die API bereits aktiviert. Klicken Sie andernfalls auf Aktivieren.

Clientseitige Messwerte aktivieren

Wenn Sie clientseitige Messwerte aktivieren möchten, fügen Sie dem Code Ihrer Anwendung das OpenTelemetry-SDK und die OpenTelemetry-OTLP-Exporter hinzu, die auf die Telemetry API ausgerichtet sind. Die OpenTelemetry-Instrumentierung, die direkt in der Redis-Clientbibliothek Ihrer Anwendung ausgeführt wird, erfasst die Messwerte. Dadurch kann Ihre Anwendung Latenzdatenpunkte aufzeichnen und zur Visualisierung in Monitoring und Trace exportieren.

Zum Aktivieren clientseitiger Messwerte können Sie Go, Java, Node.js oder Python verwenden. Informationen zum Aktivieren der Messwerte für die einzelnen Sprachen finden Sie auf den folgenden Tabs.

Go

  1. Führen Sie die folgenden Befehle in Ihrem Terminal aus, um die erforderlichen OpenTelemetry- und OTLP-Exporter-Abhängigkeiten zu installieren:

      go get github.com/gomodule/redigo/redis@latest
      go get go.opentelemetry.io/otel
      go get go.opentelemetry.io/otel/sdk
      go get go.opentelemetry.io/otel/sdk/metric
      go get go.opentelemetry.io/contrib/detectors/gcp
      go get go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
      go get go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc
      go get golang.org/x/oauth2/google
      go get google.golang.org/grpc
  2. Wenn Sie die clientseitigen Messwerte aktivieren möchten, erstellen Sie eine main.go-Datei und fügen Sie ihr den folgenden Code hinzu:

    package main
    
    import (
    	"context"
    	"fmt"
    	"log"
    	"os"
    	"time"
    
    	"github.com/gomodule/redigo/redis"
    	"go.opentelemetry.io/contrib/detectors/gcp"
    	"go.opentelemetry.io/otel"
    	"go.opentelemetry.io/otel/attribute"
    	"go.opentelemetry.io/otel/codes"
    	"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc"
    	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    	"go.opentelemetry.io/otel/metric"
    	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
    	"go.opentelemetry.io/otel/sdk/resource"
    	sdktrace "go.opentelemetry.io/otel/sdk/trace"
    	"go.opentelemetry.io/otel/trace"
    	"golang.org/x/oauth2/google"
    	"google.golang.org/grpc"
    	"google.golang.org/grpc/credentials/oauth"
    )
    
    // MetricClient encapsulates the tracer and metric histograms to avoid package-level globals.
    type MetricClient struct {
    	tracer           trace.Tracer
    	rttHist          metric.Float64Histogram
    	clientBlockHist  metric.Float64Histogram
    	appBlockHist     metric.Float64Histogram
    	retryCounter     metric.Int64Counter
    	connErrorCounter metric.Int64Counter
    }
    
    // sleep hook enables lightning-fast unit tests by stubbing out real time.Sleep
    var sleep = time.Sleep
    
    // sinceMs calculates elapsed time in fractional milliseconds to avoid truncating sub-millisecond durations.
    func sinceMs(start time.Time) float64 {
    	return float64(time.Since(start).Microseconds()) / 1000.0
    }
    
    func initTelemetry(ctx context.Context) (*MetricClient, func(), error) {
    	creds, err := google.FindDefaultCredentials(ctx, "https://www.googleapis.com/auth/cloud-platform")
    	if err != nil {
    		return nil, nil, fmt.Errorf("google.FindDefaultCredentials: %w", err)
    	}
    	perRPCCreds := oauth.TokenSource{TokenSource: creds.TokenSource}
    
    	res, err := resource.New(
    		ctx,
    		resource.WithDetectors(gcp.NewDetector()),
    		resource.WithFromEnv(),
    		resource.WithAttributes(attribute.String("gcp.project_id", creds.ProjectID)),
    	)
    	if err != nil {
    		return nil, nil, fmt.Errorf("resource.New: %w", err)
    	}
    
    	traceExporter, err := otlptracegrpc.New(
    		ctx,
    		otlptracegrpc.WithEndpoint("telemetry.googleapis.com:443"),
    		otlptracegrpc.WithDialOption(grpc.WithPerRPCCredentials(perRPCCreds)),
    		otlptracegrpc.WithCompressor("gzip"),
    	)
    	if err != nil {
    		return nil, nil, fmt.Errorf("otlptracegrpc.New: %w", err)
    	}
    	tp := sdktrace.NewTracerProvider(
    		sdktrace.WithBatcher(traceExporter),
    		sdktrace.WithResource(res),
    	)
    	otel.SetTracerProvider(tp)
    	tracer := tp.Tracer("redigo.client")
    
    	metricExporter, err := otlpmetricgrpc.New(
    		ctx,
    		otlpmetricgrpc.WithEndpoint("telemetry.googleapis.com:443"),
    		otlpmetricgrpc.WithDialOption(grpc.WithPerRPCCredentials(perRPCCreds)),
    		otlpmetricgrpc.WithCompressor("gzip"),
    	)
    	if err != nil {
    		_ = tp.Shutdown(ctx)
    		return nil, nil, fmt.Errorf("otlpmetricgrpc.New: %w", err)
    	}
    	mp := sdkmetric.NewMeterProvider(
    		sdkmetric.WithResource(res),
    		sdkmetric.WithReader(sdkmetric.NewPeriodicReader(
    			metricExporter,
    			sdkmetric.WithInterval(10*time.Second),
    		)),
    	)
    	otel.SetMeterProvider(mp)
    	meter := mp.Meter("redigo.metrics")
    
    	rttHist, err := meter.Float64Histogram("redis_client_rtt", metric.WithUnit("ms"))
    	if err != nil {
    		return nil, nil, fmt.Errorf("redis_client_rtt histogram: %w", err)
    	}
    	clientBlockHist, err := meter.Float64Histogram("redis_client_blocking_latency", metric.WithUnit("ms"))
    	if err != nil {
    		return nil, nil, fmt.Errorf("redis_client_blocking_latency histogram: %w", err)
    	}
    	appBlockHist, err := meter.Float64Histogram("redis_application_blocking_latency", metric.WithUnit("ms"))
    	if err != nil {
    		return nil, nil, fmt.Errorf("redis_application_blocking_latency histogram: %w", err)
    	}
    	retryCounter, err := meter.Int64Counter("redis_retry_count")
    	if err != nil {
    		return nil, nil, fmt.Errorf("redis_retry_count counter: %w", err)
    	}
    	connErrorCounter, err := meter.Int64Counter("redis_connectivity_error_count")
    	if err != nil {
    		return nil, nil, fmt.Errorf("redis_connectivity_error_count counter: %w", err)
    	}
    
    	client := &MetricClient{
    		tracer:           tracer,
    		rttHist:          rttHist,
    		clientBlockHist:  clientBlockHist,
    		appBlockHist:     appBlockHist,
    		retryCounter:     retryCounter,
    		connErrorCounter: connErrorCounter,
    	}
    
    	initAttrs := metric.WithAttributes(attribute.String("operation", "startup"))
    	client.retryCounter.Add(ctx, 0, initAttrs)
    	client.connErrorCounter.Add(ctx, 0, initAttrs)
    
    	shutdown := func() {
    		shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    		defer cancel()
    		if err := tp.Shutdown(shutdownCtx); err != nil {
    			log.Printf("Error shutting down tracer provider: %v", err)
    		}
    		if err := mp.Shutdown(shutdownCtx); err != nil {
    			log.Printf("Error shutting down meter provider: %v", err)
    		}
    	}
    
    	return client, shutdown, nil
    }
    
    func (c *MetricClient) smartRedisCall(ctx context.Context, pool *redis.Pool, operationName string, commandName string, args ...interface{}) (interface{}, error) {
    	// Create a dedicated child span for the Redis command
    	ctx, span := c.tracer.Start(ctx, operationName)
    	span.SetAttributes(attribute.String("redis.command", commandName))
    	defer span.End()
    
    	maxRetries := 3
    	attempt := 0
    	metricOpts := metric.WithAttributes(attribute.String("operation", operationName))
    	var lastErr error
    
    	for attempt < maxRetries {
    		poolStart := time.Now()
    		// Use GetContext to respect context deadlines and cancellation
    		conn, err := pool.GetContext(ctx)
    		c.clientBlockHist.Record(ctx, sinceMs(poolStart), metricOpts)
    
    		if err != nil {
    			c.connErrorCounter.Add(ctx, 1, metricOpts)
    			c.retryCounter.Add(ctx, 1, metricOpts)
    			span.RecordError(err)
    			span.SetStatus(codes.Error, err.Error())
    			lastErr = err
    			attempt++
    			if attempt >= maxRetries {
    				break
    			}
    			sleep(time.Duration(100<<attempt) * time.Millisecond)
    			continue
    		}
    
    		// Check if the connection is dead
    		if err := conn.Err(); err != nil {
    			conn.Close()
    			c.connErrorCounter.Add(ctx, 1, metricOpts)
    			c.retryCounter.Add(ctx, 1, metricOpts)
    			span.RecordError(err)
    			span.SetStatus(codes.Error, err.Error())
    			lastErr = err
    			attempt++
    			if attempt >= maxRetries {
    				break
    			}
    			sleep(time.Duration(100<<attempt) * time.Millisecond)
    			continue
    		}
    
    		reqStart := time.Now()
    		// Redigo has no native DoContext; pass timeouts using redis.DoWithTimeout when context has a deadline
    		var reply interface{}
    		if deadline, ok := ctx.Deadline(); ok {
    			reply, err = redis.DoWithTimeout(conn, time.Until(deadline), commandName, args...)
    		} else {
    			reply, err = conn.Do(commandName, args...)
    		}
    		c.rttHist.Record(ctx, sinceMs(reqStart), metricOpts)
    		conn.Close()
    
    		if err != nil {
    			c.retryCounter.Add(ctx, 1, metricOpts)
    			span.RecordError(err)
    			span.SetStatus(codes.Error, err.Error())
    			lastErr = err
    			attempt++
    			if attempt >= maxRetries {
    				break
    			}
    			sleep(time.Duration(100<<attempt) * time.Millisecond)
    			continue
    		}
    
    		appStart := time.Now()
    		// Replace fmt.Sprintf to remove unnecessary string formatting overhead
    		sleep(2 * time.Millisecond)
    		c.appBlockHist.Record(ctx, sinceMs(appStart), metricOpts)
    
    		// Reset span status to Ok if the retry or execution eventually succeeds
    		span.SetStatus(codes.Ok, "")
    
    		return reply, nil
    	}
    	return nil, fmt.Errorf("max retries reached for %s: %w", operationName, lastErr)
    }
    
    func main() {
    	ctx := context.Background()
    	client, shutdown, err := initTelemetry(ctx)
    	if err != nil {
    		log.Printf("Failed to initialize telemetry: %v", err)
    		os.Exit(1)
    	}
    	defer shutdown()
    
    	redisHost := os.Getenv("REDISHOST")
    	redisPort := os.Getenv("REDISPORT")
    	if redisPort == "" {
    		redisPort = "6379"
    	}
    
    	pool := &redis.Pool{
    		MaxIdle:     10,
    		MaxActive:   20,
    		IdleTimeout: 240 * time.Second,
    		Wait:        true,
    		Dial: func() (redis.Conn, error) {
    			return redis.Dial("tcp", fmt.Sprintf("%s:%s", redisHost, redisPort))
    		},
    	}
    	defer pool.Close()
    
    	ctx, span := client.tracer.Start(ctx, "fetch_data_span")
    	defer span.End()
    
    	// Simple write and read operations
    	_, err = client.smartRedisCall(ctx, pool, "set_user", "SET", "user:123", "active")
    	if err != nil {
    		log.Printf("Error setting data: %v", err)
    	}
    
    	val, err := client.smartRedisCall(ctx, pool, "get_user", "GET", "user:123")
    	if err != nil {
    		log.Printf("Error fetching data: %v", err)
    	} else {
    		log.Printf("Retrieved value: %s", val)
    	}
    }
    
  3. Führen Sie Ihre Anwendung mindestens eine Minute lang aus, damit der Exporter genügend Zeit hat, die veröffentlichten Messwerte zu bündeln und an Monitoring zu senden.

Java

  1. Wenn Sie die erforderlichen OpenTelemetry- und OTLP-Exporter-Abhängigkeiten installieren möchten, fügen Sie der Datei pom.xml Ihrer Anwendung den folgenden Code hinzu:

    <dependencies>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>5.1.0</version>
        </dependency>
        <dependency>
            <groupId>io.opentelemetry</groupId>
            <artifactId>opentelemetry-api</artifactId>
            <version>1.44.1</version>
        </dependency>
        <dependency>
            <groupId>io.opentelemetry</groupId>
            <artifactId>opentelemetry-sdk</artifactId>
            <version>1.44.1</version>
        </dependency>
        <dependency>
            <groupId>io.opentelemetry</groupId>
            <artifactId>opentelemetry-exporter-otlp</artifactId>
            <version>1.44.1</version>
        </dependency>
        <dependency>
            <groupId>io.opentelemetry</groupId>
            <artifactId>opentelemetry-sdk-extension-autoconfigure-spi</artifactId>
            <version>1.44.1</version>
        </dependency>
        <dependency>
            <groupId>io.opentelemetry.contrib</groupId>
            <artifactId>opentelemetry-gcp-resources</artifactId>
            <version>1.37.0-alpha</version>
        </dependency>
        <dependency>
            <groupId>com.google.auth</groupId>
            <artifactId>google-auth-library-oauth2-http</artifactId>
            <version>1.24.0</version>
        </dependency>
    
        <!-- Testing Dependencies -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.mockito</groupId>
            <artifactId>mockito-core</artifactId>
            <version>4.11.0</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.36</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
  2. Erstellen Sie eine RedisTelemetryApp.java-Datei und fügen Sie den folgenden Code hinzu, um die clientseitigen Messwerte zu aktivieren:

    import com.google.auth.oauth2.GoogleCredentials;
    import io.opentelemetry.api.OpenTelemetry;
    import io.opentelemetry.api.common.AttributeKey;
    import io.opentelemetry.api.common.Attributes;
    import io.opentelemetry.api.metrics.DoubleHistogram;
    import io.opentelemetry.api.metrics.LongCounter;
    import io.opentelemetry.api.metrics.Meter;
    import io.opentelemetry.api.trace.Span;
    import io.opentelemetry.api.trace.Tracer;
    import io.opentelemetry.exporter.otlp.metrics.OtlpGrpcMetricExporter;
    import io.opentelemetry.exporter.otlp.trace.OtlpGrpcSpanExporter;
    import io.opentelemetry.sdk.OpenTelemetrySdk;
    import io.opentelemetry.sdk.metrics.SdkMeterProvider;
    import io.opentelemetry.sdk.metrics.export.MetricExporter;
    import io.opentelemetry.sdk.metrics.export.PeriodicMetricReader;
    import io.opentelemetry.sdk.resources.Resource;
    import io.opentelemetry.sdk.trace.SdkTracerProvider;
    import io.opentelemetry.sdk.trace.export.BatchSpanProcessor;
    import io.opentelemetry.sdk.trace.export.SpanExporter;
    import redis.clients.jedis.Jedis;
    import redis.clients.jedis.JedisPool;
    import redis.clients.jedis.JedisPoolConfig;
    import redis.clients.jedis.exceptions.JedisConnectionException;
    
    import java.io.IOException;
    import java.time.Duration;
    import java.util.Collections;
    import java.util.Map;
    import java.util.function.Function;
    import java.util.function.Supplier;
    
    /**
     * Sample application demonstrating client-side metrics and tracing for
     * Google Cloud Memorystore for Redis using OpenTelemetry OTLP exporters.
     */
    public final class RedisTelemetryApp {
        /** Attribute key for Redis operation names. */
        private static final AttributeKey<String> ATTR_OPERATION =
                AttributeKey.stringKey("operation");
    
        /** Attribute key for the detected cloud account/project ID. */
        private static final AttributeKey<String> ATTR_CLOUD_ACCOUNT_ID =
                AttributeKey.stringKey("cloud.account.id");
    
        /** Attribute key required by the Google Cloud Telemetry API. */
        private static final AttributeKey<String> ATTR_GCP_PROJECT_ID =
                AttributeKey.stringKey("gcp.project_id");
    
        /** Google Cloud Telemetry API OTLP endpoint. */
        private static final String TELEMETRY_ENDPOINT =
                "https://telemetry.googleapis.com:443";
    
        /** OAuth2 scope for Google Cloud APIs. */
        private static final String CLOUD_PLATFORM_SCOPE =
                "https://www.googleapis.com/auth/cloud-platform";
    
        /** HTTP/gRPC Authorization header name. */
        private static final String AUTHORIZATION_HEADER = "Authorization";
    
        /** Prefix for OAuth2 Bearer tokens. */
        private static final String BEARER_PREFIX = "Bearer ";
    
        /** Maximum number of Redis reconnection attempts. */
        private static final int MAX_RETRIES = 3;
    
        /** Maximum total connections for the Jedis pool. */
        private static final int POOL_MAX_TOTAL = 20;
    
        /** Interval in seconds for exporting metrics to Google Cloud. */
        private static final long METRIC_INTERVAL_SECONDS = 10L;
    
        /** Base multiplier for exponential backoff sleep (in milliseconds). */
        private static final long RETRY_BACKOFF_BASE_MS = 100L;
    
        /** Conversion factor from Nanoseconds to Milliseconds. */
        private static final double NANO_TO_MS = 1_000_000.0;
    
        /** Default Redis port. */
        private static final int DEFAULT_REDIS_PORT = 6379;
    
        /** OpenTelemetry SDK instance used for flushing telemetry on shutdown. */
        private static OpenTelemetrySdk openTelemetrySdk;
    
        /** OpenTelemetry Tracer instance for recording trace spans. */
        private static Tracer tracer;
    
        /** OpenTelemetry Histogram for Redis round-trip time. */
        private static DoubleHistogram rttHist;
    
        /** OpenTelemetry Histogram for pool blocking latency. */
        private static DoubleHistogram clientBlockHist;
    
        /** OpenTelemetry Histogram for application logic blocking latency. */
        private static DoubleHistogram appBlockHist;
    
        /** OpenTelemetry Counter for Redis reconnection retry events. */
        private static LongCounter retryCounter;
    
        /** OpenTelemetry Counter for Redis connectivity errors. */
        private static LongCounter connErrorCounter;
    
        /** Shared Jedis connection pool. */
        private static JedisPool jedisPool;
    
        /**
         * Private constructor to prevent instantiation of this utility class.
         */
        private RedisTelemetryApp() {
        }
    
        /**
         * Main entry point for running the sample application.
         *
         * @param args Command line arguments (not used).
         * @throws IOException If Google Cloud credentials cannot be loaded.
         */
        public static void main(final String[] args) throws IOException {
            setupTelemetry();
    
            final String host = System.getenv()
                    .getOrDefault("REDISHOST", "localhost");
            final int port = Integer.parseInt(System.getenv()
                    .getOrDefault("REDISPORT",
                            String.valueOf(DEFAULT_REDIS_PORT)));
    
            final JedisPoolConfig poolConfig = new JedisPoolConfig();
            poolConfig.setMaxTotal(POOL_MAX_TOTAL);
            poolConfig.setBlockWhenExhausted(true);
            jedisPool = new JedisPool(poolConfig, host, port);
    
            try {
                run();
            } finally {
                if (jedisPool != null) {
                    jedisPool.close();
                }
                if (openTelemetrySdk != null) {
                    openTelemetrySdk.close();
                }
            }
        }
    
        /**
         * Executes the core business logic of reading and writing to Redis.
         *
         * @return The string retrieved from the Redis 'get' operation.
         */
        static String run() {
            final Span span = tracer.spanBuilder("process_user_span")
                    .startSpan();
            try {
                smartRedisCall("set_user", jedis ->
                        jedis.set("user:123", "active"));
    
                final String result = smartRedisCall("get_user", jedis ->
                        jedis.get("user:123"));
                System.out.println("Retrieved: " + result);
                return result;
            } catch (Exception e) {
                span.recordException(e);
                throw e;
            } finally {
                span.end();
            }
        }
    
        /**
         * Injects mocked or no-op telemetry and pool instances for unit testing.
         *
         * @param pool              The mocked or test JedisPool instance.
         * @param testOpenTelemetry The OpenTelemetry instance to use for testing.
         */
        static void initForTest(
                final JedisPool pool,
                final OpenTelemetry testOpenTelemetry) {
            jedisPool = pool;
            tracer = testOpenTelemetry.getTracer("jedis.client");
            final Meter meter = testOpenTelemetry.getMeter("jedis.metrics");
    
            rttHist = meter.histogramBuilder("redis_client_rtt")
                    .setUnit("ms").build();
            clientBlockHist = meter
                    .histogramBuilder("redis_client_blocking_latency")
                    .setUnit("ms").build();
            appBlockHist = meter
                    .histogramBuilder("redis_application_blocking_latency")
                    .setUnit("ms").build();
            retryCounter = meter.counterBuilder("redis_retry_count").build();
            connErrorCounter = meter
                    .counterBuilder("redis_connectivity_error_count")
                    .build();
    
            retryCounter.add(0, Attributes.of(ATTR_OPERATION, "startup"));
            connErrorCounter.add(0, Attributes.of(ATTR_OPERATION, "startup"));
        }
    
        /**
         * Configures the production OpenTelemetry SDK to export Traces and Metrics
         * via OTLP to Google Cloud.
         *
         * @throws IOException If Google Application Default Credentials fail.
         */
        private static void setupTelemetry() throws IOException {
            final GoogleCredentials credentials = GoogleCredentials
                    .getApplicationDefault()
                    .createScoped(Collections.singletonList(CLOUD_PLATFORM_SCOPE));
            credentials.refreshIfExpired();
    
            final Supplier<Map<String, String>> headerSupplier = () -> {
                try {
                    synchronized (credentials) {
                        credentials.refreshIfExpired();
                        return Collections.singletonMap(
                                AUTHORIZATION_HEADER,
                                BEARER_PREFIX
                                        + credentials.getAccessToken()
                                                .getTokenValue());
                    }
                } catch (IOException e) {
                    throw new RuntimeException(
                            "Failed to refresh Google credentials", e);
                }
            };
    
            final Resource defaultResource = Resource.getDefault();
            String projectId =
                    defaultResource.getAttributes().get(ATTR_CLOUD_ACCOUNT_ID);
            if (projectId == null || projectId.isEmpty()) {
                projectId = System.getenv("GOOGLE_CLOUD_PROJECT");
            }
            final Resource resource = projectId != null && !projectId.isEmpty()
                    ? defaultResource.merge(Resource.create(
                            Attributes.of(ATTR_GCP_PROJECT_ID, projectId)))
                    : defaultResource;
    
            final SpanExporter traceExporter = OtlpGrpcSpanExporter.builder()
                    .setEndpoint(TELEMETRY_ENDPOINT)
                    .setHeaders(headerSupplier)
                    .build();
            final SdkTracerProvider tracerProvider = SdkTracerProvider.builder()
                    .setResource(resource)
                    .addSpanProcessor(
                            BatchSpanProcessor.builder(traceExporter).build())
                    .build();
    
            final MetricExporter metricExporter = OtlpGrpcMetricExporter.builder()
                    .setEndpoint(TELEMETRY_ENDPOINT)
                    .setHeaders(headerSupplier)
                    .build();
            final SdkMeterProvider meterProvider = SdkMeterProvider.builder()
                    .setResource(resource)
                    .registerMetricReader(
                            PeriodicMetricReader.builder(metricExporter)
                                    .setInterval(Duration.ofSeconds(
                                            METRIC_INTERVAL_SECONDS))
                                    .build())
                    .build();
    
            openTelemetrySdk = OpenTelemetrySdk.builder()
                    .setTracerProvider(tracerProvider)
                    .setMeterProvider(meterProvider)
                    .buildAndRegisterGlobal();
    
            tracer = openTelemetrySdk.getTracer("jedis.client");
            final Meter meter = openTelemetrySdk.getMeter("jedis.metrics");
    
            rttHist = meter.histogramBuilder("redis_client_rtt")
                    .setUnit("ms").build();
            clientBlockHist = meter
                    .histogramBuilder("redis_client_blocking_latency")
                    .setUnit("ms").build();
            appBlockHist = meter
                    .histogramBuilder("redis_application_blocking_latency")
                    .setUnit("ms").build();
            retryCounter = meter.counterBuilder("redis_retry_count").build();
            connErrorCounter = meter
                    .counterBuilder("redis_connectivity_error_count")
                    .build();
    
            retryCounter.add(0, Attributes.of(ATTR_OPERATION, "startup"));
            connErrorCounter.add(0, Attributes.of(ATTR_OPERATION, "startup"));
        }
    
        /**
         * Wraps a Redis operation with latency metrics, reconnection retry logic,
         * and trace spans.
         *
         * @param <T>           The return type of the Redis operation.
         * @param operationName The name of the operation for metric attributes.
         * @param operation     The Redis command lambda to execute safely.
         * @return The return value from the Redis command.
         */
        private static <T> T smartRedisCall(
                final String operationName,
                final Function<Jedis, T> operation) {
            int attempt = 0;
            final Attributes attrs = Attributes.of(ATTR_OPERATION,
                    operationName);
    
            final Span span = tracer.spanBuilder(operationName).startSpan();
    
            try {
                while (attempt < MAX_RETRIES) {
                    final long poolStart = System.nanoTime();
                    try (Jedis jedis = jedisPool.getResource()) {
                        clientBlockHist.record((System.nanoTime() - poolStart)
                                / NANO_TO_MS, attrs);
    
                        final long reqStart = System.nanoTime();
                        final T response = operation.apply(jedis);
                        rttHist.record((System.nanoTime() - reqStart)
                                / NANO_TO_MS, attrs);
    
                        final long appStart = System.nanoTime();
                        @SuppressWarnings("unused")
                        final String dummy = String.valueOf(response);
                        appBlockHist.record((System.nanoTime() - appStart)
                                / NANO_TO_MS, attrs);
    
                        return response;
                    } catch (JedisConnectionException e) {
                        attempt++;
                        connErrorCounter.add(1, attrs);
                        retryCounter.add(1, attrs);
                        span.recordException(e);
                        if (attempt >= MAX_RETRIES) {
                            throw e;
                        }
                        try {
                            Thread.sleep((long) (Math.pow(2, attempt)
                                    * RETRY_BACKOFF_BASE_MS));
                        } catch (InterruptedException ie) {
                            Thread.currentThread().interrupt();
                        }
                    }
                }
                return null;
            } finally {
                span.end();
            }
        }
    }
  3. Führen Sie Ihre Anwendung mindestens eine Minute lang aus, damit der Exporter genügend Zeit hat, die veröffentlichten Messwerte zu bündeln und an Monitoring zu senden.

Node.js

  1. Führen Sie die folgenden Befehle in Ihrem Terminal aus, um die erforderlichen OpenTelemetry- und OTLP-Exporter-Abhängigkeiten zu installieren:

      npm install redis@^4.6.0 \
      @grpc/grpc-js@^1.12.0 \
      google-auth-library@^9.15.0 \
      @opentelemetry/api@^1.9.0 \
      @opentelemetry/sdk-trace-node@^2.1.0 \
      @opentelemetry/sdk-trace-base@^2.1.0 \
      @opentelemetry/sdk-metrics@^2.1.0 \
      @opentelemetry/instrumentation@^0.205.0 \
      @opentelemetry/instrumentation-redis@^0.67.0 \
      @opentelemetry/exporter-trace-otlp-grpc@^0.205.0 \
      @opentelemetry/exporter-metrics-otlp-grpc@^0.205.0 \
      @opentelemetry/resources@^2.10.0 \
      @opentelemetry/resource-detector-gcp@^0.40.0
  2. Wenn Sie die clientseitigen Messwerte aktivieren möchten, erstellen Sie eine server.js-Datei und fügen Sie ihr den folgenden Code hinzu:

    
    'use strict';
    
    const grpc = require('@grpc/grpc-js');
    const {trace, metrics} = require('@opentelemetry/api');
    const {
      OTLPMetricExporter,
    } = require('@opentelemetry/exporter-metrics-otlp-grpc');
    const {OTLPTraceExporter} = require('@opentelemetry/exporter-trace-otlp-grpc');
    const {registerInstrumentations} = require('@opentelemetry/instrumentation');
    const {RedisInstrumentation} = require('@opentelemetry/instrumentation-redis');
    const {gcpDetector} = require('@opentelemetry/resource-detector-gcp');
    const {defaultResource, detectResources} = require('@opentelemetry/resources');
    const {
      MeterProvider,
      PeriodicExportingMetricReader,
    } = require('@opentelemetry/sdk-metrics');
    const {BatchSpanProcessor} = require('@opentelemetry/sdk-trace-base');
    const {NodeTracerProvider} = require('@opentelemetry/sdk-trace-node');
    const {GoogleAuth} = require('google-auth-library');
    const {performance} = require('perf_hooks');
    
    const auth = new GoogleAuth({
      scopes: 'https://www.googleapis.com/auth/cloud-platform',
    });
    
    const channelCreds = grpc.credentials.combineChannelCredentials(
      grpc.credentials.createSsl(),
      grpc.credentials.createFromGoogleCredential({
        getRequestHeaders: async url => {
          const headers = await auth.getRequestHeaders(url);
          return typeof headers.entries === 'function'
            ? Object.fromEntries(headers.entries())
            : headers;
        },
      })
    );
    
    const projectDetector = {
      detect: () => ({
        attributes: {
          'gcp.project_id': auth.getProjectId().catch(() => undefined),
        },
      }),
    };
    
    const resource = defaultResource().merge(
      detectResources({detectors: [gcpDetector, projectDetector]})
    );
    
    const traceExporter = new OTLPTraceExporter({
      url: 'https://telemetry.googleapis.com:443',
      credentials: channelCreds,
    });
    
    const provider = new NodeTracerProvider({
      resource,
      spanProcessors: [new BatchSpanProcessor(traceExporter)],
    });
    provider.register();
    
    registerInstrumentations({
      instrumentations: [new RedisInstrumentation()],
    });
    
    const redis = require('redis');
    
    const metricExporter = new OTLPMetricExporter({
      url: 'https://telemetry.googleapis.com:443',
      credentials: channelCreds,
    });
    const metricReader = new PeriodicExportingMetricReader({
      exporter: metricExporter,
      exportIntervalMillis: 10000,
    });
    const meterProvider = new MeterProvider({
      resource,
      readers: [metricReader],
    });
    metrics.setGlobalMeterProvider(meterProvider);
    
    const tracer = trace.getTracer('redis.client.node');
    const meter = metrics.getMeter('redis.metrics.node');
    
    const rttHist = meter.createHistogram('redis_client_rtt', {unit: 'ms'});
    const appBlockHist = meter.createHistogram(
      'redis_application_blocking_latency',
      {unit: 'ms'}
    );
    const retryCounter = meter.createCounter('redis_retry_count');
    const connErrorCounter = meter.createCounter('redis_connectivity_error_count');
    
    retryCounter.add(0, {operation: 'startup'});
    connErrorCounter.add(0, {operation: 'startup'});
    
    const REDISHOST = process.env.REDISHOST || 'localhost';
    const REDISPORT = process.env.REDISPORT || 6379;
    
    const client = redis.createClient({
      socket: {
        host: REDISHOST,
        port: REDISPORT,
        reconnectStrategy: retries => {
          connErrorCounter.add(1, {error: 'socket_reconnect'});
          if (retries > 5) return new Error('Max retries reached');
          return Math.min(retries * 100, 3000);
        },
      },
    });
    client.on('error', err => console.log('Redis Client Error', err));
    
    async function smartRedisCall(operationName, func, ...args) {
      let attempt = 0;
      while (attempt < 3) {
        try {
          const reqStart = performance.now();
          const response = await func(...args);
          rttHist.record(performance.now() - reqStart, {operation: operationName});
    
          const appParseStart = performance.now();
          // eslint-disable-next-line no-unused-vars
          const _ = String(response);
          appBlockHist.record(performance.now() - appParseStart, {
            operation: operationName,
          });
    
          return response;
        } catch (e) {
          attempt++;
          retryCounter.add(1, {operation: operationName});
          if (attempt >= 3) throw e;
          await new Promise(resolve =>
            setTimeout(resolve, Math.pow(2, attempt) * 100)
          );
        }
      }
    }
    
    async function main() {
      if (typeof resource.waitForAsyncAttributes === 'function') {
        await resource.waitForAsyncAttributes();
      }
      await client.connect();
    
      await tracer.startActiveSpan('process_user_span', async span => {
        try {
          // Simple write and read operations
          await smartRedisCall(
            'set_user',
            client.set.bind(client),
            'user:123',
            'active'
          );
    
          const result = await smartRedisCall(
            'get_user',
            client.get.bind(client),
            'user:123'
          );
          console.log('Retrieved:', result);
        } catch (e) {
          span.recordException(e);
        } finally {
          span.end();
        }
      });
    
      await client.quit();
      await provider.forceFlush();
      await meterProvider.forceFlush();
    }
    
    // Only run the script automatically if it is executed directly (e.g. `node server.js`)
    if (require.main === module) {
      main().catch(console.error);
    }
    
    // Export for testability
    module.exports = {
      main,
      smartRedisCall,
    };
    
  3. Führen Sie Ihre Anwendung mindestens eine Minute lang aus, damit der Exporter genügend Zeit hat, die veröffentlichten Messwerte zu bündeln und an Monitoring zu senden.

Python

  1. Führen Sie die folgenden Befehle in Ihrem Terminal aus, um die erforderlichen OpenTelemetry- und OTLP-Exporter-Abhängigkeiten zu installieren:

      pip install redis>=5.0.0 \
      opentelemetry-api==1.39.1 \
      opentelemetry-sdk==1.39.1 \
      opentelemetry-instrumentation-redis==0.60b1 \
      opentelemetry-exporter-otlp-proto-grpc \
      opentelemetry-resourcedetector-gcp \
      google-auth \
      requests \
      grpcio
  2. Wenn Sie die clientseitigen Messwerte aktivieren möchten, erstellen Sie eine main.py-Datei und fügen Sie Ihrer Anwendung den folgenden Code hinzu:

    import os
    import time
    
    import google.auth
    from google.auth.transport.grpc import AuthMetadataPlugin
    import google.auth.transport.requests
    import grpc
    from opentelemetry import metrics, trace
    from opentelemetry.exporter.otlp.proto.grpc.metric_exporter import (
        OTLPMetricExporter,
    )
    from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
        OTLPSpanExporter,
    )
    from opentelemetry.instrumentation.redis import RedisInstrumentor
    from opentelemetry.resourcedetector.gcp_resource_detector import (
        GoogleCloudResourceDetector,
    )
    from opentelemetry.sdk.metrics import MeterProvider
    from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
    from opentelemetry.sdk.resources import get_aggregated_resources, Resource
    from opentelemetry.sdk.trace import TracerProvider
    from opentelemetry.sdk.trace.export import BatchSpanProcessor
    import redis
    from redis.exceptions import ConnectionError, TimeoutError
    
    
    def init_telemetry():
        """Initializes OpenTelemetry with OTLP Exporters and returns the SDK objects."""
        credentials, project_id = google.auth.default(
            scopes=["https://www.googleapis.com/auth/cloud-platform"]
        )
        request = google.auth.transport.requests.Request()
        auth_metadata_plugin = AuthMetadataPlugin(credentials=credentials, request=request)
        channel_creds = grpc.composite_channel_credentials(
            grpc.ssl_channel_credentials(),
            grpc.metadata_call_credentials(auth_metadata_plugin),
        )
    
        resource = get_aggregated_resources([GoogleCloudResourceDetector()])
        if project_id:
            resource = resource.merge(Resource.create({"gcp.project_id": project_id}))
    
        # 1. Initialize Tracing
        tracer_provider = TracerProvider(resource=resource)
        tracer_provider.add_span_processor(
            BatchSpanProcessor(
                OTLPSpanExporter(
                    endpoint="telemetry.googleapis.com:443",
                    credentials=channel_creds,
                )
            )
        )
        trace.set_tracer_provider(tracer_provider)
        tracer = trace.get_tracer("redis.client")
    
        # 2. Initialize Metrics
        metrics_exporter = OTLPMetricExporter(
            endpoint="telemetry.googleapis.com:443",
            credentials=channel_creds,
        )
        metric_reader = PeriodicExportingMetricReader(
            metrics_exporter, export_interval_millis=10000
        )
        meter_provider = MeterProvider(resource=resource, metric_readers=[metric_reader])
        metrics.set_meter_provider(meter_provider)
        meter = metrics.get_meter("redis.metrics")
    
        # Bundle all metric handlers safely into a dictionary
        redis_metrics = {
            "rtt_hist": meter.create_histogram("redis_client_rtt", unit="ms"),
            "client_block_hist": meter.create_histogram(
                "redis_client_blocking_latency", unit="ms"
            ),
            "app_block_hist": meter.create_histogram(
                "redis_application_blocking_latency", unit="ms"
            ),
            "retry_counter": meter.create_counter("redis_retry_count"),
            "conn_error_counter": meter.create_counter("redis_connectivity_error_count"),
        }
    
        redis_metrics["retry_counter"].add(0, {"operation": "startup"})
        redis_metrics["conn_error_counter"].add(0, {"operation": "startup"})
    
        # 3. Setup Redis Auto-Instrumentation
        RedisInstrumentor().instrument()
    
        return tracer, redis_metrics, tracer_provider, meter_provider
    
    
    def init_redis_pool():
        """Initializes and returns the Redis ConnectionPool and Client."""
        redis_host = os.environ.get("REDISHOST", "localhost")
        redis_port = int(os.environ.get("REDISPORT", 6379))
    
        redis_pool = redis.ConnectionPool(
            host=redis_host,
            port=redis_port,
            max_connections=10,
            decode_responses=True,
        )
        redis_client = redis.Redis(connection_pool=redis_pool)
        return redis_pool, redis_client
    
    
    def smart_redis_call(operation_name, func, redis_pool, metrics, *args, **kwargs):
        """Executes a Redis operation with metrics and retry handling (No Globals!)."""
        max_retries = 3
        attempt = 0
    
        pool_start = time.time()
        try:
            conn = redis_pool.get_connection()
            redis_pool.release(conn)
        except Exception:
            pass
    
        if metrics and metrics.get("client_block_hist"):
            metrics["client_block_hist"].record(
                (time.time() - pool_start) * 1000, {"operation": operation_name}
            )
    
        while attempt < max_retries:
            try:
                req_start = time.time()
                response = func(*args, **kwargs)
    
                if metrics and metrics.get("rtt_hist"):
                    metrics["rtt_hist"].record(
                        (time.time() - req_start) * 1000,
                        {"operation": operation_name},
                    )
    
                app_start = time.time()
                _ = str(response)
    
                if metrics and metrics.get("app_block_hist"):
                    metrics["app_block_hist"].record(
                        (time.time() - app_start) * 1000,
                        {"operation": operation_name},
                    )
    
                return response
    
            except (ConnectionError, TimeoutError) as e:
                attempt += 1
                if metrics and metrics.get("conn_error_counter"):
                    metrics["conn_error_counter"].add(1, {"operation": operation_name})
                if metrics and metrics.get("retry_counter"):
                    metrics["retry_counter"].add(1, {"operation": operation_name})
                if attempt >= max_retries:
                    raise e
                time.sleep((2**attempt) * 0.1)
    
    
    if __name__ == "__main__":
        tracer, redis_metrics, tracer_provider, meter_provider = init_telemetry()
        redis_pool, redis_client = init_redis_pool()
    
        if tracer:
            with tracer.start_as_current_span("process_user_span"):
                try:
                    # Simple write and read operations
                    smart_redis_call(
                        "set_user",
                        redis_client.set,
                        redis_pool,
                        redis_metrics,
                        "user:123",
                        "active",
                    )
    
                    result = smart_redis_call(
                        "get_user",
                        redis_client.get,
                        redis_pool,
                        redis_metrics,
                        "user:123",
                    )
                    print(f"Retrieved: {result}")
                except Exception as e:
                    print(f"Error: {e}")
    
            tracer_provider.shutdown()
            meter_provider.shutdown()
  3. Führen Sie Ihre Anwendung mindestens eine Minute lang aus, damit der Exporter genügend Zeit hat, die veröffentlichten Messwerte zu bündeln und an Monitoring zu senden.

Messwerte in Monitoring ansehen

Nachdem Sie clientseitige Messwerte aktiviert und Ihre Anwendung mindestens eine Minute lang ausgeführt haben, damit der Exporter genügend Zeit hat, Messwerte zu bündeln und an Monitoring zu senden, können Sie Monitoring verwenden, um Ihre Messwerte zu visualisieren, sie nach Vorgang oder Instanz zu gruppieren und Aggregatoren anzuwenden, um die Leistung Ihrer Anwendung zu überwachen.

So rufen Sie Messwerte in Monitoring auf:

  1. Wechseln Sie in der Google Cloud Console zur Seite Metrics Explorer.

    Zum Metrics Explorer

  2. Wählen Sie Ihr Google Cloud Projekt aus.

  3. Klicken Sie auf Messwert auswählen.

  4. Suchen Sie nach workload.googleapis.com/redis.

  5. Wählen Sie einen clientseitigen Messwert aus. Gruppieren Sie die Daten nach Bedarf nach operation und instance und wählen Sie einen Aggregator aus. Weitere Optionen finden Sie unter Messwerte bei Verwendung von Metrics Explorer auswählen.

Verteilte Traces in Trace ansehen

Nachdem Ihre Anwendung mit dem Exportieren von Daten begonnen hat, können Sie Trace verwenden, um den gesamten Anfrage-Antwort-Zyklus Ihrer Redis-Befehle zu visualisieren. Wenn Sie sich Ihre verteilten Traces in Trace ansehen, können Sie Engpässe diagnostizieren und so die genaue Ursache der Latenz in Ihrer Anwendung schnell isolieren.

So rufen Sie verteilte Traces in Trace auf:

  1. Rufen Sie in der Google Cloud Console die Seite Trace Explorer auf.

    Trace Explorer aufrufen

  2. Wählen Sie einen aktuellen Trace aus, der durch einen Punkt im Streudiagramm dargestellt wird.

  3. Sehen Sie sich die Wasserfallansicht an, um die Latenzquelle zu isolieren. Identifizieren Sie dazu die folgenden Engpässe:

    • Gesamte Anfragedauer: Der oberste Balken (übergeordnet) zeigt die Gesamtzeit an, die Sie auf den Abschluss des Vorgangs warten müssen.

    • Netzwerk- und Serverlatenz (RTT): Die untergeordneten Balken (z. B. mit den Labels GET oder SET) zeigen die Zeit, die der Befehl für die Übertragung über das Netzwerk und die Ausführung auf dem Memorystore for Redis-Server benötigt hat.

    • Blockierung der Clientverbindung: Wenn es eine große, leere horizontale Lücke vor dem Beginn des untergeordneten Redis-Spans gibt, wartet der Anwendungsthread auf eine verfügbare TCP-Verbindung aus dem Verbindungspool.

    • Blockierung beim Parsen der Anwendung: Wenn nach dem Ende des untergeordneten Redis-Spans eine große, leere horizontale Lücke vorhanden ist, hat die Anwendung Schwierigkeiten, die zurückgegebene Nutzlast zu parsen oder zu verarbeiten. Dies geschieht häufig bei JSON-Strings mit mehreren Megabyte.

    • Wiederholungen: Wenn Sie mehrere kurze untergeordnete Spans für denselben Befehl sehen, die nacheinander innerhalb desselben übergeordneten Trace auftreten, kann es sein, dass Ihr Client Netzwerkpaketverluste hat und seine exponentielle Backoff-Wiederholungsschleife auslösen muss.

Fehlerbehebung

In diesem Abschnitt werden häufige Leistungsprobleme aufgeführt, die Sie mithilfe von clientseitigen Messwerten identifizieren können. Außerdem werden die Ursachen erläutert und es wird beschrieben, wie Sie die Probleme beheben können.

Problem Ursache Fehlerbehebung

In Ihrer Anwendung tritt ein plötzlicher Latenzanstieg auf, aber Memorystore for Redis scheint völlig fehlerfrei zu sein.

  • workload.googleapis.com/
    redis_client_blocking_latency
    (clientseitiger Messwert): Spitzenwert
  • workload.googleapis.com/redis_client_rtt (clientseitiger Messwert): niedrig oder typisch
  • redis.googleapis.com/commands/
    usec_per_call
    (Memorystore for Redis-Servermesswert): niedrig oder typisch
  • redis.googleapis.com/clients/connected (Memorystore for Redis-Servermesswert): flacht bei einer bestimmten Zahl ab
Der Engpass befindet sich ausschließlich in Ihrer Anwendung. Ihre Threads versuchen, Redis-Befehle auszuführen, aber der Verbindungspool ist vollständig erschöpft. Der hohe redis_client_blocking_latency-Wert stellt die Zeit dar, die Ihr Code auf einen verfügbaren TCP-Socket wartet, bevor der Befehl an das Netzwerk gesendet wird. Erhöhen Sie die Größenlimits für den Verbindungspool in Ihrer Redis-Clientkonfiguration (z. B. MaxActive für Go, MaxTotal für Java oder max_connections für Node.js und Python), um den höheren gleichzeitigen Traffic zu bewältigen.

Die Anfrage wird abgeschlossen, aber der Endpunkt benötigt deutlich länger als erwartet. Es gibt keine Probleme mit dem Zustand Ihres Netzwerks oder Servers.

  • workload.googleapis.com/
    redis_application_blocking_latency
    (clientseitiger Messwert): Spitzenwert
  • workload.googleapis.com/redis_client_rtt (clientseitiger Messwert): niedrig oder typisch
  • redis.googleapis.com/commands/
    usec_per_call
    (Memorystore for Redis-Servermesswert): niedrig oder typisch
  • redis.googleapis.com/stats/
    network_traffic
    (Ausgehende Byte) (Memorystore for Redis-Servermesswert): starker Anstieg
Memorystore for Redis führt den Befehl aus und das Netzwerk überträgt die Nutzlast schnell (niedrige RTT). Die zurückgegebene Nutzlast ist jedoch groß (z. B. ein JSON-String mit 15 MB). In Ihrer Anwendung tritt ein hoher redis_application_blocking_latency auf, da die Anwendung beim Zuweisen von Arbeitsspeicher und Deserialisieren dieses großen Strings in ein Objekt übermäßig viele Ressourcen verbraucht. Datenmodell optimieren Speichern Sie keine riesigen JSON-Blobs in einzelnen Schlüsseln. Schlüsseln Sie die Daten mithilfe von Redis-Hashes (HSET) auf und verwenden Sie HGET oder HMGET, um nur die spezifischen Felder abzurufen, die Sie benötigen.

Die Latenz Ihrer für Nutzer sichtbaren Anwendung steigt, aber Ihre Redis-Messwerte zeigen eine niedrige Serverlatenz und typische Verbindungspool-Checkouts an.

  • workload.googleapis.com/redis_retry_count (clientseitiger Messwert): Spitzen
  • workload.googleapis.com/
    redis_connectivity_error_count
    (clientseitiger Messwert): kann vorübergehende Erhöhungen aufweisen
  • workload.googleapis.com/redis_client_rtt (clientseitiger Messwert): niedrig oder typisch für erfolgreiche Anfragen
  • redis.googleapis.com/commands/
    usec_per_call
    (Memorystore for Redis-Servermesswert): niedrig oder typisch
Da redis_client_rtt nur die RTT erfolgreicher Anfragen erfasst, wird die Zeitlimitdauer eines fehlgeschlagenen Pakets nicht berücksichtigt. Wenn in Ihrer Anwendung vorübergehende Paketverluste oder TCP-Zurücksetzungen auftreten, erhöht die Wiederholungslogik des instrumentierten Clients den Wert redis_retry_count und löst die exponentielle Backoff-Schleife aus. Dadurch wird eine Wartezeit zwischen den Versuchen eingeführt (z. B. 100ms, 200ms oder 400ms). Der Nutzer erlebt eine hohe Gesamtlatenz, aber die zugrunde liegende Ursache ist ein Netzwerk-Paketverlust, der clientseitige Wartezeiten auslöst. Prüfen Sie Ihre VPC-Flusslogs auf verworfene Pakete, Bandbreitendrosselung oder Anomalien beim regionsübergreifenden Routing. Wenn Sie aggressive Zeitüberschreitungen feststellen, sollten Sie darauf achten, dass die Zeitüberschreitungen für Clientverbindungen (socket_timeout oder connect_timeout) größer als die erwartete RTT sind, um vorübergehenden Netzwerk-Jitter zu berücksichtigen.

Alles wird angehalten und alle Ebenen der Telemetriepipeline melden eine hohe Latenz.

  • workload.googleapis.com/redis_client_rtt (clientseitiger Messwert): hoch
  • redis.googleapis.com/commands/
    usec_per_call
    (Memorystore for Redis-Servermesswert): hoch
  • redis.googleapis.com/stats/
    cpu_utilization_main_thread
    (Memorystore for Redis-Servermesswert): hoch (z. B. nahe 1 s/s oder 100 %)
  • Trace-Wasserfalldiagramm: zeigt einen Befehl, der viel Zeit in Anspruch nimmt
Redis ist Single-Threaded. Wenn Sie einen Befehl mit der Zeitkomplexität O(N) ausführen, z. B. KEYS *, SMEMBERS für einen riesigen Satz oder HGETALL für einen Hash mit Millionen von Feldern, pausiert die Redis-Engine, um diese Anfrage zu erfüllen. Während dieser Befehl ausgeführt wird, werden alle anderen Anwendungsanfragen in die Warteschlange gestellt, was zu einer systemweiten Latenzspitze führt. Da Ihr benutzerdefinierter redis_client_rtt mit der Latenz des Servers (commands/usec_per_call) übereinstimmt, ist der Server, auf dem der Befehl ausgeführt wird, der Engpass.

Öffnen Sie Trace und sehen Sie sich die Redis-Befehle in den langsamen Spans an, um herauszufinden, welche Abfrage die Blockierung verursacht. Ersetzen Sie blockierende Befehle in Ihrem Code durch nicht blockierende Befehle.

Wenn Sie große Datasets schrittweise durchlaufen möchten, ohne den Serverthread zu sperren, verwenden Sie SCAN, SSCAN oder HSCAN.

Ihre Anwendung meldet eine konsistente, erhöhte Baseline-Latenz für alle Redis-Befehle, auch bei geringem Traffic.

  • workload.googleapis.com/redis_client_rtt (clientseitiger Messwert): durchgehend erhöht (P50 und P99 liegen beide bei ca. 30–100 ms+)
  • redis.googleapis.com/commands/
    usec_per_call
    (Memorystore for Redis-Servermesswert): extrem niedrig (< 1 ms)
  • workload.googleapis.com/
    redis_client_blocking_latency

    und redis_application_blocking_latency: niedrig oder normal
Der Redis-Server führt Befehle sofort aus, aber Ihre Anwendung und Ihre Instanz werden in verschiedenen Regionen bereitgestellt (z. B. us-central1 und us-east1). Jedes Netzwerkpaket muss über die physische Google Cloud-Infrastruktur zwischen diesen geografischen Rechenzentren übertragen werden. Dies führt zu einer obligatorischen, überregionalen Latenzstrafe für jeden Hin- und Rückflug. Um die Latenz zu verringern, stellen Sie Ihre Anwendung in derselben Region und Zone wie Ihre Instanz bereit. In der Google Cloud Console können Sie die Region Ihrer Anwendung und Instanz aufrufen.

Nächste Schritte