In diesem Thema wird beschrieben, wie Sie eine Cloud Spanner-Komponente zur Ermittlung der Latenzquelle untersuchen. Dazu müssen Sie OpenCensus verwenden, um die Latenz zu erfassen und zu visualisieren. Eine allgemeine Übersicht über die Komponenten in diesem Thema finden Sie unter Latenzpunkte in einer Cloud Spanner-Anfrage.
Hinweis
Gehen Sie wie im Abschnitt Latenzpunkt identifizieren beschrieben vor, um die Komponenten oder Komponenten zu finden, die Latenz anzeigen.
Client-Roundtrip-Latenz erfassen und visualisieren
Die Client-Roundtrip-Latenz ist die Zeitdauer (in Millisekunden) zwischen dem ersten Byte der Spanner API-Anfrage, die der Client über das GFE und das Spanner API-Front-End an die Datenbank sendet, und das letzte Byte der Antwort, die der Client von der Datenbank empfängt.
Umlauflatenz des Clients erfassen
Sie können die Client-Umlauflatenz für die folgenden Sprachen erfassen:
Client-Umlauflatenz visualisieren
Nachdem Sie die Messwerte abgerufen haben, können Sie die Umlaufzeit des Clients in Cloud Monitoring visualisieren.
Hier sehen Sie ein Beispiel für eine Grafik, die die Latenz des 5. Perzentils für den Client-Roundtrip-Latenzmesswert veranschaulicht. Über das Menü Aggregator können Sie die Perzentillatenz auf das 50. oder 99. Perzentil ändern.
Das Programm erstellt eine OpenCensus-Ansicht mit dem Namen roundtrip_latency.
Dieser String wird Teil des Namens des Messwerts, wenn er in Cloud Monitoring exportiert wird.
GFE-Latenz erfassen und visualisieren
Die Latenz des Google Front End (GFE) ist die Zeit in Millisekunden, die zwischen dem Empfang des Remoteprozeduraufrufs durch das Google-Netzwerk und dem Empfang des ersten Bytes der Antwort durch das Google-Netzwerk liegt.
GFE-Latenz erfassen
Sie können die GFE-Latenz für die folgenden Sprachen erfassen:
Einfach loslegen (Go)
// We are in the process of adding support in the Cloud Spanner Go Client Library
// to capture the gfe_latency metric.
import (
"context"
"fmt"
"io"
"strconv"
"strings"
spanner "cloud.google.com/go/spanner/apiv1"
gax "github.com/googleapis/gax-go/v2"
sppb "google.golang.org/genproto/googleapis/spanner/v1"
"google.golang.org/grpc"
"google.golang.org/grpc/metadata"
"contrib.go.opencensus.io/exporter/stackdriver"
"go.opencensus.io/stats"
"go.opencensus.io/stats/view"
"go.opencensus.io/tag"
)
// OpenCensus Tag, Measure and View.
var (
KeyMethod = tag.MustNewKey("grpc_client_method")
GFELatencyMs = stats.Int64("cloud.google.com/go/spanner/gfe_latency",
"Latency between Google's network receives an RPC and reads back the first byte of the response", "ms")
GFELatencyView = view.View{
Name: "cloud.google.com/go/spanner/gfe_latency",
Measure: GFELatencyMs,
Description: "Latency between Google's network receives an RPC and reads back the first byte of the response",
Aggregation: view.Distribution(0.0, 0.01, 0.05, 0.1, 0.3, 0.6, 0.8, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 13.0,
16.0, 20.0, 25.0, 30.0, 40.0, 50.0, 65.0, 80.0, 100.0, 130.0, 160.0, 200.0, 250.0,
300.0, 400.0, 500.0, 650.0, 800.0, 1000.0, 2000.0, 5000.0, 10000.0, 20000.0, 50000.0,
100000.0),
TagKeys: []tag.Key{KeyMethod}}
)
func queryWithGFELatency(w io.Writer, db string) error {
projectID, _, _, err := parseDatabaseName(db)
if err != nil {
return err
}
ctx := context.Background()
client, err := spanner.NewClient(ctx)
if err != nil {
return err
}
defer client.Close()
// Register OpenCensus views.
err = view.Register(&GFELatencyView)
if err != nil {
return err
}
// Create OpenCensus Stackdriver exporter.
sd, err := stackdriver.NewExporter(stackdriver.Options{
ProjectID: projectID,
})
if err != nil {
return err
}
// It is imperative to invoke flush before your main function exits
defer sd.Flush()
// Start the metrics exporter
sd.StartMetricsExporter()
defer sd.StopMetricsExporter()
// Create a session.
req := &sppb.CreateSessionRequest{Database: db}
session, err := client.CreateSession(ctx, req)
if err != nil {
return err
}
// Execute a SQL query and retrieve the GFE server-timing header in gRPC metadata.
req2 := &sppb.ExecuteSqlRequest{
Session: session.Name,
Sql: `SELECT SingerId, AlbumId, AlbumTitle FROM Albums`,
}
var md metadata.MD
resultSet, err := client.ExecuteSql(ctx, req2, gax.WithGRPCOptions(grpc.Header(&md)))
if err != nil {
return err
}
for _, row := range resultSet.GetRows() {
for _, value := range row.GetValues() {
fmt.Fprintf(w, "%s ", value.GetStringValue())
}
fmt.Fprintf(w, "\n")
}
// The format is: "server-timing: gfet4t7; dur=[GFE latency in ms]"
srvTiming := md.Get("server-timing")[0]
gfeLtcy, err := strconv.Atoi(strings.TrimPrefix(srvTiming, "gfet4t7; dur="))
if err != nil {
return err
}
// Record GFE t4t7 latency with OpenCensus.
ctx, err = tag.New(ctx, tag.Insert(KeyMethod, "ExecuteSql"))
if err != nil {
return err
}
stats.Record(ctx, GFELatencyMs.M(int64(gfeLtcy)))
return nil
}
GFE-Latenz visualisieren
Nachdem Sie die Messwerte abgerufen haben, können Sie die GFE-Latenz in Cloud Monitoring visualisieren.
Hier ist ein Beispiel für eine Grafik, die die Latenz des 5. Perzentils für den GFE-Latenzmesswert veranschaulicht. Über das Menü Aggregator können Sie die Perzentillatenz auf das 50. oder 99. Perzentil ändern.
Das Programm erstellt eine OpenCensus-Ansicht mit dem Namen gfe_latency. Dieser String wird beim Export in Cloud Monitoring Teil des Messwerts.
Spanner API-Anfragelatenz erfassen und visualisieren
Die Latenz der Spanner API-Anfrage ist die Zeitspanne (in Sekunden) zwischen dem ersten Anfragebyte, das das Spanner API-Front-End empfängt, und dem letzten Byte der Antwort, das das Spanner API-Front-End sendet.
Latenz der Spanner API-Anfrage erfassen
Diese Latenz ist standardmäßig als Teil der Cloud Monitoring-Messwerte verfügbar.
Sie müssen nichts unternehmen, um sie zu erfassen und zu exportieren.
Latenz von Spanner API-Anfragen visualisieren
Mit dem Diagrammtool Metrics Explorer können Sie das Diagramm für den Messwert spanner.googleapis.com/api/request_latencies in Cloud Monitoring visualisieren.
Hier ist ein Beispiel für eine Grafik, in der die Latenz des 5. Perzentils für den Latenzmesswert der Spanner API dargestellt wird. Wenn Sie die Perzentillatenz auf das 50. oder 99. Perzentil ändern möchten, verwenden Sie das Menü Aggregator.
Abfragelatenz erfassen und visualisieren
Die Abfragelatenz ist die Zeit in Millisekunden, die zum Ausführen von SQL-Abfragen in der Spanner-Datenbank benötigt wird.
Abfragelatenz erfassen
Sie können die Abfragelatenz für die folgenden Sprachen erfassen:
Java
private static final String MILLISECOND = "ms";
static final List<Double> RPC_MILLIS_BUCKET_BOUNDARIES =
Collections.unmodifiableList(
Arrays.asList(
0.0, 0.01, 0.05, 0.1, 0.3, 0.6, 0.8, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 13.0,
16.0, 20.0, 25.0, 30.0, 40.0, 50.0, 65.0, 80.0, 100.0, 130.0, 160.0, 200.0, 250.0,
300.0, 400.0, 500.0, 650.0, 800.0, 1000.0, 2000.0, 5000.0, 10000.0, 20000.0, 50000.0,
100000.0));
static final Aggregation AGGREGATION_WITH_MILLIS_HISTOGRAM =
Distribution.create(BucketBoundaries.create(RPC_MILLIS_BUCKET_BOUNDARIES));
static MeasureDouble QUERY_STATS_ELAPSED =
MeasureDouble.create(
"cloud.google.com/java/spanner/query_stats_elapsed",
"The execution of the query",
MILLISECOND);
// Register the view. It is imperative that this step exists,
// otherwise recorded metrics will be dropped and never exported.
static View QUERY_STATS_LATENCY_VIEW = View
.create(Name.create("cloud.google.com/java/spanner/query_stats_elapsed"),
"The execution of the query",
QUERY_STATS_ELAPSED,
AGGREGATION_WITH_MILLIS_HISTOGRAM,
Collections.emptyList());
static ViewManager manager = Stats.getViewManager();
private static final StatsRecorder STATS_RECORDER = Stats.getStatsRecorder();
static void captureQueryStatsMetric(DatabaseClient dbClient) {
manager.registerView(QUERY_STATS_LATENCY_VIEW);
// Enable OpenCensus exporters to export metrics to Cloud Monitoring.
// Exporters use Application Default Credentials to authenticate.
// See https://developers.google.com/identity/protocols/application-default-credentials
// for more details.
try {
StackdriverStatsExporter.createAndRegister();
} catch (IOException | IllegalStateException e) {
System.out.println("Error during StackdriverStatsExporter");
}
try (ResultSet resultSet = dbClient.singleUse()
.analyzeQuery(Statement.of("SELECT SingerId, AlbumId, AlbumTitle FROM Albums"),
QueryAnalyzeMode.PROFILE)) {
while (resultSet.next()) {
System.out.printf(
"%d %d %s", resultSet.getLong(0), resultSet.getLong(1), resultSet.getString(2));
}
Value value = resultSet.getStats().getQueryStats()
.getFieldsOrDefault("elapsed_time", Value.newBuilder().setStringValue("0 msecs").build());
double elapasedTime = Double.parseDouble(value.getStringValue().replaceAll(" msecs", ""));
STATS_RECORDER.newMeasureMap()
.put(QUERY_STATS_ELAPSED, elapasedTime)
.record();
}
}
Einfach loslegen (Go)
import (
"context"
"fmt"
"io"
"strconv"
"strings"
"cloud.google.com/go/spanner"
"google.golang.org/api/iterator"
"contrib.go.opencensus.io/exporter/stackdriver"
"go.opencensus.io/stats"
"go.opencensus.io/stats/view"
"go.opencensus.io/tag"
)
// OpenCensus Tag, Measure and View.
var (
QueryStatsElapsed = stats.Float64("cloud.google.com/go/spanner/query_stats_elapsed",
"The execution of the query", "ms")
QueryStatsLatencyView = view.View{
Name: "cloud.google.com/go/spanner/query_stats_elapsed",
Measure: QueryStatsElapsed,
Description: "The execution of the query",
Aggregation: view.Distribution(0.0, 0.01, 0.05, 0.1, 0.3, 0.6, 0.8, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 13.0,
16.0, 20.0, 25.0, 30.0, 40.0, 50.0, 65.0, 80.0, 100.0, 130.0, 160.0, 200.0, 250.0,
300.0, 400.0, 500.0, 650.0, 800.0, 1000.0, 2000.0, 5000.0, 10000.0, 20000.0, 50000.0,
100000.0),
TagKeys: []tag.Key{}}
)
func queryWithQueryStats(w io.Writer, db string) error {
projectID, _, _, err := parseDatabaseName(db)
if err != nil {
return err
}
ctx := context.Background()
client, err := spanner.NewClient(ctx, db)
if err != nil {
return err
}
defer client.Close()
// Register OpenCensus views.
err = view.Register(&QueryStatsLatencyView)
if err != nil {
return err
}
// Create OpenCensus Stackdriver exporter.
sd, err := stackdriver.NewExporter(stackdriver.Options{
ProjectID: projectID,
})
if err != nil {
return err
}
// It is imperative to invoke flush before your main function exits
defer sd.Flush()
// Start the metrics exporter
sd.StartMetricsExporter()
defer sd.StopMetricsExporter()
// Execute a SQL query and get the query stats.
stmt := spanner.Statement{SQL: `SELECT SingerId, AlbumId, AlbumTitle FROM Albums`}
iter := client.Single().QueryWithStats(ctx, stmt)
defer iter.Stop()
for {
row, err := iter.Next()
if err == iterator.Done {
// Record query execution time with OpenCensus.
elapasedTime := iter.QueryStats["elapsed_time"].(string)
elapasedTimeMs, err := strconv.ParseFloat(strings.TrimSuffix(elapasedTime, " msecs"), 64)
if err != nil {
return err
}
stats.Record(ctx, QueryStatsElapsed.M(elapasedTimeMs))
return nil
}
if err != nil {
return err
}
var singerID, albumID int64
var albumTitle string
if err := row.Columns(&singerID, &albumID, &albumTitle); err != nil {
return err
}
fmt.Fprintf(w, "%d %d %s\n", singerID, albumID, albumTitle)
}
}
Abfragelatenz visualisieren
Nachdem Sie die Messwerte abgerufen haben, können Sie die Abfragelatenz in Cloud Monitoring visualisieren.
Hier ist ein Beispiel für eine Grafik, in der die Latenz des 5. Perzentils für den Abfragelatenzmesswert dargestellt wird. Über das Menü Aggregator können Sie die Perzentillatenz auf das 50. oder 99. Perzentil ändern.
Das Programm erstellt eine OpenCensus-Ansicht mit dem Namen query_stats_elapsed.
Dieser String wird beim Export in Cloud Monitoring Teil des Messwerts.
Nächste Schritte
