Luca Wintergerst

使用 OpenTelemetry 手动监控 Go 应用程序

在这篇博文中，我们将向您展示如何使用 OpenTelemetry 手动监控 Go 应用程序。我们将探讨如何使用合适的 OpenTelemetry Go 包，特别是如何在 Go 应用程序中进行追踪监控。

阅读时间：14分钟
OpenTelemetryAPM监控
Manual instrumentation of Go applications with OpenTelemetry

DevOps 和 SRE 团队正在改变软件开发流程。DevOps 工程师专注于高效的软件应用程序和服务交付，而 SRE 团队则是确保可靠性、可扩展性和性能的关键。这些团队必须依靠全栈可观测性解决方案来管理和监控系统，并确保在问题影响业务之前解决问题。

对整个现代分布式应用程序堆栈进行可观测性需要数据收集、处理和关联，通常以仪表盘的形式呈现。摄取所有系统数据需要跨堆栈、框架和提供商安装代理——对于必须处理版本更改、兼容性问题和无法随着系统更改而扩展的专有代码的团队来说，这是一个可能具有挑战性和耗时的过程。

由于有了 OpenTelemetry (OTel)，DevOps 和 SRE 团队现在有了一种标准的方法来收集和发送数据，这种方法不依赖于专有代码，并且拥有庞大的支持社区，从而减少了供应商锁定。

在这篇博文中，我们将向您展示如何使用 OpenTelemetry 手动监控 Go 应用程序。这种方法比使用自动监控略微复杂一些。

在之前的 博文 中，我们还回顾了如何使用 OpenTelemetry 演示并将其连接到 Elastic®，以及 Elastic 在 OpenTelemetry 中的一些功能。在本博文中，我们将使用 另一种演示应用程序，它有助于以简单的方式突出手动监控。

最后，我们将讨论 Elastic 如何支持混合模式应用程序，这些应用程序与 Elastic 和 OpenTelemetry 代理一起运行。其优点在于**不需要 otel-collector**！此设置使您可以根据最适合您业务的时间表，缓慢而轻松地将应用程序迁移到使用 Elastic 的 OTel。

应用程序、先决条件和配置

我们在这篇博文中使用的应用程序称为 Elastiflix，一个电影流媒体应用程序。它由几个用 .NET、NodeJS、Go 和 Python 编写的微服务组成。

在我们监控示例应用程序之前，我们首先需要了解 Elastic 如何接收遥测数据。

Elastic Observability 的所有 APM 功能都可用于 OTel 数据。其中一些包括：

  • 服务地图
  • 服务详情（延迟、吞吐量、失败事务）
  • 服务之间的依赖关系，分布式追踪
  • 事务（追踪）
  • 机器学习 (ML) 关联
  • 日志关联

除了 Elastic 的 APM 和统一的遥测数据视图之外，您还可以使用 Elastic 的强大机器学习功能来减少分析，并发出警报以帮助减少 MTTR。

先决条件

查看示例源代码

完整的源代码（包括本博文中使用的 Dockerfile）可以在 GitHub 上找到。该存储库还包含 没有监控的相同应用程序。这使您可以比较每个文件并查看差异。

在我们开始之前，让我们先看看未经监控的代码。

这是一个简单的 Go 应用程序，可以接收 GET 请求。请注意，此处显示的代码是略微简短的版本。

package main

import (
	"log"
	"net/http"
	"os"
	"time"

	"github.com/go-redis/redis/v8"

	"github.com/sirupsen/logrus"

	"github.com/gin-gonic/gin"
	"strconv"
	"math/rand"
)

var logger = &logrus.Logger{
	Out:   os.Stderr,
	Hooks: make(logrus.LevelHooks),
	Level: logrus.InfoLevel,
	Formatter: &logrus.JSONFormatter{
		FieldMap: logrus.FieldMap{
			logrus.FieldKeyTime:  "@timestamp",
			logrus.FieldKeyLevel: "log.level",
			logrus.FieldKeyMsg:   "message",
			logrus.FieldKeyFunc:  "function.name", // non-ECS
		},
		TimestampFormat: time.RFC3339Nano,
	},
}

func main() {
	delayTime, _ := strconv.Atoi(os.Getenv("TOGGLE_SERVICE_DELAY"))

	redisHost := os.Getenv("REDIS_HOST")
	if redisHost == "" {
		redisHost = "localhost"
	}

	redisPort := os.Getenv("REDIS_PORT")
	if redisPort == "" {
		redisPort = "6379"
	}

	applicationPort := os.Getenv("APPLICATION_PORT")
	if applicationPort == "" {
		applicationPort = "5000"
	}

	// Initialize Redis client
	rdb := redis.NewClient(&redis.Options{
		Addr:     redisHost + ":" + redisPort,
		Password: "",
		DB:       0,
	})

	// Initialize router
	r := gin.New()
	r.Use(logrusMiddleware)

	r.GET("/favorites", func(c *gin.Context) {
		// artificial sleep for delayTime
		time.Sleep(time.Duration(delayTime) * time.Millisecond)

		userID := c.Query("user_id")

		contextLogger(c).Infof("Getting favorites for user %q", userID)

		favorites, err := rdb.SMembers(c.Request.Context(), userID).Result()
		if err != nil {
			contextLogger(c).Error("Failed to get favorites for user %q", userID)
			c.String(http.StatusInternalServerError, "Failed to get favorites")
			return
		}

		contextLogger(c).Infof("User %q has favorites %q", userID, favorites)

		c.JSON(http.StatusOK, gin.H{
			"favorites": favorites,
		})
	})

	// Start server
	logger.Infof("App startup")
	log.Fatal(http.ListenAndServe(":"+applicationPort, r))
	logger.Infof("App stopped")
}

分步指南

步骤 0. 登录您的 Elastic Cloud 帐户

本博文假设您拥有 Elastic Cloud 帐户 — 如果没有，请按照 说明在 Elastic Cloud 上开始使用。

步骤 1. 安装和初始化 OpenTelemetry

第一步，我们需要向应用程序添加一些额外的包。

import (
      "github.com/go-redis/redis/extra/redisotel/v8"
      "go.opentelemetry.io/otel"
      "go.opentelemetry.io/otel/attribute"
      "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"

	"go.opentelemetry.io/otel/propagation"

	"google.golang.org/grpc/credentials"
	"crypto/tls"

      sdktrace "go.opentelemetry.io/otel/sdk/trace"

	"go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"

	"go.opentelemetry.io/otel/trace"
	"go.opentelemetry.io/otel/codes"
)

此代码导入了必要的 OpenTelemetry 包，包括用于追踪、导出和监控特定库（如 Redis）的包。

接下来，我们读取“OTEL_EXPORTER_OTLP_ENDPOINT”变量并初始化导出器。

var (
    collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
)
var tracer trace.Tracer


func initTracer() func(context.Context) error {
	tracer = otel.Tracer("go-favorite-otel-manual")

	// remove https:// from the collector URL if it exists
	collectorURL = strings.Replace(collectorURL, "https://", "", 1)
	secretToken := os.Getenv("ELASTIC_APM_SECRET_TOKEN")
	if secretToken == "" {
		log.Fatal("ELASTIC_APM_SECRET_TOKEN is required")
	}

	secureOption := otlptracegrpc.WithInsecure()
    exporter, err := otlptrace.New(
        context.Background(),
        otlptracegrpc.NewClient(
            secureOption,
            otlptracegrpc.WithEndpoint(collectorURL),
			otlptracegrpc.WithHeaders(map[string]string{
				"Authorization": "Bearer " + secretToken,
			}),
			otlptracegrpc.WithTLSCredentials(credentials.NewTLS(&tls.Config{})),
        ),
    )

    if err != nil {
        log.Fatal(err)
    }

    otel.SetTracerProvider(
        sdktrace.NewTracerProvider(
            sdktrace.WithSampler(sdktrace.AlwaysSample()),
            sdktrace.WithBatcher(exporter),
        ),
    )
	otel.SetTextMapPropagator(
		propagation.NewCompositeTextMapPropagator(
			propagation.Baggage{},
			propagation.TraceContext{},
		),
	)
    return exporter.Shutdown
}

为了监控与 Redis 的连接，我们将向其添加一个追踪钩子，为了监控 Gin，我们将添加 OTel 中间件。这将自动捕获与我们应用程序的所有交互，因为 Gin 将被完全监控。此外，所有传出的 Redis 连接也将被监控。

// Initialize Redis client
	rdb := redis.NewClient(&redis.Options{
		Addr:     redisHost + ":" + redisPort,
		Password: "",
		DB:       0,
	})
	rdb.AddHook(redisotel.NewTracingHook())
	// Initialize router
	r := gin.New()
	r.Use(logrusMiddleware)
	r.Use(otelgin.Middleware("go-favorite-otel-manual"))

添加自定义跨度
现在我们已经添加并初始化了所有内容，我们可以添加自定义跨度。

如果我们希望对应用程序的一部分进行额外的监控，我们只需启动一个自定义跨度，然后延迟结束该跨度。

// start otel span
ctx := c.Request.Context()
ctx, span := tracer.Start(ctx, "add_favorite_movies")
defer span.End()

为了进行比较，这是我们示例应用程序的已监控代码。您可以在 GitHub 上找到完整的源代码。

package main

import (
	"log"
	"net/http"
	"os"
	"time"
	"context"

	"github.com/go-redis/redis/v8"
	"github.com/go-redis/redis/extra/redisotel/v8"


	"github.com/sirupsen/logrus"

	"github.com/gin-gonic/gin"

  "go.opentelemetry.io/otel"
  "go.opentelemetry.io/otel/attribute"
  "go.opentelemetry.io/otel/exporters/otlp/otlptrace"
  "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"

	"go.opentelemetry.io/otel/propagation"

	"google.golang.org/grpc/credentials"
	"crypto/tls"

  sdktrace "go.opentelemetry.io/otel/sdk/trace"

	"go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin"

	"go.opentelemetry.io/otel/trace"

	"strings"
	"strconv"
	"math/rand"
	"go.opentelemetry.io/otel/codes"

)

var tracer trace.Tracer

func initTracer() func(context.Context) error {
	tracer = otel.Tracer("go-favorite-otel-manual")

	collectorURL = strings.Replace(collectorURL, "https://", "", 1)

	secureOption := otlptracegrpc.WithInsecure()

	// split otlpHeaders by comma and convert to map
	headers := make(map[string]string)
	for _, header := range strings.Split(otlpHeaders, ",") {
		headerParts := strings.Split(header, "=")

		if len(headerParts) == 2 {
			headers[headerParts[0]] = headerParts[1]
		}
	}

    exporter, err := otlptrace.New(
        context.Background(),
        otlptracegrpc.NewClient(
            secureOption,
            otlptracegrpc.WithEndpoint(collectorURL),
			otlptracegrpc.WithHeaders(headers),
			otlptracegrpc.WithTLSCredentials(credentials.NewTLS(&tls.Config{})),
        ),
    )

    if err != nil {
        log.Fatal(err)
    }

    otel.SetTracerProvider(
        sdktrace.NewTracerProvider(
            sdktrace.WithSampler(sdktrace.AlwaysSample()),
            sdktrace.WithBatcher(exporter),
            //sdktrace.WithResource(resources),
        ),
    )
	otel.SetTextMapPropagator(
		propagation.NewCompositeTextMapPropagator(
			propagation.Baggage{},
			propagation.TraceContext{},
		),
	)
    return exporter.Shutdown
}

var (
  collectorURL = os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
	otlpHeaders = os.Getenv("OTEL_EXPORTER_OTLP_HEADERS")
)


var logger = &logrus.Logger{
	Out:   os.Stderr,
	Hooks: make(logrus.LevelHooks),
	Level: logrus.InfoLevel,
	Formatter: &logrus.JSONFormatter{
		FieldMap: logrus.FieldMap{
			logrus.FieldKeyTime:  "@timestamp",
			logrus.FieldKeyLevel: "log.level",
			logrus.FieldKeyMsg:   "message",
			logrus.FieldKeyFunc:  "function.name", // non-ECS
		},
		TimestampFormat: time.RFC3339Nano,
	},
}

func main() {
	cleanup := initTracer()
  defer cleanup(context.Background())

	redisHost := os.Getenv("REDIS_HOST")
	if redisHost == "" {
		redisHost = "localhost"
	}

	redisPort := os.Getenv("REDIS_PORT")
	if redisPort == "" {
		redisPort = "6379"
	}

	applicationPort := os.Getenv("APPLICATION_PORT")
	if applicationPort == "" {
		applicationPort = "5000"
	}

	// Initialize Redis client
	rdb := redis.NewClient(&redis.Options{
		Addr:     redisHost + ":" + redisPort,
		Password: "",
		DB:       0,
	})
	rdb.AddHook(redisotel.NewTracingHook())


	// Initialize router
	r := gin.New()
	r.Use(logrusMiddleware)
	r.Use(otelgin.Middleware("go-favorite-otel-manual"))


	// Define routes
	r.GET("/", func(c *gin.Context) {
		contextLogger(c).Infof("Main request successful")
		c.String(http.StatusOK, "Hello World!")
	})

	r.GET("/favorites", func(c *gin.Context) {
		// artificial sleep for delayTime
		time.Sleep(time.Duration(delayTime) * time.Millisecond)

		userID := c.Query("user_id")

		contextLogger(c).Infof("Getting favorites for user %q", userID)

		favorites, err := rdb.SMembers(c.Request.Context(), userID).Result()
		if err != nil {
			contextLogger(c).Error("Failed to get favorites for user %q", userID)
			c.String(http.StatusInternalServerError, "Failed to get favorites")
			return
		}

		contextLogger(c).Infof("User %q has favorites %q", userID, favorites)

		c.JSON(http.StatusOK, gin.H{
			"favorites": favorites,
		})
	})

	// Start server
	logger.Infof("App startup")
	log.Fatal(http.ListenAndServe(":"+applicationPort, r))
	logger.Infof("App stopped")
}

步骤 2. 使用环境变量运行 Docker 镜像

如 OTEL 文档 中所述，我们将使用环境变量并传入在 APM 代理的配置部分中找到的配置值。

因为 Elastic 原生支持 OTLP，我们只需要提供 OTEL 导出器需要发送数据的端点和身份验证，以及其他一些环境变量。

**在 Elastic Cloud 和 Kibana® 中获取这些变量的位置**
您可以从 Kibana 的 /app/home#/tutorial/apm 路径下复制端点和令牌。

您需要复制 OTEL_EXPORTER_OTLP_ENDPOINT 和 OTEL_EXPORTER_OTLP_HEADERS。

构建镜像

docker build -t  go-otel-manual-image .

运行镜像

docker run \
       -e OTEL_EXPORTER_OTLP_ENDPOINT="<REPLACE WITH OTEL_EXPORTER_OTLP_ENDPOINT>" \
       -e OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer <REPLACE WITH TOKEN>" \
       -e OTEL_RESOURCE_ATTRIBUTES="service.version=1.0,deployment.environment=production,service.name=go-favorite-otel-manual" \
       -p 5000:5000 \
       go-otel-manual-image

您现在可以发出一些请求以生成追踪数据。请注意，这些请求预计会返回错误，因为此服务依赖于您当前未运行的 Redis 连接。如前所述，您可以在这里找到使用 Docker compose 的更完整的示例 here。

curl localhost:500/favorites
# or alternatively issue a request every second

while true; do curl "localhost:5000/favorites"; sleep 1; done;

追踪如何在 Elastic 中显示？

现在服务已得到监控，当查看 Node.js 服务的事务部分时，您应该在 Elastic APM 中看到以下输出。

结论

在这篇博文中，我们讨论了以下内容：

  • 如何使用 OpenTelemetry 手动监控 Go
  • 如何正确初始化 OpenTelemetry 并添加自定义跨度
  • 如何在无需收集器的情况下轻松设置带有 Elastic 的 OTLP ENDPOINT 和 OTLP HEADERS

希望这能提供一个易于理解的使用 OpenTelemetry 监控 Go 的过程，以及将追踪发送到 Elastic 的简易性。

开发者资源

通用配置和用例资源

还没有 Elastic Cloud 帐户？注册 Elastic Cloud 并试用上面讨论的自动追踪功能。我很乐意听取您使用 Elastic 提升应用程序堆栈可见性方面的体验反馈。

本文中描述的任何功能或功能的发布和时间安排完全由 Elastic 决定。任何目前不可用的功能或功能可能无法按时或根本无法交付。

分享此文章

XFacebookLinkedInReddit