Usar métricas do lado do cliente para resolver problemas de alta latência

Embora o Memorystore para Redis forneça métricas em tempo real do lado do servidor para monitorar a capacidade de processamento, a utilização da CPU e o uso da memória, esses dados por si só podem não explicar por que o aplicativo cliente apresenta alta latência em sistemas distribuídos complexos.

As métricas do lado do cliente resolvem isso oferecendo transparência em todo o ciclo de solicitação-resposta. Elas medem um comando desde o momento em que o aplicativo o inicia até o momento em que o aplicativo processa a resposta. Ao capturar esses pontos de dados, é possível determinar com precisão se a latência se origina da lógica do aplicativo, do caminho de rede ou do servidor do Redis.

Antes de começar

Verifique se o aplicativo cliente usa uma conta de serviço e se os seguintes papéis do Identity and Access Management (IAM) estão atribuídos a ela:

  • roles/cloudtrace.agent (Agente do Cloud Trace)
  • roles/monitoring.metricWriter (Gravador de métricas do Monitoring)

Para mais informações sobre como conceder papéis, consulte o guia de início rápido Conceder um papel do IAM usando o console do Google Cloud .

Ativar a API Cloud Monitoring.

Para exportar métricas do lado do cliente para o Monitoring, seu aplicativo exige que você ative a API Monitoring. Exportar e visualizar essas métricas no Monitoring permite identificar a causa raiz dos gargalos para determinar onde a latência se origina.

Para ativar a API Monitoring, faça o seguinte:

  1. No console do Google Cloud , acesse a página APIs e serviços.

    Acessar APIs e serviços

  2. Selecione o projeto em que você criou a instância do Memorystore para Redis.

  3. Clique em Ativar APIs e serviços.

  4. Pesquisar por monitoring.

  5. Nos resultados da pesquisa, clique em API Cloud Monitoring.

  6. Se a mensagem API ativada aparecer, quer dizer que a API já está ativada. Caso contrário, clique em Ativar.

Ative a API Cloud Trace

Para visualizar traces distribuídos no Trace, é necessário ativar a API Trace. Em seguida, use o Trace Explorer para visualizar esses traces, diagnosticar gargalos e isolar a origem da latência no aplicativo.

Para ativar a API Trace, faça o seguinte:

  1. No console do Google Cloud , acesse a página APIs e serviços.

    Acessar APIs e serviços

  2. Selecione o projeto em que você criou a instância do Memorystore para Redis.

  3. Clique em Ativar APIs e serviços.

  4. Pesquisar por trace.

  5. Nos resultados da pesquisa, clique em API Cloud Trace.

  6. Se a mensagem API ativada aparecer, quer dizer que a API já está ativada. Caso contrário, clique em Ativar.

Ativar a API Telemetry

Para exportar métricas do lado do cliente usando o protocolo OpenTelemetry (OTLP), é necessário ativar a API Telemetry. Em seguida, use exportadores OTLP padrão no código do cliente, em vez de exportadores Google Cloud específicos do fornecedor.

Os exportadores padrão do OTLP evitam a perda de dados. Eles também simplificam suas dependências e garantem que seus dados permaneçam portáteis em outras plataformas de observabilidade. Depois de escrever o código de telemetria uma vez, é possível rotear os dados para qualquer uma dessas plataformas atualizando a configuração. Não é necessário reescrever o código com um novo conjunto de bibliotecas reservadas para cada plataforma.

Para ativar a API Telemetry, faça o seguinte:

  1. No console do Google Cloud , acesse a página APIs e serviços.

    Acessar APIs e serviços

  2. Selecione o projeto em que você criou a instância do Memorystore para Redis.

  3. Clique em Ativar APIs e serviços.

  4. Pesquisar por telemetry.

  5. Nos resultados da pesquisa, clique em API Telemetry.

  6. Se a mensagem API ativada aparecer, quer dizer que a API já está ativada. Caso contrário, clique em Ativar.

Ativar métricas do lado do cliente

Para ativar as métricas do lado do cliente, adicione o SDK do OpenTelemetry e os exportadores OTLP do OpenTelemetry, que têm como destino a API Telemetry, ao código do aplicativo. A instrumentação do OpenTelemetry, que é executada diretamente na biblioteca de cliente do Redis do aplicativo, captura as métricas. Isso permite que o aplicativo registre pontos de dados de latência e os exporte para o Monitoring e o Trace para visualização.

Para ativar as métricas do lado do cliente, use Go, Java, Node.js ou Python. As informações para ativar as métricas de cada linguagem aparecem nas guias a seguir.

Go

  1. Para instalar as dependências necessárias do OpenTelemetry e do exportador OTLP, execute os seguintes comandos no 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. Para ativar as métricas do lado do cliente, crie um arquivo main.go e adicione o seguinte código a ele:

    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. Execute o aplicativo por pelo menos um minuto para que o exportador tenha tempo suficiente para agrupar e enviar as métricas publicadas ao Monitoring.

Java

  1. Para instalar as dependências necessárias do OpenTelemetry e do exportador OTLP, adicione o seguinte código ao arquivo pom.xml do aplicativo:

    <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. Para ativar as métricas do lado do cliente, crie um arquivo RedisTelemetryApp.java e adicione o seguinte código a ele:

    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. Execute o aplicativo por pelo menos um minuto para que o exportador tenha tempo suficiente para agrupar e enviar as métricas publicadas ao Monitoring.

Node.js

  1. Para instalar as dependências necessárias do OpenTelemetry e do exportador OTLP, execute os seguintes comandos no 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. Para ativar as métricas do lado do cliente, crie um arquivo server.js e adicione o seguinte código a ele:

    
    '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. Execute o aplicativo por pelo menos um minuto para que o exportador tenha tempo suficiente para agrupar e enviar as métricas publicadas ao Monitoring.

Python

  1. Para instalar as dependências necessárias do OpenTelemetry e do exportador OTLP, execute os seguintes comandos no 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. Para ativar as métricas do lado do cliente, crie um arquivo main.py e adicione o seguinte código ao aplicativo:

    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. Execute o aplicativo por pelo menos um minuto para que o exportador tenha tempo suficiente para agrupar e enviar as métricas publicadas ao Monitoring.

Ver métricas no Monitoring

Depois de ativar as métricas do lado do cliente e executar o aplicativo por pelo menos um minuto para que o exportador tenha tempo suficiente para agrupar e enviar métricas ao Monitoring, use o Monitoring para visualizar as métricas, agrupá-las por operação ou instância e aplicar agregadores para monitorar o desempenho do aplicativo.

Para conferir as métricas no Monitoring, faça o seguinte:

  1. No console do Google Cloud , acesse a página do Metrics Explorer.

    Acessar o Metrics Explorer

  2. Selecionar o projeto Google Cloud .

  3. Clique em Selecionar uma métrica.

  4. Pesquisar por workload.googleapis.com/redis.

  5. Selecione uma métrica do lado do cliente. Agrupe os dados por operation e instance conforme necessário e escolha um agregador. Para conhecer outras opções, consulte Selecionar métricas ao usar o Metrics Explorer.

Ver traces distribuídos no Trace

Depois que o aplicativo começar a exportar dados, use o Trace para visualizar o ciclo completo de solicitação-resposta dos comandos do Redis. Ao visualizar os traces distribuídos no Trace, é possível diagnosticar gargalos para isolar rapidamente a origem exata da latência no aplicativo.

Para ver traces distribuídos no Trace, faça o seguinte:

  1. No console Google Cloud , acesse a página Explorador de traces.

    Acessar o Explorador de traces

  2. Selecione um trace recente representado por um ponto no gráfico de dispersão.

  3. Examine a visualização em cascata para isolar a origem da latência identificando os seguintes gargalos:

    • Duração total da solicitação: a barra de nível superior (principal) mostra o tempo total que você precisa esperar para que a operação seja concluída.

    • Latência de rede e servidor (RTT): as barras secundárias (como as rotuladas como GET ou SET) mostram o tempo que o comando levou para viajar pela rede e ser executado no servidor do Memorystore para Redis.

    • Bloqueio de conexão do cliente: se houver uma lacuna horizontal grande e vazia antes do início do período filho do Redis, a linha de execução do aplicativo ficará travada aguardando uma conexão TCP disponível do pool de conexões.

    • Bloqueio de análise do aplicativo: se houver uma lacuna horizontal grande e vazia depois que o período filho do Redis terminar, o aplicativo terá dificuldade para analisar ou processar o payload retornado. Isso geralmente acontece com strings JSON de vários megabytes.

    • Novas tentativas: se você encontrar vários períodos filhos curtos para o mesmo comando ocorrendo sequencialmente no mesmo trace pai, seu cliente pode ter perda de pacotes de rede e precisa acionar o loop de nova tentativa de espera exponencial.

Resolver problemas

Nesta seção, listamos problemas comuns de desempenho que podem ser identificados usando métricas do lado do cliente, explicamos as causas raiz e fornecemos orientações sobre como resolver os problemas.

Problema Causa Resolver problemas

Seu aplicativo apresenta um pico repentino de latência, mas o Memorystore para Redis parece estar totalmente íntegro.

  • workload.googleapis.com/
    redis_client_blocking_latency
    (métrica do lado do cliente): pico
  • workload.googleapis.com/redis_client_rtt (métrica do lado do cliente): baixa ou típica
  • redis.googleapis.com/commands/
    usec_per_call
    (métrica do servidor do Memorystore for Redis): baixa ou típica
  • redis.googleapis.com/clients/connected (métrica do servidor do Memorystore para Redis): se estabiliza em um número específico
O gargalo está estritamente dentro do aplicativo. As linhas de execução tentam executar comandos do Redis, mas o pool de conexões está totalmente esgotado. O redis_client_blocking_latency alto representa o tempo que o código passa esperando por um soquete TCP disponível antes que o comando seja enviado à rede. Para lidar com o tráfego simultâneo mais alto, aumente os limites de tamanho do pool de conexões na configuração do cliente do Redis (por exemplo, MaxActive para Go, MaxTotal para Java ou max_connections para Node.js e Python).

A solicitação é concluída, mas o endpoint leva muito mais tempo do que o esperado. Não há problemas associados à integridade da rede ou do servidor.

  • workload.googleapis.com/
    redis_application_blocking_latency
    (métrica do lado do cliente): pico
  • workload.googleapis.com/redis_client_rtt (métrica do lado do cliente): baixa ou típica
  • redis.googleapis.com/commands/
    usec_per_call
    (métrica do servidor do Memorystore for Redis): baixa ou típica
  • redis.googleapis.com/stats/
    network_traffic
    (Bytes de saída) (métrica do servidor do Memorystore para Redis): picos intensos
O Memorystore para Redis executa o comando, e a rede transfere o payload rapidamente (RTT baixo). No entanto, o payload retornado é grande (por exemplo, uma string JSON de 15 MB). O aplicativo apresenta um redis_application_blocking_latency alto porque consome recursos excessivos ao alocar memória e desserializar essa string grande em um objeto. Otimize o modelo de dados. Não armazene blobs JSON enormes em chaves únicas. Divida os dados usando hashes do Redis (HSET) e use HGET ou HMGET para recuperar apenas os campos específicos necessários.

A latência do aplicativo voltado ao usuário aumenta, mas as métricas do Redis informam uma latência de servidor baixa e check-outs típicos do pool de conexões.

  • workload.googleapis.com/redis_retry_count (métrica do lado do cliente): picos
  • workload.googleapis.com/
    redis_connectivity_error_count
    (métrica do lado do cliente): pode mostrar incrementos temporários
  • workload.googleapis.com/redis_client_rtt (métrica do lado do cliente): baixa ou típica para solicitações bem-sucedidas
  • redis.googleapis.com/commands/
    usec_per_call
    (métrica do servidor do Memorystore for Redis): baixa ou típica
Como redis_client_rtt captura apenas o RTT de solicitações bem-sucedidas, ele não reflete a duração do tempo limite de um pacote com falha. Quando o aplicativo apresenta quedas de pacotes temporárias ou redefinições de TCP, a lógica de repetição do cliente instrumentado incrementa o redis_retry_count e aciona o loop de espera exponencial. Isso introduz um tempo de espera entre as tentativas (por exemplo, 100ms, 200ms ou 400ms). O usuário enfrenta uma latência total alta, mas a causa raiz é uma perda de pacote de rede, que aciona atrasos de espera do lado do cliente. Verifique se há pacotes descartados, limitação de largura de banda ou anomalias de roteamento entre regiões nos registros de fluxo de VPC. Se você tiver tempos limite agressivos, verifique se os tempos limite de conexão do cliente (socket_timeout ou connect_timeout) são maiores do que o RTT esperado para considerar o jitter de rede temporário.

Tudo para e todas as camadas do pipeline de telemetria relatam alta latência.

  • workload.googleapis.com/redis_client_rtt (métrica do lado do cliente): alta
  • redis.googleapis.com/commands/
    usec_per_call
    (métrica do servidor do Memorystore for Redis): alta
  • redis.googleapis.com/stats/
    cpu_utilization_main_thread
    (métrica do servidor do Memorystore for Redis): alta (por exemplo, perto de 1 s/s ou 100%)
  • Cascata de trace: mostra um comando que leva muito tempo
O Redis tem uma única linha de execução. Quando você executa um comando de complexidade de tempo O(N), como KEYS *, SMEMBERS em um conjunto massivo ou HGETALL em um hash com milhões de campos, o mecanismo do Redis é pausado para atender a essa solicitação. Enquanto esse comando é executado, todas as outras solicitações de aplicativo são colocadas em fila, causando um pico de latência em todo o sistema. Como o redis_client_rtt personalizado corresponde à latência do servidor (commands/usec_per_call), o servidor que executa o comando é o gargalo.

Abra o Trace e observe os comandos do Redis nos períodos lentos para identificar qual consulta causa o bloqueio. Substitua os comandos de bloqueio por comandos sem bloqueio no código.

Para iterar em grandes conjuntos de dados de forma incremental sem bloquear a linha de execução do servidor, use SCAN, SSCAN ou HSCAN.

O aplicativo relata uma latência de referência consistente e elevada para todos os comandos do Redis, mesmo quando o tráfego está baixo.

  • workload.googleapis.com/redis_client_rtt (métrica do lado do cliente): consistentemente elevada (p50 e p99 são ~30-100 ms+)
  • redis.googleapis.com/commands/
    usec_per_call
    (métrica do servidor do Memorystore para Redis): extremamente baixa (< 1 ms)
  • workload.googleapis.com/
    redis_client_blocking_latency

    e redis_application_blocking_latency: baixo ou normal
O servidor do Redis executa comandos instantaneamente, mas o aplicativo e a instância são implantados em regiões diferentes (por exemplo, us-central1 e us-east1). Cada pacote de rede precisa viajar pela infraestrutura física do Google Cloud entre esses data centers geográficos. Isso resulta em uma penalidade obrigatória de latência entre regiões na velocidade da luz para cada ida e volta. Para reduzir a latência, implante o aplicativo para que ele resida na mesma região e zona que a instância. Para ver a região do aplicativo e da instância, use o console do Google Cloud .

A seguir