# Trimite date

Source: https://instatus.com/help/ro/observability/send-logs

Instatus primește loguri, trace-uri și metrici prin OpenTelemetry (OTLP peste HTTPS). Există două moduri de a conecta o aplicație. Alege unul.

| At a glance | Details |
| :-- | :-- |
| [Cel mai rapid](https://instatus.com/help/ro/observability/send-logs#opțiunea-1-copiază-un-prompt) | Copiază un prompt pentru agentul tău de programare |
| [Manual](https://instatus.com/help/ro/observability/send-logs#opțiunea-2-configurează-manual) | Alege limbajul și lipește codul |
| [Endpoint](https://instatus.com/help/ro/observability/send-logs#ce-trebuie-să-conțină-fiecare-cerere) | https://otel.instatus.com, plus două headere |
| [Test](https://instatus.com/help/ro/observability/send-logs#trimite-un-log-de-test) | O cerere curl |
| [Nu apare nimic?](https://instatus.com/help/ro/observability/send-logs#depanare) | Rezolvă problemele obișnuite |

## Opțiunea 1: Copiază un prompt

Cea mai rapidă cale, dacă folosești un agent de programare precum Claude Code, Cursor sau Copilot.

1. Deschide **Observability** pe pagina ta de status.
2. La **Include**, bifează ce vrei să trimiți: **Loguri**, **Trace-uri**, **Metrici**. Bifează și **Dashboard de pornire** dacă mai târziu vrei dashboarduri gata făcute pentru serviciile tale.
3. Apasă pe **Copiază promptul**.
4. Lipește-l în agentul tău de programare, în proiectul aplicației.
5. Pune [cheia API](#găsește-cheia-api) în variabila de mediu `INSTATUS_API_KEY`, apoi rulează testul sugerat de agent.

![Cardul de configurare, cu loguri, trace-uri și metrici de inclus și un buton pentru copierea promptului](https://instatus.com/help/observability/setup.png)

Promptul îi cere agentului să folosească SDK-ul OpenTelemetry oficial pentru limbajul tău, să păstreze biblioteca de logging existentă, să citească cheia dintr-o variabilă de mediu și să nu o comită niciodată. ID-ul paginii tale este deja inclus.

## Opțiunea 2: Configurează manual

1. Deschide **Observability** pe pagina ta de status.
2. Apasă pe **Configurează manual**.
3. Alege limbajul: Node.js, Python, Go, Java, .NET, Ruby, PHP sau OpenTelemetry Collector.
4. Copiază comanda de la **Instalare** și rulează-o, apoi copiază codul de la **Configurare** în aplicație.
5. Setează variabila de mediu `INSTATUS_API_KEY` la [cheia API](#găsește-cheia-api) și pornește aplicația.

![Configurare manuală cu Node.js selectat, cu comanda de instalare și codul de configurare](https://instatus.com/help/observability/setup-by-hand.png)

Codul din dashboard are deja completat ID-ul paginii tale. Aceleași exemple sunt mai jos, dacă preferi să le copiezi de aici.

## Ce trebuie să conțină fiecare cerere

| Ce          | Valoare                                                                                  |
| -------------------- | --------------------------------------------------------------------------------------------- |
| Endpoint      | `https://otel.instatus.com`. Logurile merg la `/v1/logs`, trace-urile la `/v1/traces`, metricile la `/v1/metrics`. |
| `Authorization`      | `Bearer <API_KEY>`, cu cheia unui proprietar, administrator sau editor al paginii.                    |
| `X-Instatus-Site-Id` | ID-ul paginii de status căreia îi aparțin datele.                                                |
| Protocol      | OTLP peste HTTP, ca protobuf sau JSON. Dacă SDK-ul tău folosește implicit gRPC, schimbă-l pe HTTP.          |

> Cheia ta API oferă acces la tot contul. Păstreaz-o pe serverele tale, într-o variabilă de mediu. Nu o pune niciodată într-un browser, într-o aplicație mobilă sau într-un repository public.

### Găsește cheia API

Deschide meniul avatarului, alege **Setările utilizatorului**, apoi **Dezvoltator**, sau mergi direct la [setările de dezvoltator](https://dashboard.instatus.com/developer). Apasă pe **Copiază** lângă cheie.

![Cheia API în setările de dezvoltator, cu un buton de copiere](https://instatus.com/help/observability/api-key.png)

### Găsește ID-ul paginii

Rareori e nevoie: promptul și codul din dashboard îl conțin deja. Ca să-l copiezi singur, dă clic dreapta pe numele proiectului din partea de sus a dashboardului și alege **Copy Project ID**.

![Copy Project ID în meniul numelui proiectului](https://instatus.com/help/observability/copy-page-id.png)

## Trimite un log de test

O singură cerere dintr-un terminal e suficientă pentru a verifica cheia și ID-ul paginii:

```bash
curl -X POST https://otel.instatus.com/v1/logs \
  -H "Authorization: Bearer $INSTATUS_API_KEY" \
  -H "X-Instatus-Site-Id: $INSTATUS_PAGE_ID" \
  -H "Content-Type: application/json" \
  -d '{
    "resourceLogs": [{
      "resource": {
        "attributes": [
          { "key": "service.name", "value": { "stringValue": "api" } }
        ]
      },
      "scopeLogs": [{
        "logRecords": [{
          "timeUnixNano": "'$(date +%s)'000000000",
          "severityText": "INFO",
          "body": { "stringValue": "Hello from Instatus" }
        }]
      }]
    }]
  }'
```

Un răspuns `200` înseamnă că logul a fost acceptat. Deschide **Observability** → **Loguri** și îl vezi în câteva secunde.

## Orice limbaj, fără modificări de cod

Fiecare SDK OpenTelemetry citește aceleași variabile de mediu. Cu ele, instrumentarea automată trimite trace-uri, metrici și loguri fără să atingi codul:

```bash
export OTEL_SERVICE_NAME="api"
export OTEL_EXPORTER_OTLP_ENDPOINT="https://otel.instatus.com"
export OTEL_EXPORTER_OTLP_PROTOCOL="http/protobuf"
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer%20${INSTATUS_API_KEY},X-Instatus-Site-Id=${INSTATUS_PAGE_ID}"
export OTEL_TRACES_EXPORTER="otlp"
export OTEL_METRICS_EXPORTER="otlp"
export OTEL_LOGS_EXPORTER="otlp"
```

Spațiul de după `Bearer` se scrie `%20`, deoarece variabila de headere este codificată ca URL. Apoi pornește aplicația cu instrumentarea automată pentru limbajul ei:

```bash
# Node.js
npm install @opentelemetry/api @opentelemetry/auto-instrumentations-node
node --require @opentelemetry/auto-instrumentations-node/register app.js

# Python
pip install opentelemetry-distro opentelemetry-exporter-otlp
opentelemetry-bootstrap -a install
OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED=true opentelemetry-instrument python app.py
```

Java, .NET, Go, Ruby și PHP au propria instrumentare automată și citesc aceleași variabile. Vezi [ghidurile zero-code OpenTelemetry](https://opentelemetry.io/docs/zero-code/).

## Node.js

Pentru a trimite loguri din cod, instalează SDK-ul pentru loguri:

```bash
npm install @opentelemetry/api-logs @opentelemetry/sdk-logs \
  @opentelemetry/exporter-logs-otlp-http @opentelemetry/resources
```

Configurează-l o dată, la pornirea aplicației:

```js
import { SeverityNumber } from '@opentelemetry/api-logs'
import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http'
import { resourceFromAttributes } from '@opentelemetry/resources'
import { BatchLogRecordProcessor, LoggerProvider } from '@opentelemetry/sdk-logs'

const provider = new LoggerProvider({
  resource: resourceFromAttributes({ 'service.name': 'api' }),
  processors: [
    new BatchLogRecordProcessor(
      new OTLPLogExporter({
        url: 'https://otel.instatus.com/v1/logs',
        headers: {
          Authorization: `Bearer ${process.env.INSTATUS_API_KEY}`,
          'X-Instatus-Site-Id': process.env.INSTATUS_PAGE_ID
        }
      })
    )
  ]
})

const logger = provider.getLogger('api')

logger.emit({
  severityNumber: SeverityNumber.ERROR,
  severityText: 'ERROR',
  body: 'Payment failed: card declined',
  attributes: { 'customer.id': 'cus_123', route: '/v2/charges' }
})

process.on('beforeExit', () => provider.shutdown())
```

Folosești deja **pino** sau **winston**? Păstrează-le. [`pino-opentelemetry-transport`](https://www.npmjs.com/package/pino-opentelemetry-transport) și [`@opentelemetry/winston-transport`](https://www.npmjs.com/package/@opentelemetry/winston-transport) trimit fiecare linie de log existentă așa cum este.

## Python

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

SDK-ul se conectează la modulul `logging` din Python, așa că apelurile `logging` existente sunt trimise așa cum sunt:

```python
import logging
import os

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

provider = LoggerProvider(resource=Resource.create({"service.name": "worker"}))
provider.add_log_record_processor(
    BatchLogRecordProcessor(
        OTLPLogExporter(
            endpoint="https://otel.instatus.com/v1/logs",
            headers={
                "Authorization": f"Bearer {os.environ['INSTATUS_API_KEY']}",
                "X-Instatus-Site-Id": os.environ["INSTATUS_PAGE_ID"],
            },
        )
    )
)
set_logger_provider(provider)

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

logging.warning("Card declined for customer %s", "cus_123")
```

## OpenTelemetry Collector

Rulezi deja OpenTelemetry Collector? Adaugă Instatus ca exporter și lasă aplicațiile așa cum sunt:

```yaml
exporters:
  otlphttp/instatus:
    endpoint: https://otel.instatus.com
    headers:
      Authorization: Bearer ${env:INSTATUS_API_KEY}
      X-Instatus-Site-Id: ${env:INSTATUS_PAGE_ID}

service:
  pipelines:
    logs:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/instatus]
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/instatus]
    metrics:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlphttp/instatus]
```

Exporterul adaugă singur `/v1/logs`, `/v1/traces` și `/v1/metrics`, așa că endpointul este doar hostul. Pentru a trimite fișiere de log, adaugă un receiver `filelog` în pipeline-ul de loguri.

## Ce să trimiți

Instatus citește aceste câmpuri. Restul este păstrat ca atribut după care poți căuta și filtra.

| Câmp                       | Folosit pentru                                                                                    |
| ---------------------------------- | ------------------------------------------------------------------------------------------------- |
| `service.name` (resursă)      | Coloana și filtrul **Serviciu**. Setează-l în fiecare aplicație, worker și job. |
| `body`                             | Mesajul logului, în care caută căutarea text.                                                     |
| `severityText` sau `severityNumber` | Nivelul: `fatal`, `error`, `warn`, `info`, `debug` sau `trace`.                                  |
| `traceId` și `spanId`             | Leagă un log de trace-ul lui, ca să poți trece de la unul la altul.                                          |
| Atribute                     | Orice adaugi, de exemplu `customer.id` sau `http.route`. Fiecare devine un filtru.               |

Atributele care încep cu `instatus.` sunt rezervate și sunt înlocuite la sosirea datelor.

## Depanare

| Vezi               | Soluție                                                                                                                     |
| --------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| `401`                       | Verifică cheia și headerul `X-Instatus-Site-Id`. Proprietarul cheii trebuie să fie proprietar, administrator sau editor al paginii.       |
| `400`                       | Corpul nu este OTLP valid. Verifică `Content-Type` și structura JSON din [logul de test](#trimite-un-log-de-test).             |
| `429`                       | Volumul de date al lunii s-a epuizat. Vezi [planuri și limite](https://instatus.com/help/ro/observability#planuri-și-limite).                    |
| `200`, dar nu apare nimic | Așteaptă câteva secunde, apoi verifică intervalul de timp. Un log cu marcaj de timp din trecut apare doar dacă intervalul îl acoperă. |
| Absolut nimic              | SDK-urile trimit în loturi. Asigură-te că aplicația golește sau închide providerul înainte să se oprească.                           |

Când regenerezi cheia API din setările de dezvoltator, cea veche nu mai funcționează imediat, așa că actualizează mai întâi fiecare aplicație care o folosește.

- [Loguri](https://instatus.com/help/ro/observability/logs): Caută, filtrează și urmărește logurile live
- [Trace-uri](https://instatus.com/help/ro/observability/traces): Vezi unde își petrece timpul fiecare cerere
