Send Logs from Zap to SigNoz

This guide explains how to forward logs from Zap to SigNoz.

Requirements

Go Modules: Ensure your project is using the following Go modules.

go get go.opentelemetry.io/contrib/bridges/otelzap
go get go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp
go get go.uber.org/zap

We import the required packages:

otelzap: The bridge for Zap logger to work with OpenTelemetry.
otlploghttp: The OTLP exporter for logs over HTTP.
zap: The high-performance logging library.

Define Endpoint and Access Token

You need to provide

otlpEndpoint: The URL of your SigNoz Cloud OTLP collector endpoint.
accessToken: The token required to authenticate against SigNoz Cloud. This is typically provided in your account dashboard.

otlpEndpoint := "<signoz-client-url>"
accessToken := "<my-access-token>"

Create HTTP Headers for Authorization

To send data securely to the SigNoz Cloud, the access token is included in the Authorization header

headers := map[string]string{
	"Authorization": "Bearer " + accessToken,
}

Create Exporter

ctx := context.Background()
exporter, err := otlploghttp.New(ctx,
	otlploghttp.WithEndpoint(otlpEndpoint),
	otlploghttp.WithHeaders(headers),
)
if err != nil {
	fmt.Println(err)
}

Here, we create an OTLP HTTP exporter. This is responsible for exporting log records to an OTLP endpoint (like the OpenTelemetry collector).

Log Processor

processor := log.NewBatchProcessor(exporter)

A batch processor is used to efficiently group and export log records. The processor ensures that log records are buffered and sent in batches to the OTLP endpoint.

Logger Provider

provider := log.NewLoggerProvider(
	log.WithProcessor(processor),
)

defer func() {
	err := provider.Shutdown(context.Background())
	if err != nil {
		fmt.Println(err)
	}
}()

The LoggerProvider serves as the core log provider, which connects the log pipeline (processor) to the Zap logger. This ensures that logs generated by your application will pass through OpenTelemetry’s logging mechanisms.

It's important to properly shut down the LoggerProvider to ensure that no logs are left unprocessed before the application exits.

Zap Logger Initialisation

logger := zap.New(otelzap.NewCore("my/pkg/name", otelzap.WithLoggerProvider(provider)))
defer logger.Sync()

We initialise a Zap logger, but instead of using Zap’s native logging core, we create an OpenTelemetry-based core (otelzap.NewCore). This core connects Zap’s logging functionality to the OpenTelemetry log pipeline, ensuring logs are exported.

"my/pkg/name": Specifies the package name or source of the logs, useful for debugging.
otelzap.WithLoggerProvider(provider): Connects the previously created OpenTelemetry LoggerProvider.

Logging Messages

logger.Info("something really cool")

The logger.Info method logs messages. In this example, instead of writing logs to standard output, they are sent to the OTLP endpoint.

Trace With Context

logger.Info("setting context", zap.Any("context", ctx))

You can include the context for more contextual tracing of the log messages

logging.go

package logging

import (
	"context"
	"fmt"

	"go.opentelemetry.io/contrib/bridges/otelzap"
	"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp"
	"go.opentelemetry.io/otel/sdk/log"
	"go.uber.org/zap"
)

func Example() {

	otlpEndpoint := "<signoz-client-url>"
	accessToken := "<my-access-token>"
	ctx := context.Background()

	headers := map[string]string{
		"Authorization": "Bearer " + accessToken,
	}

	// Create an exporter that will emit log records.
	exporter, err := otlploghttp.New(ctx,
		otlploghttp.WithEndpoint(otlpEndpoint),
		otlploghttp.WithHeaders(headers),
	)
	if err != nil {
		fmt.Println(err)
	}
	// Create a log record processor pipeline.
	processor := log.NewBatchProcessor(exporter)

	// Create a logger provider.
	// You can pass this instance directly when creating a log bridge.
	provider := log.NewLoggerProvider(
		log.WithProcessor(processor),
	)

	defer func() {
		err := provider.Shutdown(context.Background())
		if err != nil {
			fmt.Println(err)
		}
	}()

	// Initialize a zap logger with the otelzap bridge core.
	logger := zap.New(otelzap.NewCore("my/pkg/name", otelzap.WithLoggerProvider(provider)))
	defer logger.Sync()

	// You can now use your logger in your code.
	logger.Info("something really cool")

	// You can set context for trace correlation using zap.Any or zap.Reflect
	logger.Info("setting context", zap.Any("context", ctx))

	logger.Info("Hello from Zap logger!")
}