Sending Logs

Glintlog accepts logs and traces via the OpenTelemetry Protocol (OTLP). You can send data using either gRPC or HTTP.

Endpoints

Protocol	Port	Endpoint
gRPC	4317	`localhost:4317`
HTTP	4318	`http://localhost:4318/v1/logs`
HTTP	4318	`http://localhost:4318/v1/traces`

Authentication

Log ingestion can optionally require an API key. Include the key in the X-Glintlog-Key header:

curl -X POST http://localhost:4318/v1/logs \
  -H "Content-Type: application/json" \
  -H "X-Glintlog-Key: your-api-key" \
  -d @logs.json

Create API keys through the admin panel or API. See Authentication for details.

OpenTelemetry SDK Configuration

Go

package main

import (
    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc"
    "go.opentelemetry.io/otel/sdk/log"
    "go.opentelemetry.io/otel/sdk/resource"
    semconv "go.opentelemetry.io/otel/semconv/v1.24.0"
)

func initLogger() (*log.LoggerProvider, error) {
    exporter, err := otlploggrpc.New(ctx,
        otlploggrpc.WithEndpoint("localhost:4317"),
        otlploggrpc.WithInsecure(),
    )
    if err != nil {
        return nil, err
    }

    res := resource.NewWithAttributes(
        semconv.SchemaURL,
        semconv.ServiceName("my-service"),
    )

    provider := log.NewLoggerProvider(
        log.WithResource(res),
        log.WithProcessor(log.NewBatchProcessor(exporter)),
    )

    return provider, nil
}

Python

from opentelemetry import trace
from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter
from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.sdk.resources import Resource

resource = Resource.create({"service.name": "my-service"})

logger_provider = LoggerProvider(resource=resource)
logger_provider.add_log_record_processor(
    BatchLogRecordProcessor(
        OTLPLogExporter(endpoint="localhost:4317", insecure=True)
    )
)

# Use with Python logging
import logging
handler = LoggingHandler(logger_provider=logger_provider)
logging.getLogger().addHandler(handler)

Node.js

const { NodeSDK } = require('@opentelemetry/sdk-node');
const { OTLPLogExporter } = require('@opentelemetry/exporter-logs-otlp-grpc');
const { SimpleLogRecordProcessor } = require('@opentelemetry/sdk-logs');

const sdk = new NodeSDK({
  serviceName: 'my-service',
  logRecordProcessor: new SimpleLogRecordProcessor(
    new OTLPLogExporter({
      url: 'grpc://localhost:4317',
    })
  ),
});

sdk.start();

Java

import io.opentelemetry.exporter.otlp.logs.OtlpGrpcLogRecordExporter;
import io.opentelemetry.sdk.logs.SdkLoggerProvider;
import io.opentelemetry.sdk.logs.export.BatchLogRecordProcessor;
import io.opentelemetry.sdk.resources.Resource;
import io.opentelemetry.semconv.ResourceAttributes;

Resource resource = Resource.getDefault()
    .merge(Resource.create(Attributes.of(
        ResourceAttributes.SERVICE_NAME, "my-service"
    )));

OtlpGrpcLogRecordExporter exporter = OtlpGrpcLogRecordExporter.builder()
    .setEndpoint("http://localhost:4317")
    .build();

SdkLoggerProvider loggerProvider = SdkLoggerProvider.builder()
    .setResource(resource)
    .addLogRecordProcessor(BatchLogRecordProcessor.builder(exporter).build())
    .build();

HTTP Ingestion

Send logs directly via HTTP POST:

curl -X POST http://localhost:4318/v1/logs \
  -H "Content-Type: application/json" \
  -d '{
    "resourceLogs": [{
      "resource": {
        "attributes": [{
          "key": "service.name",
          "value": {"stringValue": "my-service"}
        }]
      },
      "scopeLogs": [{
        "logRecords": [{
          "timeUnixNano": "1234567890000000000",
          "severityNumber": 9,
          "severityText": "INFO",
          "body": {"stringValue": "Hello from Glintlog!"},
          "attributes": [{
            "key": "user.id",
            "value": {"stringValue": "123"}
          }]
        }]
      }]
    }]
  }'

Severity Levels

Glintlog recognizes standard OpenTelemetry severity levels:

Level	Number	Description
TRACE	1-4	Fine-grained debugging
DEBUG	5-8	Debugging information
INFO	9-12	Normal operations
WARN	13-16	Warning conditions
ERROR	17-20	Error conditions
FATAL	21-24	Critical failures

Best Practices

Set service.name - Always include a service.name resource attribute to identify your application
Use structured logging - Include relevant attributes for filtering and analysis
Batch logs - Use batch processors to reduce network overhead
Include trace context - When using distributed tracing, include trace and span IDs

Troubleshooting

Connection refused

Ensure Glintlog is running and the ports are accessible:

# Check if Glintlog is listening
netstat -an | grep 4317
netstat -an | grep 4318

Authentication errors

If you've enabled API key authentication, ensure you're including the X-Glintlog-Key header.

Logs not appearing

Check the Glintlog server logs for ingestion errors. Verify your OTLP payload format matches the specification.