Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

דוגמה לאינסטרומנטציה ב-Go

במאמר הזה מוסבר איך להוסיף אינסטרומנטציה לאפליקציית Go כדי לאסוף נתוני מעקב ומדדים באמצעות OpenTelemetry SDK ו-OpenTelemetry Collector. הוא גם מסביר איך לכתוב יומנים מובנים בפורמט JSON לפלט רגיל. כדי להתנסות בהוספת מכשור, מורידים ומריצים את האפליקציה לדוגמה. האפליקציה הזו יוצרת נתוני יומן, מדדים ונתוני מעקב.

כשמשתמשים ב-OpenTelemetry collector, מוסיפים אינסטרומנטציה לאפליקציה באמצעות ה-SDK וה-OTLP in-process exporter של ה-SDK. הכלי הזה לא תלוי בספק. אתם גם פורסים OpenTelemetry Collector שמקבל טלמטריה מהכלי לייצוא נתונים בתהליך, ואז מייצא את הטלמטריה הזו לפרויקט Google Cloud . מידע נוסף על קולקטורים זמין במאמר בנושא Google-Built OpenTelemetry Collector.

מומלץ להשתמש ב-OpenTelemetry collector כדי לייצא את נתוני הטלמטריה אם הסביבה שלכם תומכת בשימוש ב-collector. בסביבות מסוימות, צריך להשתמש בכלי לייצוא שפועל בתהליך ושולח נתונים ישירות לGoogle Cloud פרויקט. מידע על הטמעה בתהליך זמין במאמר מעבר מ-Trace exporter לנקודת הקצה OTLP.

למידע נוסף על מכשור, אפשר לעיין במסמכים הבאים:

מידע על הקשר

‫Context ב-OpenTelemetry הוא מנגנון להעברת ערכים בהיקף הביצוע בין ממשקי API בתהליך. שימוש חשוב בהקשר הוא העברת הטווח הפעיל הנוכחי כדי שניתן יהיה לשנות אותו או להתייחס אליו כאל רכיב האב של טווחים חדשים שנוצרים. לסיכום:

הקשר מתייחס למנגנון להפצת ערכים בהיקף ההרצה, כולל יחידה לוגית למעקב הפעילה הנוכחית, בין ממשקי API בתהליך.
Span Context הוא אובייקט שלא ניתן לשינוי בכל span, שכולל את מזהה העקבות, מזהה ה-span, דגלים ומצב של העקבות.
הפצה היא המנגנון שמעביר הקשר בין שירותים ותהליכים.

בנוסף, ספריית התקנים של Go‏, context.Context, מעבירה ערכים בהיקף מוגדר בין גבולות של ממשקי API. בדרך כלל, פונקציות handler בשרת מקבלות Context נכנסת ומעבירות אותה דרך שרשרת הקריאות לכל הלקוחות שמבצעים בקשות יוצאות.

הספרייה הרגילה של Go‏ context.Context משמשת כהטמעה של OpenTelemetry Context ב-Go.

לפני שמתחילים

נכנסים לחשבון Google Cloud . אם אתם משתמשים חדשים ב- Google Cloud, צרו חשבון כדי שתוכלו להעריך את הביצועים של המוצרים שלנו בתרחישים מהעולם האמיתי. לקוחות חדשים מקבלים בחינם גם קרדיט בשווי 300$ להרצה, לבדיקה ולפריסה של עומסי העבודה.

התקינו את ה-CLI של Google Cloud.

אם אתם משתמשים בספק זהויות חיצוני (IdP), קודם אתם צריכים להיכנס ל-CLI של gcloud באמצעות המאגר המאוחד לניהול זהויות.

כדי לאתחל את ה-CLI של gcloud, הריצו את הפקודה הבאה:

gcloud init

יוצרים או בוחרים Google Cloud פרויקט.

תפקידים שנדרשים כדי לבחור או ליצור פרויקט

Select a project: כדי לבחור פרויקט לא צריך תפקיד IAM ספציפי – אפשר לבחור כל פרויקט שקיבלתם בו תפקיד.
יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד Project Creator (יצירת פרויקטים) (roles/resourcemanager.projectCreator), שכולל את ההרשאה resourcemanager.projects.create. איך מקצים תפקידים

יוצרים Google Cloud פרויקט:
```
gcloud projects create PROJECT_ID
```
מחליפים את PROJECT_ID בשם של פרויקט Google Cloud שיוצרים.
בוחרים את הפרויקט שיצרתם: Google Cloud
```
gcloud config set project PROJECT_ID
```
מחליפים את PROJECT_ID בשם הפרויקט ב- Google Cloud .

מוודאים שהחיוב מופעל בפרויקט Google Cloud .

מפעילים את ממשקי ה-API של Cloud Logging,‏ Cloud Monitoring,‏ Cloud Trace וטלמטריה:

תפקידים שנדרשים להפעלת ממשקי API

כדי להפעיל ממשקי API, צריך את תפקיד ה-IAM 'אדמין של Service Usage' (roles/serviceusage.serviceUsageAdmin), שכולל את ההרשאה serviceusage.services.enable. איך מקצים תפקידים

gcloud services enable logging.googleapis.com monitoring.googleapis.com cloudtrace.googleapis.com telemetry.googleapis.com

התקינו את ה-CLI של Google Cloud.

אם אתם משתמשים בספק זהויות חיצוני (IdP), קודם אתם צריכים להיכנס ל-CLI של gcloud באמצעות המאגר המאוחד לניהול זהויות.

כדי לאתחל את ה-CLI של gcloud, הריצו את הפקודה הבאה:

gcloud init

יוצרים או בוחרים Google Cloud פרויקט.

תפקידים שנדרשים כדי לבחור או ליצור פרויקט

Select a project: כדי לבחור פרויקט לא צריך תפקיד IAM ספציפי – אפשר לבחור כל פרויקט שקיבלתם בו תפקיד.
יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד Project Creator (יצירת פרויקטים) (roles/resourcemanager.projectCreator), שכולל את ההרשאה resourcemanager.projects.create. איך מקצים תפקידים

יוצרים Google Cloud פרויקט:
```
gcloud projects create PROJECT_ID
```
מחליפים את PROJECT_ID בשם של פרויקט Google Cloud שיוצרים.
בוחרים את הפרויקט שיצרתם: Google Cloud
```
gcloud config set project PROJECT_ID
```
מחליפים את PROJECT_ID בשם הפרויקט ב- Google Cloud .

מוודאים שהחיוב מופעל בפרויקט Google Cloud .

מפעילים את ממשקי ה-API של Cloud Logging,‏ Cloud Monitoring,‏ Cloud Trace וטלמטריה:

תפקידים שנדרשים להפעלת ממשקי API

gcloud services enable logging.googleapis.com monitoring.googleapis.com cloudtrace.googleapis.com telemetry.googleapis.com

כדי לקבל את ההרשאות שדרושות לאפליקציית הדוגמה כדי לכתוב נתונים של יומנים, מדדים ומעקב, צריך לבקש מהאדמין להקצות לכם את תפקידי ה-IAM הבאים בפרויקט:
- Logs Writer (roles/logging.logWriter)
- כתיבת מדדי מעקב (roles/monitoring.metricWriter)
- Cloud Telemetry Traces Writer (roles/telemetry.tracesWriter)
ההרשאות האלה מספיקות אם מריצים את הדוגמה ב-Cloud Shell, במשאבים או בסביבת פיתוח מקומית. Google Cloud

חשוב: אפליקציות בייצור מסתמכות בדרך כלל על חשבון שירות כדי לספק את פרטי הכניסה שנדרשים לכתיבת נתוני יומן, מדדים ומעקב. בתרחישים האלה, צריך להקצות לחשבון השירות את התפקידים הקודמים.

כדי לקבל את ההרשאות שדרושות להצגת נתוני היומן, המדדים והמעקב, צריך לבקש מהאדמין להקצות לכם את תפקידי ה-IAM הבאים בפרויקט:
- כלי הצפייה ביומנים (roles/logging.viewer)
- צפייה ב-Monitoring (roles/monitoring.viewer)
- משתמש Cloud Trace (roles/cloudtrace.user)
להסבר על מתן תפקידים, ראו איך מנהלים את הגישה ברמת הפרויקט, התיקייה והארגון.

יכול להיות שאפשר לקבל את ההרשאות הנדרשות גם באמצעות תפקידים בהתאמה אישית או תפקידים מוגדרים מראש.

בצעו אינסטרומנטציה באפליקציה כדי לאסוף נתוני מעקב, מדדים ויומנים

כדי להטמיע באפליקציה איסוף של נתוני מעקב ומדדים, ולכתוב JSON מובנה לפלט רגיל, פועלים לפי השלבים הבאים, כפי שמתואר בקטעים הבאים של המסמך הזה:

הגדרת הפונקציה הראשית
הגדרה של OpenTelemetry
הגדרת רישום ביומן במבנה
הוספת מכשור לשרת ה-HTTP
קישור של טווחים של מעקב אחר קישורים ליומנים ולמדדים
הוספת מכשור ללקוח HTTP
כתיבת יומנים מובְנים

הגדרת הפונקציה הראשית

כדי להגדיר את האפליקציה כך שתכתוב יומנים מובנים ותאסוף מדדים ונתוני מעקב באמצעות OpenTelemetry, צריך לעדכן את הפונקציה main כדי להגדיר את חבילת הרישום המובנה של Go‏, slog, וכדי להגדיר את OpenTelemetry.

בדוגמת הקוד הבאה מוצגת פונקציה main שקוראת לשתי פונקציות עזר, setupLogging() ו-setupOpenTelemetry(). פונקציות העזר האלה מגדירות את חבילת הרישום ביומן ואת OpenTelemetry.

כדי לראות את הדוגמה המלאה, בסרגל הכלים של הדוגמה, לוחצים על הלוגו של GitHub.

func main() {
	ctx := context.Background()

	// Setup logging
	setupLogging()

	// Setup metrics, tracing, and context propagation
	shutdown, err := setupOpenTelemetry(ctx)
	if err != nil {
		slog.ErrorContext(ctx, "error setting up OpenTelemetry", slog.Any("error", err))
		os.Exit(1)
	}

	// Run the http server, and shutdown and flush telemetry after it exits.
	slog.InfoContext(ctx, "server starting...")
	if err = errors.Join(runServer(), shutdown(ctx)); err != nil {
		slog.ErrorContext(ctx, "server exited with error", slog.Any("error", err))
		os.Exit(1)
	}
}

אחרי שמגדירים את חבילת הרישום ביומן, כדי לקשר את היומנים לנתוני המעקב, צריך להעביר את Context של Go לרושם היומנים. מידע נוסף זמין בקטע כתיבת יומנים מובנים במסמך הזה.

הגדרת OpenTelemetry

כדי לאסוף ולייצא עקבות ומדדים באמצעות פרוטוקול OTLP, צריך להגדיר את המופעים הגלובליים TracerProvider ו-MeterProvider. בדוגמת הקוד הבאה מוצגת הפונקציה setupOpenTelemetry, שמופעלת מהפונקציה main:

func setupOpenTelemetry(ctx context.Context) (shutdown func(context.Context) error, err error) {
	var shutdownFuncs []func(context.Context) error

	// shutdown combines shutdown functions from multiple OpenTelemetry
	// components into a single function.
	shutdown = func(ctx context.Context) error {
		var err error
		for _, fn := range shutdownFuncs {
			err = errors.Join(err, fn(ctx))
		}
		shutdownFuncs = nil
		return err
	}

	// Configure Context Propagation to use the default W3C traceparent format
	otel.SetTextMapPropagator(autoprop.NewTextMapPropagator())

	// Configure Trace Export to send spans as OTLP
	texporter, err := autoexport.NewSpanExporter(ctx)
	if err != nil {
		err = errors.Join(err, shutdown(ctx))
		return
	}
	tp := trace.NewTracerProvider(trace.WithBatcher(texporter))
	shutdownFuncs = append(shutdownFuncs, tp.Shutdown)
	otel.SetTracerProvider(tp)

	// Configure Metric Export to send metrics as OTLP
	mreader, err := autoexport.NewMetricReader(ctx)
	if err != nil {
		err = errors.Join(err, shutdown(ctx))
		return
	}
	mp := metric.NewMeterProvider(
		metric.WithReader(mreader),
	)
	shutdownFuncs = append(shutdownFuncs, mp.Shutdown)
	otel.SetMeterProvider(mp)

	return shutdown, nil
}

בדוגמת הקוד הקודמת, הגדרנו את המשתנה הגלובלי TextMapPropagator כך שישתמש בפורמט W3C Trace Context כדי להעביר את ההקשר של המעקב. ההגדרה הזו מבטיחה שלטווחים יהיו יחסי הורה-צאצא נכונים בתוך מעקב.

כדי לוודא שכל נתוני הטלמטריה שבהמתנה נמחקים ושהחיבורים נסגרים בצורה תקינה, הפונקציה setupOpenTelemetry מחזירה פונקציה בשם shutdown, שמבצעת את הפעולות האלה.

הגדרת רישום ביומן במבנה

כדי לכלול את פרטי העקבות כחלק מהיומנים בפורמט JSON שנכתבים לפלט רגיל, צריך להגדיר את חבילת הרישום המובנה ביומן של Go, ‏ slog. בדוגמת הקוד הבאה מוצגת הפונקציה setupLogging, שמופעלת מהפונקציה main:

func setupLogging() {
	// Use json as our base logging format.
	jsonHandler := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{ReplaceAttr: replacer})
	// Add span context attributes when Context is passed to logging calls.
	instrumentedHandler := handlerWithSpanContext(jsonHandler)
	// Set this handler as the global slog handler.
	slog.SetDefault(slog.New(instrumentedHandler))
}

הקוד הקודם קורא לפונקציה handlerWithSpanContext, שמחלצת מידע מהמופע Context ומוסיפה את המידע הזה כמאפיינים ליומן. אחר כך אפשר להשתמש במאפיינים האלה כדי ליצור קורלציה בין יומן לבין מעקב:

‫logging.googleapis.com/trace: שם המשאב של ה-trace שמשויך לרשומה ביומן.
‫logging.googleapis.com/spanId: מזהה הטווח עם העקבות שמשויך לרשומה ביומן.
‫logging.googleapis.com/trace_sampled: הערך בשדה הזה חייב להיות true או false.

מידע נוסף על השדות האלה זמין במאמר בנושא LogEntry.

func handlerWithSpanContext(handler slog.Handler) *spanContextLogHandler {
	return &spanContextLogHandler{Handler: handler}
}

// spanContextLogHandler is a slog.Handler which adds attributes from the
// span context.
type spanContextLogHandler struct {
	slog.Handler
}

// Handle overrides slog.Handler's Handle method. This adds attributes from the
// span context to the slog.Record.
func (t *spanContextLogHandler) Handle(ctx context.Context, record slog.Record) error {
	// Get the SpanContext from the context.
	if s := trace.SpanContextFromContext(ctx); s.IsValid() {
		// Add trace context attributes following Cloud Logging structured log format described
		// in https://cloud.google.com/logging/docs/structured-logging#special-payload-fields
		record.AddAttrs(
			slog.Any("logging.googleapis.com/trace", s.TraceID()),
		)
		record.AddAttrs(
			slog.Any("logging.googleapis.com/spanId", s.SpanID()),
		)
		record.AddAttrs(
			slog.Bool("logging.googleapis.com/trace_sampled", s.TraceFlags().IsSampled()),
		)
	}
	return t.Handler.Handle(ctx, record)
}

func replacer(groups []string, a slog.Attr) slog.Attr {
	// Rename attribute keys to match Cloud Logging structured log format
	switch a.Key {
	case slog.LevelKey:
		a.Key = "severity"
		// Map slog.Level string values to Cloud Logging LogSeverity
		// https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#LogSeverity
		if level := a.Value.Any().(slog.Level); level == slog.LevelWarn {
			a.Value = slog.StringValue("WARNING")
		}
	case slog.TimeKey:
		a.Key = "timestamp"
	case slog.MessageKey:
		a.Key = "message"
	}
	return a
}

הוספת אינסטרומנטציה לשרת ה-HTTP

כדי להוסיף אינסטרומנטציה של מעקב ומדדים לבקשות שמטופלות על ידי שרת ה-HTTP, משתמשים ב-OpenTelemetry. בדוגמה הבאה נעשה שימוש ב-handler‏ otelhttp כדי להעביר הקשר, וכדי לבצע אינסטרומנטציה של מעקב ומדדים:

func runServer() error {
	handleHTTP("/single", handleSingle)
	handleHTTP("/multi", handleMulti)

	return http.ListenAndServe(":8080", nil)
}

// handleHTTP handles the http HandlerFunc on the specified route, and uses
// otelhttp for context propagation, trace instrumentation, and metric
// instrumentation.
func handleHTTP(route string, handleFn http.HandlerFunc) {
	instrumentedHandler := otelhttp.NewHandler(otelhttp.WithRouteTag(route, handleFn), route)

	http.Handle(route, instrumentedHandler)
}

בקוד הקודם, הפונקציה לטיפול באירוע otelhttp משתמשת במופעים הגלובליים TracerProvider,‏ MeterProvider ו-TextMapPropagator. הפונקציה setupOpenTelemetry מגדירה את המקרים האלה.

קישור של טווחים של מעקב אחר קישורים ליומנים ולמדדים

כדי לקשר בין טווחי שרת ולקוח, ולשייך מדדים ויומנים, מעבירים את מופע Go Context לבקשת ה-HTTP ולכתיבת היומנים. בדוגמה הבאה מוצג handler של נתיב שמחלץ את מופע Context של Go ומעביר את המופע הזה ל-logger ולפונקציה callSingle, שיוצרת בקשת HTTP יוצאת:

func handleMulti(w http.ResponseWriter, r *http.Request) {
	subRequests := 3 + rand.Intn(4)
	// Write a structured log with the request context, which allows the log to
	// be linked with the trace for this request.
	slog.InfoContext(r.Context(), "handle /multi request", slog.Int("subRequests", subRequests))

	err := computeSubrequests(r, subRequests)
	if err != nil {
		http.Error(w, err.Error(), http.StatusBadGateway)
		return
	}

	fmt.Fprintln(w, "ok")
}

בדוגמה הקודמת, קריאה לפונקציה r.Context() מאחזרת את Go Context מבקשת ה-HTTP.

הוספת אינסטרומנטציה ללקוח HTTP

כדי להוסיף את הקשר של המעקב לבקשות HTTP יוצאות וכדי להוסיף מעקב ומדדים, קוראים לפונקציה otelhttp.Get. בדוגמה הבאה, הפונקציה callSingle מבצעת את הפעולה הזו:

func callSingle(ctx context.Context) error {
	// otelhttp.Get makes an http GET request, just like net/http.Get.
	// In addition, it records a span, records metrics, and propagates context.
	res, err := otelhttp.Get(ctx, "http://localhost:8080/single")
	if err != nil {
		return err
	}

	return res.Body.Close()
}

כתיבת יומנים מובנים

כדי לכתוב יומנים מובנים שמקושרים למעקב, משתמשים בחבילת הרישום המובנה של Go‏, slog, ומעבירים את מופע Go‏ Context ל-logger. נדרש מופע של Go Context כשרוצים לקשר יומן לטווח. לדוגמה, ההצהרה הבאה מראה איך להפעיל את המתודה InfoContext עבור slog, ומדגימה איך להוסיף את השדה subRequests למופע JSON:

slog.InfoContext(r.Context(), "handle /multi request", slog.Int("subRequests", subRequests))

הפעלת אפליקציה לדוגמה שהוגדרה לאיסוף טלמטריה

האינסטרומנטציה באפליקציית הדוגמה משתמשת בפורמטים ניטרליים לספקים, כמו JSON לנתוני יומן ו-OTLP לנתוני מדדים ולנתוני מעקב. ‫OpenTelemetry Collector שולח נתוני יומן ומדדים לפרויקט באמצעות כלי ייצוא של Google. הוא שולח את נתוני המעקב לפרויקט שלכם באמצעות Telemetry API, שמשתמש ב-OTLP. מחולל העומסים באפליקציה שולח בקשות למסלולים של האפליקציה.

הורדה ופריסה של האפליקציה

כדי להריץ את הדוגמה:

במסוף Google Cloud , מפעילים את Cloud Shell.

הפעלת Cloud Shell

בחלק התחתון של Google Cloud המסוף יתחיל סשן של Cloud Shell ותופיע הודעה של שורת הפקודה. Cloud Shell היא סביבת מעטפת שבה ה-CLI של Google Cloud מותקן ומוגדרים ערכים לפרויקט הקיים. הסשן יופעל תוך כמה שניות.

משכפלים את המאגר:

git clone https://github.com/GoogleCloudPlatform/golang-samples

עוברים לספרייה OpenTelemetry:

cd golang-samples/opentelemetry/instrumentation

מפתחים ומריצים את הדוגמה:
```
docker compose up --abort-on-container-exit
```
אם אתם לא מריצים את האפליקציה ב-Cloud Shell, אתם צריכים להריץ אותה עם משתנה הסביבה GOOGLE_APPLICATION_CREDENTIALS שמצביע על קובץ פרטי הכניסה. ‫Application Default Credentials‏ (ADC) מספק קובץ פרטי כניסה בנתיב $HOME/.config/gcloud/application_default_credentials.json.
```
# Set environment variables
export GOOGLE_CLOUD_PROJECT="PROJECT_ID"
export GOOGLE_APPLICATION_CREDENTIALS="$HOME/.config/gcloud/application_default_credentials.json"
export USERID="$(id -u)"

# Run
docker compose -f docker-compose.yaml -f docker-compose.creds.yaml up --abort-on-container-exit
```

הצגת המדדים

האינסטרומנטציה של OpenTelemetry באפליקציית הדוגמה יוצרת מדדים של Prometheus שאפשר לראות באמצעות Metrics Explorer:

Prometheus/http_server_duration_milliseconds/histogram מתעד את משך הזמן של בקשות לשרת ומאחסן את התוצאות בהיסטוגרמה.
Prometheus/http_client_duration_milliseconds/histogram מתעד את משך הזמן של בקשות הלקוח ומאחסן את התוצאות בהיסטוגרמה.
‫Prometheus/http_server_response_size_bytes_total/counter מתעד את אורך גודל התגובה עבור נתיבי ה-HTTP‏ /multi ו-/single. הערכים של המדד הזה הם מצטברים, כלומר כל ערך מייצג את הסכום הכולל מאז שהתחיל איסוף הערכים.

כדי לראות את המדדים שנוצרו על ידי האפליקציה לדוגמה:

נכנסים לדף Metrics explorer במסוף Google Cloud :
כניסה אל Metrics Explorer

אם משתמשים בסרגל החיפוש כדי למצוא את הדף הזה, בוחרים בתוצאה שבה הכותרת המשנית היא Monitoring.
בסרגל הכלים של מסוף Google Cloud , בוחרים את Google Cloud הפרויקט. בהגדרות של מרכז האפליקציות, בוחרים את הפרויקט המארח של מרכז האפליקציות או את פרויקט הניהול של התיקייה לניהול אפליקציות.
ברכיב Metric, מרחיבים את התפריט Select a metric, כותבים http_server בשורת הסינון ומשתמשים בתפריטי המשנה כדי לבחור סוג ספציפי של משאב ומדד:
1. בתפריט Active resources בוחרים באפשרות Prometheus Target.
2. בתפריט Active metric categories בוחרים באפשרות Http.
3. בתפריט Active metrics בוחרים מדד.
4. לוחצים על אישור.
כדי להוסיף מסננים שמסירים סדרות זמן מתוצאות השאילתה, משתמשים ברכיב Filter.
מגדירים את אופן התצוגה של הנתונים.
כשמדובר במדדים מצטברים, הכלי 'Metrics Explorer' מבצע נורמליזציה אוטומטית של הנתונים שנמדדו לפי תקופת ההתאמה, וכתוצאה מכך מוצג בתרשים קצב. מידע נוסף זמין במאמר סוגים, סוגים והמרות.

כשמודדים ערכים מסוג integer או double, כמו שני המדדים counter, הכלי Metrics Explorer מסכם באופן אוטומטי את כל סדרות הזמנים. כדי לראות את הנתונים של נתיבי ה-HTTP‏ /multi ו-/single, מגדירים את התפריט הראשון של הרשומה Aggregation לערך None.

מידע נוסף על הגדרת תרשים זמין במאמר איך בוחרים מדדים כשמשתמשים ב-Metrics Explorer.

הצגת העקבות

יכול להיות שיעברו כמה דקות עד שנתוני המעקב יהיו זמינים. לדוגמה, כשנתוני מעקב מתקבלים בפרויקט, יכול להיות ש-Google Cloud Observability יצטרך ליצור מסד נתונים כדי לאחסן את הנתונים האלה. יצירת מסד הנתונים יכולה להימשך כמה דקות, ובמהלך התקופה הזו לא ניתן לראות נתוני מעקב.

כדי להציג את נתוני העקבות:

נכנסים לדף Trace explorer במסוף Google Cloud :
כניסה אל Trace explorer

אפשר גם להשתמש בסרגל החיפוש כדי למצוא את הדף הזה.
בקטע הטבלה בדף, בוחרים שורה עם שם הטווח /multi.
בתרשים גאנט בחלונית Trace details, בוחרים בטווח שנקרא /multi.

תיפתח חלונית עם מידע על בקשת ה-HTTP. הפרטים האלה כוללים את השיטה, קוד הסטטוס, מספר הבייטים וסוכן המשתמש של המתקשר.
כדי לראות את היומנים שמשויכים למעקב הזה, בוחרים בכרטיסייה יומנים ואירועים.

בכרטיסייה מוצגים יומנים בודדים. כדי לראות את הפרטים של הרשומה ביומן, מרחיבים את הרשומה. אפשר גם ללחוץ על הצגת יומנים כדי לראות את היומן באמצעות Logs Explorer.

מידע נוסף על השימוש בכלי Cloud Trace Explorer זמין במאמר חיפוש עקבות ועיון בהם.

הצגת רישומי היומן

בכלי Logs Explorer אפשר לבדוק את היומנים, וגם לראות את העקבות המשויכים, אם הם קיימים.

במסוף Google Cloud , נכנסים לדף Logs Explorer:
כניסה אל Logs Explorer

אם משתמשים בסרגל החיפוש כדי למצוא את הדף הזה, בוחרים בתוצאה שכותרת המשנה שלה היא Logging.
מאתרים יומן עם התיאור של handle /multi request.

כדי לראות את פרטי היומן, מרחיבים את הרשומה ביומן. בשדה jsonPayload, יש רשומה עם התווית subRequests. הערך הזה נוסף על ידי הצהרה בפונקציה handleMulti.
לוחצים על Traces (עקבות) ברשומה ביומן עם ההודעה handle /multi request (טיפול בבקשה מרובה), ואז בוחרים באפשרות View trace details (הצגת פרטי העקבות).

נפתחת חלונית Trace details ומוצג בה ה-Trace שנבחר.

יכול להיות שנתוני היומן יהיו זמינים כמה דקות לפני שנתוני המעקב יהיו זמינים. אם נתקלתם בשגיאה כשניסיתם להציג נתוני מעקב, בין אם חיפשתם מעקב לפי מזהה או ביצעתם את השלבים במשימה הזו, המתינו דקה או שתיים ונסו שוב לבצע את הפעולה.

מידע נוסף על השימוש ב-Logs Explorer מופיע במאמר הצגת יומנים באמצעות Logs Explorer.