# Working with OTel

Gonzo can act as an OpenTelemetry Protocol (OTLP) log receiver, accepting logs directly from OpenTelemetry-instrumented applications.

### Basic OTLP Setup

```bash
# Start Gonzo as OTLP receiver
gonzo --otlp-enabled

# Custom ports
gonzo --otlp-enabled --otlp-grpc-port=5317 --otlp-http-port=5318

# OTLP with file backup
gonzo --otlp-enabled -f backup.log --follow
```

**Default Endpoints:**

* **gRPC:** `localhost:4317`
* **HTTP:** `http://localhost:4318/v1/logs`

### OpenTelemetry Collector Configuration

{% tabs %}
{% tab title="gRPC Configuration" %}
**OpenTelemetry Collector (otelcol) config:**

```yaml
# otel-collector-config.yaml
exporters:
  otlp/gonzo_grpc:
    endpoint: localhost:4317
    tls:
      insecure: true

service:
  pipelines:
    logs:
      receivers: [filelog, otlp]
      processors: [batch]
      exporters: [otlp/gonzo_grpc]
```

**Start collector:**

```bash
otelcol --config=otel-collector-config.yaml
```

{% endtab %}

{% tab title="HTTP Configuration" %}
**OpenTelemetry Collector (otelcol) config:**

```yaml
# otel-collector-config.yaml
exporters:
  otlphttp/gonzo_http:
    endpoint: http://localhost:4318/v1/logs

service:
  pipelines:
    logs:
      receivers: [filelog, otlp]
      processors: [batch]
      exporters: [otlphttp/gonzo_http]
```

**Benefits of HTTP:**

* Easier debugging with standard HTTP tools
* Better firewall compatibility
* Works with HTTP proxies
  {% endtab %}
  {% endtabs %}

### Application Integration

**Python Application:**

```python
from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor

# Configure OTLP exporter
otlp_exporter = OTLPLogExporter(
    endpoint="localhost:4317",
    insecure=True
)

# Set up logging pipeline
logger_provider = LoggerProvider()
logger_provider.add_log_record_processor(
    BatchLogRecordProcessor(otlp_exporter)
)

# Your application logs now flow to Gonzo
import logging
logging.info("This log will appear in Gonzo!")
```

**Node.js Application:**

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

const sdk = new NodeSDK({
  logRecordProcessor: new BatchLogRecordProcessor(
    new OTLPLogExporter({
      url: 'http://localhost:4317',
    })
  ),
});

sdk.start();
```

### OTLP Advantages

**Why Use OTLP with Gonzo:**

✅ **Native integration** - Structured log data preserves all attributes\
✅ **Real-time streaming** - Logs appear immediately as they're generated\
✅ **Metadata preservation** - Service names, trace IDs, and custom attributes\
✅ **Standardized format** - Works with any OpenTelemetry-compatible application\
✅ **Scalable architecture** - Handle logs from multiple services simultaneously

**Use Cases:**

* **Microservice architectures** - Centralized log collection from all services
* **Cloud-native applications** - Integration with OpenTelemetry ecosystems
* **Real-time monitoring** - Immediate visibility into application behavior
* **Distributed tracing correlation** - Logs automatically linked to traces

### OTLP Issues

```bash
# Connection refused
# Check if Gonzo is listening:
netstat -ln | grep 4317

# No logs appearing
# Verify OTLP configuration:
curl -X POST http://localhost:4318/v1/logs -d '{}'

# Port conflicts
# Use custom ports:
gonzo --otlp-enabled --otlp-grpc-port=5317
```

### What's Next?

Now that you understand all input methods, explore these advanced topics:

* **Filtering & Search** - Find exactly what you need in your logs
* **Configuration** - Set up persistent input configurations
* **Integration Examples** - Real-world input scenarios
* **AI Integration** - Add intelligence to your log analysis

***

**You now have complete mastery over getting data into Gonzo!** 🚀 Whether you're analyzing static files, monitoring real-time streams, or integrating with OpenTelemetry, you know the optimal approach for every scenario.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.controltheory.com/controltheory-documentation/gonzo-docs/advanced-features/working-with-otel.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.