Utiliser les métriques côté client pour résoudre les problèmes de latence élevée

Bien que Memorystore pour Redis fournisse des métriques côté serveur en temps réel pour surveiller le débit, l'utilisation du processeur et l'utilisation de la mémoire, ces données ne suffisent pas à expliquer pourquoi votre application cliente subit une latence élevée dans des systèmes distribués complexes.

Les métriques côté client résolvent ce problème en offrant une transparence sur l'ensemble du cycle requête-réponse. Ils mesurent une commande à partir du moment où l'application l'initie jusqu'à ce qu'elle traite la réponse. En capturant ces points de données, vous pouvez déterminer avec précision si la latence provient de la logique d'application, du chemin réseau ou du serveur Redis.

Avant de commencer

Assurez-vous que votre application cliente utilise un compte de service et que les rôles IAM (Identity and Access Management) suivants lui sont attribués :

  • roles/cloudtrace.agent (Agent Cloud Trace)
  • roles/monitoring.metricWriter (Rédacteur de métriques Monitoring)

Pour en savoir plus sur l'attribution de rôles, consultez le guide de démarrage rapide Attribuer un rôle IAM à l'aide de la console Google Cloud .

Activer l'API Cloud Monitoring.

Pour exporter des métriques côté client vers Monitoring, votre application nécessite l'activation de l'API Monitoring. L'exportation et la visualisation de ces métriques dans Monitoring vous permettent d'identifier la cause principale des goulots d'étranglement afin de déterminer l'origine de la latence.

Pour activer l'API Monitoring, procédez comme suit :

  1. Dans la console Google Cloud , accédez à la page API et services.

    Accéder à la page "API et services"

  2. Sélectionnez le projet dans lequel vous avez créé l'instance Memorystore pour Redis.

  3. Cliquez sur Activer les API et les services.

  4. Recherchez monitoring.

  5. Dans les résultats de recherche, cliquez sur API Cloud Monitoring.

  6. Si API activée s'affiche, cela signifie que l'API est déjà activée. Sinon, cliquez sur Activer.

Activer l'API Cloud Trace

Pour afficher les traces distribuées dans Trace, vous devez activer l'API Trace. Vous pouvez ensuite utiliser l'explorateur de traces pour afficher ces traces, diagnostiquer les goulots d'étranglement et isoler la source de latence dans votre application.

Pour activer l'API Trace, procédez comme suit :

  1. Dans la console Google Cloud , accédez à la page API et services.

    Accéder à la page "API et services"

  2. Sélectionnez le projet dans lequel vous avez créé l'instance Memorystore pour Redis.

  3. Cliquez sur Activer les API et les services.

  4. Recherchez trace.

  5. Dans les résultats de recherche, cliquez sur API Cloud Trace.

  6. Si API activée s'affiche, cela signifie que l'API est déjà activée. Sinon, cliquez sur Activer.

Activer l'API Telemetry

Pour exporter des métriques côté client à l'aide du protocole OpenTelemetry (OTLP), vous devez activer l'API Telemetry. Vous pouvez ensuite utiliser des exportateurs OTLP standards dans votre code client plutôt que des exportateurs Google Cloud spécifiques au fournisseur.

Les exportateurs OTLP standards évitent la perte de données. Ils simplifient également vos dépendances et garantissent que vos données restent portables sur d'autres plates-formes d'observabilité. Une fois que vous avez écrit votre code de télémétrie, vous pouvez acheminer vos données vers n'importe laquelle de ces plates-formes en mettant à jour votre configuration. Vous n'avez pas besoin de réécrire votre code avec un nouvel ensemble de bibliothèques propriétaires pour chaque plate-forme.

Pour activer l'API Telemetry, procédez comme suit :

  1. Dans la console Google Cloud , accédez à la page API et services.

    Accéder à la page "API et services"

  2. Sélectionnez le projet dans lequel vous avez créé l'instance Memorystore pour Redis.

  3. Cliquez sur Activer les API et les services.

  4. Recherchez telemetry.

  5. Dans les résultats de recherche, cliquez sur API Telemetry.

  6. Si API activée s'affiche, cela signifie que l'API est déjà activée. Sinon, cliquez sur Activer.

Activer les métriques côté client

Pour activer les métriques côté client, ajoutez le SDK OpenTelemetry et les exportateurs OTLP OpenTelemetry, qui ciblent l'API Telemetry, au code de votre application. L'instrumentation OpenTelemetry, qui s'exécute directement dans la bibliothèque cliente Redis de votre application, capture les métriques. Cela permet à votre application d'enregistrer des points de données de latence et de les exporter vers Monitoring et Trace pour les visualiser.

Pour activer les métriques côté client, vous pouvez utiliser Go, Java, Node.js ou Python. Les informations permettant d'activer les métriques pour chaque langage s'affichent dans les onglets suivants.

Go

  1. Pour installer les dépendances requises pour l'exportateur OpenTelemetry et OTLP, exécutez les commandes suivantes dans votre terminal :

      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. Pour activer les métriques côté client, créez un fichier main.go et ajoutez-y le code suivant :

    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. Exécutez votre application pendant au moins une minute pour laisser à l'exportateur le temps de regrouper et d'envoyer les métriques publiées à Monitoring.

Java

  1. Pour installer les dépendances requises pour OpenTelemetry et l'exportateur OTLP, ajoutez le code suivant au fichier pom.xml de votre application :

    <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. Pour activer les métriques côté client, créez un fichier RedisTelemetryApp.java et ajoutez-y le code suivant :

    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. Exécutez votre application pendant au moins une minute pour laisser à l'exportateur le temps de regrouper et d'envoyer les métriques publiées à Monitoring.

Node.js

  1. Pour installer les dépendances requises pour l'exportateur OpenTelemetry et OTLP, exécutez les commandes suivantes dans votre terminal :

      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. Pour activer les métriques côté client, créez un fichier server.js et ajoutez-y le code suivant :

    
    '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. Exécutez votre application pendant au moins une minute pour laisser à l'exportateur le temps de regrouper et d'envoyer les métriques publiées à Monitoring.

Python

  1. Pour installer les dépendances requises pour l'exportateur OpenTelemetry et OTLP, exécutez les commandes suivantes dans votre terminal :

      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. Pour activer les métriques côté client, créez un fichier main.py et ajoutez le code suivant à votre application :

    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. Exécutez votre application pendant au moins une minute pour laisser à l'exportateur le temps de regrouper et d'envoyer les métriques publiées à Monitoring.

Afficher les métriques dans Monitoring

Après avoir activé les métriques côté client et exécuté votre application pendant au moins une minute pour laisser à l'exportateur le temps de regrouper et d'envoyer les métriques à Monitoring, utilisez Monitoring pour visualiser vos métriques, les regrouper par opération ou par instance, et appliquer des agrégateurs pour surveiller les performances de votre application.

Pour afficher les métriques dans Monitoring, procédez comme suit :

  1. Dans la console Google Cloud , accédez à la page Explorateur de métriques.

    Accéder à l'explorateur de métriques

  2. Sélectionnez votre projet Google Cloud .

  3. Cliquez sur Sélectionner une métrique.

  4. Recherchez workload.googleapis.com/redis.

  5. Sélectionnez une métrique côté client. Regroupez les données par operation et instance si nécessaire, puis sélectionnez un agrégateur. Pour découvrir plus d'options, consultez Sélectionner des métriques lors de l'utilisation de l'explorateur de métriques.

Afficher les traces distribuées dans Trace

Une fois que votre application commence à exporter des données, vous pouvez utiliser Trace pour visualiser le cycle complet de requête-réponse de vos commandes Redis. L'affichage de vos traces distribuées dans Trace vous permet de diagnostiquer les goulots d'étranglement afin d'isoler rapidement la source exacte de latence dans votre application.

Pour afficher les traces distribuées dans Trace, procédez comme suit :

  1. Dans la console Google Cloud , accédez à la page Explorateur Trace.

    Accéder à l'explorateur Trace

  2. Sélectionnez une trace récente représentée par un point sur le graphique à nuage de points.

  3. Examinez la vue en cascade pour isoler la source de la latence en identifiant les goulots d'étranglement suivants :

    • Durée totale de la requête : la barre de niveau supérieur (parent) indique le temps total que vous devez attendre pour que l'opération se termine.

    • Latence du réseau et du serveur (DAR) : les barres enfants (telles que celles libellées GET ou SET) indiquent le temps passé par la commande à traverser le réseau et à s'exécuter sur le serveur Memorystore pour Redis.

    • Blocage de la connexion client : s'il existe un grand espace horizontal vide avant le début de l'intervalle enfant Redis, le thread de l'application est bloqué en attente d'une connexion TCP disponible dans le pool de connexions.

    • Blocage de l'analyse de l'application : s'il existe un grand espace horizontal vide après la fin de l'intervalle enfant Redis, l'application a du mal à analyser ou à traiter la charge utile renvoyée. Cela se produit souvent avec des chaînes JSON de plusieurs mégaoctets.

    • Nouvelles tentatives : si vous voyez plusieurs segments enfants courts pour la même commande se produisant de manière séquentielle dans la même trace parente, votre client peut subir une perte de paquets réseau et doit déclencher sa boucle de nouvelle tentative avec intervalle exponentiel entre les tentatives.

Résoudre les problèmes

Cette section liste les problèmes de performances courants que vous pouvez identifier à l'aide des métriques côté client, explique leurs causes principales et fournit des conseils pour le dépannage.

Problème Cause Résoudre les problèmes

Votre application subit un pic de latence soudain, mais Memorystore pour Redis semble parfaitement opérationnel.

  • workload.googleapis.com/
    redis_client_blocking_latency
    (métrique côté client) : pic
  • workload.googleapis.com/redis_client_rtt (métrique côté client) : faible ou standard
  • redis.googleapis.com/commands/
    usec_per_call
    (métrique du serveur Memorystore pour Redis) : faible ou standard
  • redis.googleapis.com/clients/connected (métrique du serveur Memorystore pour Redis) : se stabilise à un nombre spécifique
Le goulot d'étranglement se trouve strictement dans votre application. Vos threads tentent d'exécuter des commandes Redis, mais le pool de connexions est complètement épuisé. La valeur élevée de redis_client_blocking_latency représente le temps que votre code passe à attendre un socket TCP disponible avant que la commande ne soit envoyée au réseau. Pour gérer le trafic simultané plus élevé, augmentez les limites de taille du pool de connexions dans la configuration de votre client Redis (par exemple, MaxActive pour Go, MaxTotal pour Java ou max_connections pour Node.js et Python).

La requête aboutit, mais le point de terminaison prend beaucoup plus de temps que prévu. Aucun problème n'est associé à l'état de votre réseau ou de votre serveur.

  • workload.googleapis.com/
    redis_application_blocking_latency
    (métrique côté client) : pic
  • workload.googleapis.com/redis_client_rtt (métrique côté client) : faible ou standard
  • redis.googleapis.com/commands/
    usec_per_call
    (métrique du serveur Memorystore pour Redis) : faible ou standard
  • redis.googleapis.com/stats/
    network_traffic
    (octets sortants) (métrique du serveur Memorystore pour Redis) : pics importants
Memorystore pour Redis exécute la commande et le réseau transfère la charge utile rapidement (DAR faible). Toutefois, la charge utile renvoyée est volumineuse (par exemple, une chaîne JSON de 15 Mo). Votre application rencontre un redis_application_blocking_latency élevé, car elle consomme trop de ressources lors de l'allocation de mémoire et de la désérialisation de cette grande chaîne en objet. Optimisez votre modèle de données. Ne stockez pas de blobs JSON volumineux dans des clés uniques. Décomposez les données à l'aide de hachages Redis (HSET) et utilisez HGET ou HMGET pour ne récupérer que les champs spécifiques dont vous avez besoin.

La latence de votre application visible par l'utilisateur augmente, mais vos métriques Redis indiquent une faible latence du serveur et des extractions de pool de connexions standards.

  • workload.googleapis.com/redis_retry_count (métrique côté client) : pics
  • workload.googleapis.com/
    redis_connectivity_error_count
    (métrique côté client) : peut afficher des incréments temporaires
  • workload.googleapis.com/redis_client_rtt (métrique côté client) : faible ou standard pour les requêtes réussies
  • redis.googleapis.com/commands/
    usec_per_call
    (métrique du serveur Memorystore pour Redis) : faible ou standard
Comme redis_client_rtt ne capture que le DAR des requêtes réussies, il ne reflète pas la durée du délai avant expiration d'un paquet ayant échoué. Lorsque votre application subit des pertes de paquets ou des réinitialisations TCP temporaires, la logique de nouvelle tentative de votre client instrumenté incrémente redis_retry_count et déclenche sa boucle d'intervalle exponentiel entre les tentatives. Cela introduit un temps de veille entre les tentatives (par exemple, 100ms, 200ms ou 400ms). L'utilisateur subit une latence totale élevée, mais la cause principale sous-jacente est une perte de paquets réseau, qui déclenche des délais de veille côté client. Vérifiez vos journaux de flux VPC pour détecter les paquets supprimés, la limitation de la bande passante ou les anomalies de routage interrégional. Si vous rencontrez des délais d'expiration agressifs, assurez-vous que les délais d'expiration de la connexion client (socket_timeout ou connect_timeout) sont supérieurs au DAR attendu pour tenir compte de la gigue réseau temporaire.

Tout s'arrête et toutes les couches du pipeline de télémétrie signalent une latence élevée.

  • workload.googleapis.com/redis_client_rtt (métrique côté client) : élevée
  • redis.googleapis.com/commands/
    usec_per_call
    (métrique du serveur Memorystore pour Redis) : élevée
  • redis.googleapis.com/stats/
    cpu_utilization_main_thread
    (métrique du serveur Memorystore pour Redis) : élevée (par exemple, proche de 1 s/s ou 100 %)
  • Trace en cascade : affiche une commande qui prend beaucoup de temps
Redis est monothread. Lorsque vous exécutez une commande de complexité temporelle O(N), telle que KEYS *, SMEMBERS sur un ensemble massif ou HGETALL sur un hachage avec des millions de champs, le moteur Redis s'interrompt pour répondre à cette requête. Pendant l'exécution de cette commande, toutes les autres requêtes d'application sont mises en file d'attente, ce qui entraîne un pic de latence à l'échelle du système. Comme votre redis_client_rtt personnalisé correspond à la latence du serveur (commands/usec_per_call), le serveur qui exécute la commande est le goulot d'étranglement.

Ouvrez Trace et examinez les commandes Redis sur les segments lents pour identifier la requête à l'origine du blocage. Remplacez les commandes bloquantes par des commandes non bloquantes dans votre code.

Pour effectuer une itération incrémentielle sur de grands ensembles de données sans verrouiller le thread du serveur, utilisez SCAN, SSCAN ou HSCAN.

Votre application signale une latence de référence élevée et constante pour toutes les commandes Redis, même lorsque le trafic est faible.

  • workload.googleapis.com/redis_client_rtt (métrique côté client) : constamment élevée (p50 et p99 sont tous deux d'environ 30 à 100 ms et plus)
  • redis.googleapis.com/commands/
    usec_per_call
    (métrique du serveur Memorystore pour Redis) : extrêmement faible (< 1 ms)
  • workload.googleapis.com/
    redis_client_blocking_latency

    et redis_application_blocking_latency : faible ou moyenne
Le serveur Redis exécute les commandes instantanément, mais votre application et votre instance sont déployées dans des régions différentes (par exemple, us-central1 et us-east1). Chaque paquet réseau doit transiter par l'infrastructure cloud physique de Google Cloud entre ces centres de données géographiques. Cela entraîne une pénalité de latence interrégionale obligatoire liée à la vitesse de la lumière pour chaque aller-retour. Pour réduire la latence, déployez votre application dans la même région et la même zone que votre instance. Pour afficher la région de votre application et de votre instance, utilisez la console Google Cloud .

Étapes suivantes