SigNoz Docs

https://signoz.io/docs/
Admin
SigNoz is an open-source observability platform that provides APM, logs, traces, metrics,...
Tokens:1,945,583
Snippets:16,707
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Clone and set up the Pipecat quickstart project

Source: https://signoz.io/docs/pipecat-monitoring

Clones the Pipecat quickstart repository, changes into the agent-starter-python directory, and installs dependencies using uv.

```bash
git clone https://github.com/pipecat-ai/pipecat-quickstart.git
cd agent-starter-python
uv sync
```

--------------------------------

### Run Hermes Setup Wizard

Source: https://signoz.io/docs/hermes-monitoring

Runs the setup wizard for a fresh Hermes install.

```bash
hermes setup
```

--------------------------------

### Run setup script with Docker

Source: https://signoz.io/docs/inkeep-monitoring

Command to run the setup script, which starts Docker containers for the development environment.

```bash
pnpm setup-dev
```

--------------------------------

### Install net/http instrumentation with go get

Source: https://signoz.io/docs/instrumentation/opentelemetry-golang

Installs the otelhttp instrumentation package for net/http.

```bash
go get go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp
```

--------------------------------

### Start ZooKeeper

Source: https://signoz.io/docs/messaging-queues/kafka

Starts ZooKeeper, which is required for the Kafka setup described in this guide.

```bash
bin/zookeeper-server-start.sh config/zookeeper.properties
```

--------------------------------

### Install foundryctl

Source: https://signoz.io/docs/install/docker-selinux

Downloads and installs foundryctl using the official script. For manual install (air-gapped, etc.) or PATH setup, see the foundry getting-started guide.

```bash
curl -fsSL https://signoz.io/foundry.sh | bash
```

--------------------------------

### Start demo app using .env file

Source: https://signoz.io/docs/cloud/quickstart

Alternative setup using a .env file in the project root to store the OTLP endpoint and ingestion key, then starting the app with docker compose.

```dotenv
OTLP_ENDPOINT=ingest.us.signoz.cloud:443
SIGNOZ_INGESTION_KEY=<your-ingestion-key>
```

```bash
docker compose up -d
```

--------------------------------

### Set root user environment variables

Source: https://signoz.io/docs/manage/administrator-guide/configuration/root-user

Example environment variables to enable and configure the root user. Set these before first start for fresh installs, or update and restart for existing installs.

```bash
SIGNOZ_USER_ROOT_ENABLED=true
SIGNOZ_USER_ROOT_EMAIL=admin@example.com
SIGNOZ_USER_ROOT_PASSWORD=<secure-password>
SIGNOZ_USER_ROOT_ORG_NAME=default
SIGNOZ_USER_ROOT_ORG_ID=<org-uuid> # (UUID7)
```

--------------------------------

### Install Gin and otelgin packages

Source: https://signoz.io/docs/instrumentation/opentelemetry-golang

Install the Gin web framework and the otelgin instrumentation package using Go modules.

```bash
go get github.com/gin-gonic/gin
go get go.opentelemetry.io/contrib/instrumentation/github.com/gin-gonic/gin/otelgin
```

--------------------------------

### Install required npm packages

Source: https://signoz.io/docs/gcp-monitoring/gcp-fns/tracing

Run this command in your Cloud Function project directory to install the OpenTelemetry packages and the functions framework. This creates or updates package.json and package-lock.json with the dependencies used by the examples in this guide.

```bash
npm install --save \
  @google-cloud/functions-framework \
  @opentelemetry/api \
  @opentelemetry/auto-instrumentations-node \
  @opentelemetry/exporter-trace-otlp-http \
  @opentelemetry/sdk-node
```

--------------------------------

### Start Temporal Client Locally

Source: https://signoz.io/docs/integrations/temporal-golang-opentelemetry

Starts the Temporal client (starter) after setting the client-specific environment variables.

```go
go run starter/main.go

```

--------------------------------

### Start the web application

Source: https://signoz.io/docs/frontend-monitoring/document-load

Run npm start from the root folder to start the app.

```bash
npm start
```

--------------------------------

### Node.js: Install and register logger instrumentation

Source: https://signoz.io/docs/traces-management/guides/correlate-traces-and-logs

Install the instrumentation package for your logger (Pino, Winston, or Bunyan) and register it in your SDK setup. Each log entry gets trace_id, span_id, and trace_flags injected when a span is active.

```bash
npm install @opentelemetry/instrumentation-winston
# or @opentelemetry/instrumentation-pino
# or @opentelemetry/instrumentation-bunyan
```

```javascript
const { NodeSDK } = require('@opentelemetry/sdk-node');
const { WinstonInstrumentation } = require('@opentelemetry/instrumentation-winston');
 
const sdk = new NodeSDK({
  instrumentations: [new WinstonInstrumentation()],
});
sdk.start();
```

--------------------------------

### Create example Qwen application (main.py)

Source: https://signoz.io/docs/qwen-observability

A complete example application that uses the OpenAI SDK to call the Qwen model (qwen-turbo) via DashScope's compatible endpoint. Requires the DASHSCOPE_API_KEY environment variable to be set before running.

```python
import os
from openai import OpenAI
 
import logging
 
logging.getLogger().setLevel(logging.DEBUG)
logging.getLogger("httpx").setLevel(logging.DEBUG)
 
 
try:
    client = OpenAI(
        # If the environment variable is not configured, replace with: api_key="sk-xxx"
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
    )
 
    completion = client.chat.completions.create(
        model='qwen-turbo',  
        messages=[
            {'role': 'system', 'content': 'You are a helpful assistant.'},
            {'role': 'user', 'content': 'What is SigNoz?'},
        ]
    )
    print(completion.choices[0].message.content)
except Exception as e:
    print(f"Error message: {e}")
    print("See: https://www.alibabacloud.com/help/model-studio/developer-reference/error-code")
```

--------------------------------

### Get starting timestamp from distributed_signoz_index_v2

Source: https://signoz.io/docs/operate/migration/upgrade-0-64

Get the starting timestamp for the migration by querying the old index table.

```sql
select toUnixTimestamp64Nano(timestamp) from signoz_traces.distributed_signoz_index_v2 order by timestamp asc limit 1;
```

--------------------------------

### Start Mastra CLI Wizard (npm, yarn, pnpm, bun)

Source: https://signoz.io/docs/mastra-observability

Start the interactive setup wizard for Mastra using your preferred package manager. Choose one of these commands to scaffold a new Mastra project.

```bash
npx create-mastra@latest
```

```bash
yarn dlx create-mastra@latest
```

```bash
pnpm create mastra@latest
```

```bash
bun create mastra@latest
```

--------------------------------

### Complete Echo instrumentation example

Source: https://signoz.io/docs/instrumentation/opentelemetry-golang

Complete Echo application with OpenTelemetry middleware. The initTracer function is a placeholder that must be replaced with the implementation from the core setup section. The server starts on :8080 and gracefully shuts down on interrupt.

```go
package main
 
import (
	"context"
	"errors"
	"log"
	"net/http"
	"os"
	"os/signal"
	"time"
 
	"github.com/labstack/echo/v4"
	"github.com/labstack/echo/v4/middleware"
	"go.opentelemetry.io/contrib/instrumentation/github.com/labstack/echo/otelecho"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/trace"
)
 
// Use the initTracer function from Step 3 above
func initTracer(ctx context.Context) (func(context.Context) error, error) {
	// Paste the complete initTracer implementation from the core setup section
	return nil, nil  // Placeholder - replace with actual implementation
}
 
func main() {
	// Keep log.Fatal out of run() so that run()'s deferred calls still execute.
	if err := run(); err != nil {
		log.Fatalln(err)
	}
}
 
func run() (err error) {
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
	defer stop()
 
	shutdown, err := initTracer(ctx)
	if err != nil {
		return err
	}
	// Shut down with a fresh context. ctx is already cancelled once the signal
	// arrives, and a cancelled context aborts the final span flush.
	defer func() {
		shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
		defer cancel()
		err = errors.Join(err, shutdown(shutdownCtx))
	}()
 
	e := echo.New()
 
	e.Use(middleware.Recover())
 
	// Add OpenTelemetry middleware to instrument all routes
	e.Use(otelecho.Middleware("my-echo-service"))
 
	e.GET("/", func(c echo.Context) error {
		// Extract the span created by otelecho middleware
		span := trace.SpanFromContext(c.Request().Context())
 
		span.SetAttributes(attribute.String("custom.key", "value"))
		span.AddEvent("manual.event")
 
		return c.String(http.StatusOK, "Hello traced Echo!")
	})
 
	log.Println("Server starting on :8080")
	srvErr := make(chan error, 1)
	go func() {
		srvErr <- e.Start(":8080")
	}()
 
	select {
	case err := <-srvErr:
		return err
	case <-ctx.Done():
		stop()
	}
 
	shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()
	return e.Shutdown(shutdownCtx)
}
```

--------------------------------

### Clone and set up the LiveKit starter project

Source: https://signoz.io/docs/livekit-observability

Clones the LiveKit agent starter project, changes into its directory, and installs dependencies with uv. Requires Python 3.10+ and uv installed.

```bash
git clone https://github.com/livekit-examples/agent-starter-python
cd agent-starter-python
uv sync
```

--------------------------------

### Install OpenTelemetry packages for code-based setup

Source: https://signoz.io/docs/instrumentation/javascript/opentelemetry-nuxtjs

Install the OpenTelemetry packages required for code-based setup. This replaces the env var setup and gives full control over SDK initialization.

```bash
npm install --save @opentelemetry/api@^1.9.0 \
  @opentelemetry/sdk-node@^0.208.0 \
  @opentelemetry/auto-instrumentations-node@^0.67.0 \
  @opentelemetry/exporter-trace-otlp-http@^0.208.0
```

--------------------------------

### Start or reload PHP-FPM

Source: https://signoz.io/docs/instrumentation/opentelemetry-php

Start or reload PHP-FPM after installing the OpenTelemetry extension. Use the start commands after installation, and the reload commands if PHP-FPM is already running and you updated the pool configuration.

```bash
# Debian/Ubuntu
sudo systemctl start php<php-version>-fpm
 
# RHEL/CentOS/Amazon Linux
sudo systemctl start php-fpm
```

```bash
# Debian/Ubuntu
sudo systemctl reload php<php-version>-fpm
 
# RHEL/CentOS/Amazon Linux
sudo systemctl reload php-fpm
```

--------------------------------

### Start demo app with inline environment variables

Source: https://signoz.io/docs/cloud/quickstart

Starts the demo app with inline environment variables for the OTLP endpoint and ingestion key. Replace 'us' with your SigNoz Cloud region and '<your-ingestion-key>' with your actual key.

```bash
OTLP_ENDPOINT=ingest.us.signoz.cloud:443 SIGNOZ_INGESTION_KEY=<your-ingestion-key> docker compose up -d
```

--------------------------------

### Local Development Setup for n8n Poller

Source: https://signoz.io/docs/n8n-monitoring

Commands to set up a local development environment for the n8n poller: create and activate a virtual environment, install dependencies, copy the example environment file, and run the poller script.

```bash
python -m venv .venv
 
# Activate virtual environment
source .venv/bin/activate  # On Windows: .venv\Scripts\activate
 
# Install dependencies
pip install -r requirements.txt
 
# Configure .env as shown in Step 2
cp .env.example .env
 
# Run the poller
python poller.py
```

--------------------------------

### Get admin password

Source: https://signoz.io/docs/operate/migration/upgrade-0-55

Get the admin password for the ClickHouse installation.

```bash
RELEASE=my-release
NAMESPACE=platform
ADMIN_PASSWORD=$(
  kubectl -n $NAMESPACE get clickhouseinstallations.clickhouse.altinity.com $RELEASE-clickhouse \
  -o jsonpath --template '{.spec.configuration.users.admin/password}'
)
 
echo $<ADMIN_PASSWORD>
```

--------------------------------

### Copy example environment file and create data directory

Source: https://signoz.io/docs/n8n-monitoring

Copies the example environment file to .env and creates the data directory.

```bash
cp .env.example .env
mkdir -p ./data
```

--------------------------------

### Install New Binaries

Source: https://signoz.io/docs/operate/migration/upgrade-standard

Install the new binaries by copying them to the SigNoz and SigNoz OTEL Collector directories.

```bash
sudo cp -r signoz_linux_$(uname -m | sed 's/x86_64/amd64/g' | sed 's/aarch64/arm64/g')/* /opt/signoz
sudo cp -r signoz-otel-collector_linux_$(uname -m | sed 's/x86_64/amd64/g' | sed 's/aarch64/arm64/g')/* /opt/signoz-otel-collector
```

--------------------------------

### Instrument the Temporal Client (starter/main.go)

Source: https://signoz.io/docs/integrations/temporal-golang-opentelemetry

Sets up the Temporal client with OpenTelemetry tracing and metrics for sending workflow requests.

```go
package main
 
import (

```

--------------------------------

### Quick Start Query Examples

Source: https://signoz.io/docs/userguide/search-syntax

Basic query examples from the Quick Start section. The first shows a simple field comparison, the second combines conditions with AND, and the third demonstrates full-text search with a quoted phrase.

```text
service.name = 'payment-service'
```

```text
service.name = 'payment-service' AND http.status_code >= 400
```

```text
'error connecting to database'
```

--------------------------------

### Set up ZooKeeper directories

Source: https://signoz.io/docs/install/linux

Create ZooKeeper directories and copy the extracted files to /opt/zookeeper.

```bash
ZOOKEEPER_VERSION=3.9.5
sudo mkdir -p /opt/zookeeper /var/lib/zookeeper /var/log/zookeeper
sudo cp -R "apache-zookeeper-${ZOOKEEPER_VERSION}-bin/"* /opt/zookeeper/
```

--------------------------------

### Create example Baseten application (main.py)

Source: https://signoz.io/docs/baseten-monitoring

Example Baseten application using the OpenAI SDK to call a model hosted on Baseten. Requires the BASETEN_API_KEY environment variable to be set before running.

```python
from openai import OpenAI
import os
import logging
 
logging.getLogger().setLevel(logging.DEBUG)
logging.getLogger("httpx").setLevel(logging.DEBUG)
 
 
client = OpenAI(
    base_url="https://inference.baseten.co/v1",
    api_key=os.environ["BASETEN_API_KEY"],
)
 
try:
    response = client.chat.completions.create(
        model="nvidia/Nemotron-120B-A12B",
        messages=[
            {"role": "user", "content": "What is SigNoz?"},
        ],
    )
    print(response.choices[0].message.content)
except Exception as e:
    print(f"Error type: {type(e).__name__}")
    print(f"Error message: {str(e)}")
    if hasattr(e, 'response'):
        print(f"Response status: {e.response.status_code if hasattr(e.response, 'status_code') else 'N/A'}")
        print(f"Response body: {e.response.text if hasattr(e.response, 'text') else 'N/A'}")
    raise
```

--------------------------------

### Install traceloop-sdk and openai

Source: https://signoz.io/docs/traceloop

Installs the traceloop-sdk and openai packages in your Python environment. Required before running the example application.

```bash
pip install \
  traceloop-sdk \
  openai
```

--------------------------------

### Set up metrics with OTLP exporter

Source: https://signoz.io/docs/google-adk-observability

Configure the MeterProvider with a resource, OTLP metric exporter, and periodic reader, then get a meter.

```python
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry import metrics
from opentelemetry.instrumentation.system_metrics import SystemMetricsInstrumentor
import os
 
resource = Resource.create({"service.name": "<service_name>"})
metric_exporter = OTLPMetricExporter(
    endpoint= os.getenv("OTEL_EXPORTER_METRICS_ENDPOINT"),
    headers={"signoz-ingestion-key": os.getenv("SIGNOZ_INGESTION_KEY")},
)
reader = PeriodicExportingMetricReader(metric_exporter)
metric_provider = MeterProvider(metric_readers=[reader], resource=resource)
metrics.set_meter_provider(metric_provider)
 
meter = metrics.get_meter(__name__)
```
Tokens:
Raw