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

אתם יכולים להוסיף לאפליקציית Go אינסטרומנטציה כדי לאסוף נתוני מעקב ומדדים באמצעות ה-SDK של OpenTelemetry ומאגר OpenTelemetry, ולכתוב יומני JSON מובְנים ומתואמים לפלט סטנדרטי (stdout) באמצעות חבילת slog של Go. כדי להתנסות בכלים האלה, אתם יכולים להוריד ולהריץ את אפליקציית Go לדוגמה, שיוצרת נתוני יומנים, מדדים ומעקב ומייצאת אותם לפרויקט ב-Google Cloud .

מידע על גישת המדידה

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

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

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

• תצפיתיות למפתחי אפליקציות
• בחירת גישה למדידה

מידע על ההקשר

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

• הקשר מתייחס למנגנון להפצת ערכים ברמת הביצוע, כולל הטווח הפעיל הנוכחי, בין ממשקי API בתוך תהליך.

• Span Context הוא אובייקט שלא ניתן לשינוי בכל span, שכולל את מזהה המעקב, מזהה ה-span, דגלים ומצב המעקב.

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

גם context.Context של ספריית Go הרגילה מעביר ערכים מוגדרים מראש מעבר לגבולות ה-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 .

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

• בחירת פרויקט: כדי לבחור פרויקט לא נדרש תפקיד IAM ספציפי – אתם יכולים לבחור כל פרויקט שקיבלתם בו תפקיד.
• יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד "יצירת פרויקטים" (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 ו-Telemetry, אם הם עדיין לא מופעלים:

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

כדי להפעיל ממשקי API, צריך את ההרשאה serviceusage.services.enable. אם אתם יצרתם את הפרויקט, סביר להניח שכבר יש לכם את ההרשאה הזו דרך התפקיד "בעלים" (roles/owner). אחרת, תוכלו לקבל את ההרשאה הזו דרך התפקיד "אדמין בממשק 'שימוש בשירות'" (roles/serviceusage.serviceUsageAdmin). איך מקצים תפקידים

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 .

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

• בחירת פרויקט: כדי לבחור פרויקט לא נדרש תפקיד IAM ספציפי – אתם יכולים לבחור כל פרויקט שקיבלתם בו תפקיד.
• יצירת פרויקט: כדי ליצור פרויקט, צריך את התפקיד "יצירת פרויקטים" (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 ו-Telemetry, אם הם עדיין לא מופעלים:

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

כדי להפעיל ממשקי API, צריך את ההרשאה serviceusage.services.enable. אם אתם יצרתם את הפרויקט, סביר להניח שכבר יש לכם את ההרשאה הזו דרך התפקיד "בעלים" (roles/owner). אחרת, תוכלו לקבל את ההרשאה הזו דרך התפקיד "אדמין בממשק 'שימוש בשירות'" (roles/serviceusage.serviceUsageAdmin). איך מקצים תפקידים

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

1. כדי לקבל את ההרשאות שדרושות בשביל שאפליקציית הדוגמה תכתוב נתוני יומנים, מדדים ומעקב, אתם צריכים לבקש מהאדמין לתת לכם את התפקידים הבאים ב-IAM:

   • כתיבה ביומן (roles/logging.logWriter) בפרויקט
   • כתיבת מדדי מעקב (roles/monitoring.metricWriter) בפרויקט
   • כתיבת נתוני מעקב של Cloud Telemetry (roles/telemetry.tracesWriter) בפרויקט
   • Service Usage Consumer (roles/serviceusage.serviceUsageConsumer) בפרויקט המכסה

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

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

   כדי לקבל את ההרשאות שדרושות לצפייה בנתוני היומנים, המדדים והמעקב, בקשו מהאדמין להקצות לכם את תפקידי ה-IAM הבאים בפרויקט:

   • צפייה ביומנים (roles/logging.viewer)
   • צפייה במעקב (roles/monitoring.viewer)
   • Cloud Trace User (roles/cloudtrace.user)

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

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

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

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

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

1. הגדרת הפונקציה הראשית
2. הגדרת OpenTelemetry
3. הגדרת רישום ביומן של נתונים מובְנים
4. הוספת אינסטרומנטציה לשרת ה-HTTP
5. קישור בין טווחי מעקב לבין יומנים ומדדים
6. הוספת אינסטרומנטציה לצד הלקוח ב-HTTP
7. כתיבת יומנים מובְנים

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

כדי להגדיר את האפליקציה לכתוב יומנים מובְנים ולאסוף מדדים ונתוני מעקב באמצעות 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 ל-logger. מידע נוסף מופיע בקטע כתיבת יומנים מובְנים במאמר הזה.

הגדרת 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: שם המשאב של המעקב שמשויך לרשומת היומן.
• ‫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)
}

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

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

כדי לקשר בין ה-spans של השרת והלקוח ולשייך מדדים ויומנים, מעבירים את המכונה של Go Context לבקשת ה-HTTP ול-logger. בדוגמה הבאה מוצג handler של נתיב שמחלץ את המכונה של Go Context, ואז מעביר את המכונה הזו לרושם ביומן ולפונקציה 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() מאחזרת את ה-Context של Go מבקשת ה-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()
}

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

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

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

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

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

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

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

הערה: מומלץ להריץ את האפליקציה לדוגמה באמצעות Cloud Shell. עם זאת, אם אתם רוצים להריץ את האפליקציה לדוגמה באופן מקומי ב-Linux או ב-Mac, דלגו על השלב הראשון בהוראות הבאות.

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

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

   הפעלת Cloud Shell

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

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

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

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

   cd golang-samples/opentelemetry/instrumentation
   

4. מפתחים ומריצים את הדוגמה:

   docker compose up --abort-on-container-exit
   

   אם אתם לא מריצים את האפליקציה ב-Cloud Shell, אתם צריכים להריץ אותה כשמשתנה הסביבה GOOGLE_APPLICATION_CREDENTIALS מצביע על קובץ פרטי הכניסה. Application Default Credentials מספק קובץ של פרטי כניסה ב-$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 מתעד את אורך התגובה של הנתיבים /multi ו-/single ב-HTTP. המדידות של המדד הזה הן מצטברות, כלומר כל ערך מייצג את הסכום הכולל מאז שהתחיל איסוף הערכים.

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

1. במסוף Google Cloud , נכנסים לדף  Metrics explorer:

   כניסה לדף Metrics Explorer

   אם אתם משתמשים בשורת החיפוש כדי למצוא את הדף הזה, בחרו בתוצאה שכותרת המשנה שלה היא Monitoring.

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

4. כדי להוסיף מסננים שמסירים סדרות זמנים מתוצאות השאילתה, משתמשים ברכיב Filter.

5. מגדירים את אופן התצוגה של הנתונים.
   

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

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

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

הצגת המעקבים

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

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

1. במסוף Google Cloud , נכנסים לדף Trace explorer:

   כניסה לדף Trace Explorer

   אפשר גם למצוא את הדף הזה באמצעות שורת החיפוש.

2. בקטע הטבלה בדף, בוחרים שורה עם שם ה-span‏ /multi.

3. בתרשים הגאנט שבחלונית Trace details, בוחרים את ה-span שמסומן בתווית /multi.

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

4. כדי לראות את היומנים שמשויכים למעקב הזה, בוחרים בכרטיסייה Logs & Events.

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

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

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

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

1. נכנסים לדף Logs Explorer ב-segment במסוף Google Cloud :

   נכנסים לדף Logs Explorer.

   אם אתם משתמשים בשורת החיפוש כדי למצוא את הדף הזה, בחרו בתוצאה עם כותרת המשנה Logging.

2. מאתרים יומן עם התיאור handle /multi request.

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

3. לוחצים על Traces ברשומת יומן עם ההודעה "handle /multi request", ואז בוחרים באפשרות View trace details.

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

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

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

המאמרים הבאים

• OpenTelemetry
• מפרט OTLP
• רישום מובנה ביומן
• פתרון בעיות בשירות המנוהל ל-Prometheus
• פתרון בעיות ב-Cloud Trace