Quickstart Guide

Python

Install the OpenTelemetry packages:

pip install opentelemetry-api opentelemetry-sdk opentelemetry-exporter-otlp

Create a file called quickstart.py:

import logging
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry._logs import set_logger_provider
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.sdk.resources import Resource

# Configuration - replace with your values
API_KEY = "YOUR_API_KEY"
ORG_ID = "YOUR_ORG_ID"  # Found in Settings > General
ENDPOINT = "https://qorrelate.io"

# Set up resource (identifies your service)
resource = Resource.create({"service.name": "quickstart-python"})

# Set up tracing
trace_provider = TracerProvider(resource=resource)
trace_exporter = OTLPSpanExporter(
    endpoint=f"{ENDPOINT}/v1/traces",
    headers={"Authorization": f"Bearer {API_KEY}", "X-Organization-Id": ORG_ID}
)
trace_provider.add_span_processor(BatchSpanProcessor(trace_exporter))
trace.set_tracer_provider(trace_provider)

# Set up logging
logger_provider = LoggerProvider(resource=resource)
log_exporter = OTLPLogExporter(
    endpoint=f"{ENDPOINT}/v1/logs",
    headers={"Authorization": f"Bearer {API_KEY}", "X-Organization-Id": ORG_ID}
)
logger_provider.add_log_record_processor(BatchLogRecordProcessor(log_exporter))
set_logger_provider(logger_provider)

# Add handler to Python logging
handler = LoggingHandler(logger_provider=logger_provider)
logging.getLogger().addHandler(handler)
logging.getLogger().setLevel(logging.INFO)

# Send test data
tracer = trace.get_tracer(__name__)

with tracer.start_as_current_span("quickstart-test") as span:
    span.set_attribute("test.type", "quickstart")
    logging.info("Hello from Qorrelate quickstart!")
    print("✓ Data sent! Check your Qorrelate dashboard.")

# Flush to ensure data is sent
trace_provider.force_flush()
logger_provider.force_flush()

Run it:

python quickstart.py

Node.js

Install the OpenTelemetry packages:

npm install @opentelemetry/api @opentelemetry/sdk-node @opentelemetry/exporter-trace-otlp-http

Create a file called quickstart.js:

const { NodeSDK } = require('@opentelemetry/sdk-node');
const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
const { trace } = require('@opentelemetry/api');

// Configuration - replace with your values
const API_KEY = 'YOUR_API_KEY';
const ORG_ID = 'YOUR_ORG_ID';
const ENDPOINT = 'https://qorrelate.io';

const traceExporter = new OTLPTraceExporter({
  url: `${ENDPOINT}/v1/traces`,
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    'X-Organization-Id': ORG_ID
  }
});

const sdk = new NodeSDK({
  serviceName: 'quickstart-nodejs',
  traceExporter
});

sdk.start();

// Send test trace
const tracer = trace.getTracer('quickstart');
const span = tracer.startSpan('quickstart-test');
span.setAttribute('test.type', 'quickstart');
span.end();

console.log('✓ Data sent! Check your Qorrelate dashboard.');

// Give time for export then exit
setTimeout(() => {
  sdk.shutdown().then(() => process.exit(0));
}, 2000);

Run it:

node quickstart.js

Go

Install the OpenTelemetry packages:

go get go.opentelemetry.io/otel
go get go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp

Create main.go:

package main

import (
    "context"
    "fmt"
    "time"

    "go.opentelemetry.io/otel"
    "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
    "go.opentelemetry.io/otel/sdk/resource"
    "go.opentelemetry.io/otel/sdk/trace"
    semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
)

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

    // Configuration - replace with your values
    apiKey := "YOUR_API_KEY"
    orgID := "YOUR_ORG_ID"

    exporter, _ := otlptracehttp.New(ctx,
        otlptracehttp.WithEndpoint("qorrelate.io"),
        otlptracehttp.WithURLPath("/v1/traces"),
        otlptracehttp.WithHeaders(map[string]string{
            "Authorization":    "Bearer " + apiKey,
            "X-Organization-Id": orgID,
        }),
    )

    tp := trace.NewTracerProvider(
        trace.WithBatcher(exporter),
        trace.WithResource(resource.NewWithAttributes(
            semconv.SchemaURL,
            semconv.ServiceNameKey.String("quickstart-go"),
        )),
    )
    otel.SetTracerProvider(tp)
    defer tp.Shutdown(ctx)

    tracer := otel.Tracer("quickstart")
    _, span := tracer.Start(ctx, "quickstart-test")
    span.SetAttributes(semconv.ServiceNameKey.String("quickstart"))
    span.End()

    time.Sleep(2 * time.Second) // Allow export
    fmt.Println("✓ Data sent! Check your Qorrelate dashboard.")
}

Run it:

go run main.go

cURL (Direct API)

Send a log directly via the API:

curl -X POST https://qorrelate.io/v1/logs \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "X-Organization-Id: YOUR_ORG_ID" \
  -H "Content-Type: application/json" \
  -d '{
    "resourceLogs": [{
      "resource": {
        "attributes": [
          {"key": "service.name", "value": {"stringValue": "quickstart-curl"}}
        ]
      },
      "scopeLogs": [{
        "scope": {"name": "quickstart"},
        "logRecords": [{
          "timeUnixNano": "'$(date +%s)000000000'",
          "severityText": "INFO",
          "body": {"stringValue": "Hello from Qorrelate quickstart!"}
        }]
      }]
    }]
  }'