OpenTelemetry Quickstart

Get your application logs flowing to Sazabi using OpenTelemetry in 5 minutes.

OpenTelemetry is the industry-standard, vendor-neutral way to instrument applications. It works with any platform and any language that has an OpenTelemetry SDK.

Prerequisites

Sazabi account
An application you can add OpenTelemetry to (Node.js, Python, Go, or any language with an OTEL SDK)
Project API key (get one here)

Step 1: Get your Sazabi API key

Log in to Sazabi and go to Settings > API Keys
Click Create API key and select Public as the key type
Copy the key and store it securely (you will not be able to see it again)

Public keys are safe to use in server-side code and are scoped to a single project.

Step 2: Configure OpenTelemetry

Set these environment variables in your application:

OTEL_EXPORTER_OTLP_ENDPOINT=https://otlp.us-west-2.intake.sazabi.com
OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer YOUR_PUBLIC_API_KEY"
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf

Replace YOUR_PUBLIC_API_KEY with the key you created in Step 1.

Step 3: Install the OpenTelemetry SDK

Choose your language and install the required packages:

npm install @opentelemetry/sdk-node @opentelemetry/exporter-logs-otlp-proto @opentelemetry/sdk-logs @opentelemetry/api-logs

Create instrumentation.ts:

import { NodeSDK } from "@opentelemetry/sdk-node";
import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
import { BatchLogRecordProcessor } from "@opentelemetry/sdk-logs";

const logExporter = new OTLPLogExporter({
  url: "https://otlp.us-west-2.intake.sazabi.com/v1/logs",
  headers: {
    Authorization: `Bearer ${process.env.SAZABI_PUBLIC_KEY}`,
  },
});

const sdk = new NodeSDK({
  logRecordProcessors: [new BatchLogRecordProcessor(logExporter)],
});

sdk.start();

Import this file at the start of your application:

import "./instrumentation";
import { logs, SeverityNumber } from "@opentelemetry/api-logs";

const logger = logs.getLogger("my-app");

logger.emit({
  severityNumber: SeverityNumber.INFO,
  severityText: "INFO",
  body: "Application started",
  attributes: { "service.name": "my-app" },
});

pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http

Initialize OpenTelemetry:

import os
import logging
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
from opentelemetry._logs import set_logger_provider

exporter = OTLPLogExporter(
    endpoint="https://otlp.us-west-2.intake.sazabi.com/v1/logs",
    headers={"Authorization": f"Bearer {os.environ.get('SAZABI_PUBLIC_KEY')}"},
)

logger_provider = LoggerProvider()
logger_provider.add_log_record_processor(BatchLogRecordProcessor(exporter))
set_logger_provider(logger_provider)

handler = LoggingHandler(level=logging.INFO, logger_provider=logger_provider)
logging.getLogger().addHandler(handler)
logging.getLogger().setLevel(logging.INFO)

# Now use standard Python logging
logger = logging.getLogger(__name__)
logger.info("Application started", extra={"service.name": "my-app"})

go get go.opentelemetry.io/otel
go get go.opentelemetry.io/otel/sdk/log
go get go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp

Initialize OpenTelemetry:

package main

import (
    "context"
    "log"
    "os"

    "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploghttp"
    sdklog "go.opentelemetry.io/otel/sdk/log"
    "go.opentelemetry.io/otel/log/global"
)

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

    exporter, err := otlploghttp.New(ctx,
        otlploghttp.WithEndpointURL("https://otlp.us-west-2.intake.sazabi.com/v1/logs"),
        otlploghttp.WithHeaders(map[string]string{
            "Authorization": "Bearer " + os.Getenv("SAZABI_PUBLIC_KEY"),
        }),
    )
    if err != nil {
        log.Fatalf("Failed to create exporter: %v", err)
    }

    provider := sdklog.NewLoggerProvider(
        sdklog.WithProcessor(sdklog.NewBatchProcessor(exporter)),
    )
    defer provider.Shutdown(ctx)

    global.SetLoggerProvider(provider)

    logger := global.Logger("my-app")
    // Emit your logs using the logger
}

Step 4: Verify logs are flowing

Run your application and generate some log output. Then verify logs are arriving in Sazabi:

Open a chat thread in Sazabi
Ask: "Show me recent logs" or "What logs came from my-app in the last 5 minutes?"

You should see logs appear in Sazabi within 30 seconds.

OpenTelemetry batches logs for efficiency. If you need logs to appear immediately during testing, call the flush method before your application exits.

Troubleshooting

If logs are not appearing:

Verify your API key is correct and has the Public type
Check that the endpoint URL is https://otlp.<region>.intake.sazabi.com (e.g., https://otlp.us-west-2.intake.sazabi.com)
Ensure the Authorization: Bearer header is being sent with requests
Confirm your application is calling the logger and flushing before exit
Check for 401 errors in your application logs (indicates invalid API key)

Next steps

Set up alerting to get notified about errors
Create a chat thread to investigate issues
Add more data sources to get a complete picture of your stack

OpenTelemetry Quickstart

On this page