# LogBrew Docs
Wählen Sie zuerst App oder Framework, erstellen Sie das Projekt in Add Project und prüfen Sie das erste Signal, bevor Sie CLI- und Dashboard-Referenzen nutzen.

# Plattform wählen
Beginnen Sie mit der passenden App oder dem passenden Framework. Verwenden Sie dieselbe Auswahl in Add Project.

## Node.js-Service
Nutzen Sie das Node.js-Paket, wenn ein Backend-Service Logs, Request-Spans, Actions, Releases und Metrics sendet.

```bash
npm install @logbrew/sdk @logbrew/node
```
Next: Node First-Signal-Pfad nutzen

## Express-Service
Nutzen Sie das Express-Paket, wenn ein Node-Service Requests über Express-Middleware verarbeitet.

```bash
npm install @logbrew/sdk @logbrew/express express
```
Next: Add Project öffnen

## Fastify-Service
Nutzen Sie das Fastify-Paket, wenn ein Node-Service Routes über Fastify-Plugins verarbeitet.

```bash
npm install @logbrew/sdk @logbrew/fastify fastify
```
Next: Add Project öffnen

## JavaScript-App
Nutzen Sie das JavaScript-Browser-Paket für Frontend-Seiten mit Product Actions, Logs und leichten Client-Signalen.

```bash
npm install @logbrew/sdk @logbrew/browser
```
Next: Add Project öffnen

## Next.js-App
Nutzen Sie das Next.js-Paket, wenn Routes, Server Rendering und Client Actions einen gemeinsamen Setup-Pfad brauchen.

```bash
npm install @logbrew/sdk @logbrew/next next react react-dom
```
Next: Add Project öffnen

## React-App
Nutzen Sie das React-Paket für komponentenbasierte Web-Apps mit User Actions und UI-State.

```bash
npm install @logbrew/sdk @logbrew/react react
```
Next: Add Project öffnen

## Angular-App
Nutzen Sie das Angular-Paket, wenn Framework-Routing und App-Fehler denselben Setup-Pfad teilen sollen.

```bash
npm install @logbrew/sdk @logbrew/angular @angular/core
```
Next: Add Project öffnen

## Vue-App
Nutzen Sie das Vue-Paket für Vue-Apps mit klaren Product Actions und Browser-Signalen.

```bash
npm install @logbrew/sdk @logbrew/vue vue
```
Next: Add Project öffnen

## Svelte-App
Nutzen Sie das Svelte-Paket für Svelte-Apps mit direktem SDK-Installationspfad.

```bash
npm install @logbrew/sdk @logbrew/svelte svelte
```
Next: Add Project öffnen

## NestJS-Service
Nutzen Sie das NestJS-Paket, wenn ein Node-Service um Nest-Module und Request Handling aufgebaut ist.

```bash
npm install @logbrew/sdk @logbrew/nestjs @nestjs/common @nestjs/core @nestjs/platform-express reflect-metadata rxjs
```
Next: Add Project öffnen

## Python-Service
Beginnen Sie mit dem Core-Paket für Python-Worker und Services.

```bash
python3 -m pip install logbrew-sdk
```
Next: Add Project öffnen

## Django-App
Nutzen Sie das Django-Paket für Request- und App-Signale aus einem Django-Projekt.

```bash
python3 -m pip install logbrew-sdk logbrew-django
```
Next: Add Project öffnen

## FastAPI-Service
Nutzen Sie das FastAPI-Paket für Python-APIs mit expliziten Request-Spans und Actions.

```bash
python3 -m pip install logbrew-sdk logbrew-fastapi
```
Next: Add Project öffnen

## .NET-Service
Installieren Sie das .NET-Paket, wenn ein Service serverseitige Signale besitzt.

```bash
dotnet add package LogBrew
```
Next: Add Project öffnen

## ASP.NET Core-App
Nutzen Sie das ASP.NET-Core-Paket, wenn .NET-Request-Handling und Web-App-Signale einen gemeinsamen Setup-Pfad brauchen.

```bash
dotnet add package LogBrew.AspNetCore
```
Next: Add Project öffnen

## Java-Service
Nutzen Sie das JVM-Paket für Java-Services mit app-eigenen Logs, Request-Spans und Product Actions.

```bash
implementation("co.logbrew:logbrew-sdk:0.1.0")
```
Next: Add Project öffnen

## Go-Service
Fügen Sie das Go-Paket hinzu, wenn ein Service explizite Logs, Spans, Metrics und Trace Context besitzt.

```bash
go get github.com/LogBrewCo/sdk/go/logbrew@v0.1.3
```
Next: Add Project öffnen

## PHP-App
Nutzen Sie Composer für PHP-Services und app-eigene Request-Signale.

```bash
composer require logbrew/sdk
```
Next: Add Project öffnen

## Ruby-Service
Nutzen Sie das Ruby-Gem für Ruby-Services mit expliziten App- und Request-Signalen.

```bash
gem install logbrew-sdk
```
Next: Add Project öffnen

## Rust-Service
Fügen Sie die Rust-Crate für Services hinzu, die eigene Logs, Spans, Actions und Metrics erzeugen.

```bash
cargo add logbrew
```
Next: Add Project öffnen

## iOS-App
Nutzen Sie das Apple-Platform-Paket für iOS-Apps mit expliziten Product Signals.

```bash
.package(url: "https://github.com/LogBrewCo/sdk.git", from: "0.1.1")
```
Next: Add Project öffnen

## Android-App
Nutzen Sie das Android-Paket für Apps, die app-eigene Signale aus der Android Runtime senden.

```bash
implementation("co.logbrew:logbrew-kotlin:0.1.0")
```
Next: Add Project öffnen

## React-Native-App
Nutzen Sie das React-Native-Paket für mobile Apps mit gemeinsamen JavaScript Product Actions.

```bash
npm install @logbrew/sdk @logbrew/react-native react react-native
```
Next: Add Project öffnen

## Unity-App
Nutzen Sie das Unity-Paket für Spiele oder Simulationen mit Product Actions und Runtime-Signalen.

```bash
"co.logbrew.unity": "file:../Packages/co.logbrew.unity"
```
Next: Add Project öffnen

## C-App
Nutzen Sie die C-Quellen für native Services oder Embedded Apps mit direkter Signalkontrolle.

```bash
cc -std=c99 -Wall -Wextra -Wpedantic -Iinclude src/logbrew.c src/logbrew_metric.c src/logbrew_recording_transport.c src/logbrew_timeline.c src/logbrew_trace.c your_app.c -o your_app
```
Next: Add Project öffnen

## C++-App
Führen Sie den veröffentlichten CLI-Plan in einem CMake-3.16+- und C++17-Projekt aus. Verknüpfen Sie LogBrew::LogBrew. Aktivieren Sie LogBrew::HttpTransport und libcurl nur für gehostete Übertragung.

```bash
logbrew setup --json
```
Next: Add Project öffnen

## Setup-Pfad auf einen Blick
Nutzen Sie diese Reihenfolge, um von den Docs zu einer geprüften Produktaktion zu kommen, ohne den Setup-Fluss zu verlassen.

- Installieren. Paket hinzufügen: Starten Sie mit dem SDK-Paket für Ihre Laufzeit.
- Erstellen. Projekt erstellen: Öffnen Sie Add Project für die einmalige Projekt-Berechtigung.
- Senden. Eine Produktaktion senden: Führen Sie eine nicht geheime Produktaktion aus, bevor Sie die App verdrahten.
- Prüfen. Logs prüfen: Bestätigen Sie das Signal in Logs oder mit der CLI.

# Erster erfolgreicher SDK-Lauf
Halten Sie die erste Sitzung knapp: Paket installieren, Projekt erstellen, eine nicht geheime Produktaktion senden und in LogBrew prüfen.

## Für das erste Signal nötig
Direkte SDK-Ingestion hält den Setup-Weg kurz.

- Collector: Kein lokaler Agent. Installieren Sie das SDK-Paket und senden Sie direkt an die LogBrew API.
- Zugang: Eine Projekt-Berechtigung. Kopieren Sie sie nur aus Add Project, wenn Sie dieses Projekt erstellen oder einrichten.
- Nachweis: In Logs prüfen. Senden Sie ein Info-Signal und bestätigen Sie es vor weiterer Instrumentierung.

## KI-Assistentenkontext
Geben Sie einem Agenten die öffentliche LogBrew-Übersicht, bevor er Ihre App oder den Setup-Befehl bearbeitet.

```bash
curl -L https://logbrew.co/llms.txt
```

### KI-Setup-Prompt
```bash
Lies https://logbrew.co/llms.txt und wähle danach die passende SDK-Karte unter https://logbrew.co/en/docs#docs-sdk-choice-title. Verwende npm install @logbrew/sdk @logbrew/node nur für einen server-side Node.js Service; für Next.js, React, iOS, Android oder React Native nutze die gewählte Karte und den Add Project Prompt. Bitte den angemeldeten Nutzer, Add Project zu öffnen und Berechtigungen nur in der passenden App-Umgebung abzulegen. Für server-side Node.js heißt die Env-Variable LOGBREW_SERVER_API_KEY. Führe node node_modules/@logbrew/node/examples/first-useful-telemetry.mjs nur für Node Services aus und prüfe danach mit logbrew logs info --json. Frage im Chat oder in Commits nicht nach Berechtigungen.
```
Next: Agent-Leitfaden öffnen

## SDK installieren
Nutzen Sie die Node-Pakete für einen Backend-Service mit Logs, Spans, Actions, Releases und Metriken.

```bash
npm install @logbrew/sdk @logbrew/node
```


## Projekt erstellen
Öffnen Sie Add Project, wählen Sie eine Plattform und kopieren Sie die einmalige Ingest-Berechtigung aus dem Setup-Panel.

Next: Add Project öffnen

## Eine Produktaktion senden
Führen Sie das Paketbeispiel aus, bevor Produktionscode angebunden wird, damit die erste Form bekannt und tokenfrei ist.

```bash
node node_modules/@logbrew/node/examples/first-useful-telemetry.mjs
```


## In LogBrew prüfen
Lesen Sie das erste Info-Signal in den Logs, bevor weitere Instrumentierung hinzukommt.

```bash
logbrew logs info --json
```


# Das erste Node-SDK-Event an LogBrew senden
Nutzen Sie diesen Node-Pfad, wenn Sie echte Projektdaten brauchen statt noch eines Setup-Artikels. Das Dashboard erstellt das Projekt und zeigt die einmalige Ingest-Berechtigung; die öffentlichen Docs halten Paket- und Prüfschritte sicher.

## JavaScript-SDK-Pakete hinzufügen
Beginnen Sie mit dem Core-SDK und dem Node-Helfer, wenn ein Backend-Service Logs, Request-Spans, Actions, Releases und Metriken senden soll.

```bash
npm install @logbrew/sdk @logbrew/node
```

## Projekt über Add Project erstellen
Melden Sie sich an, öffnen Sie Add Project, wählen Sie eine Plattform und kopieren Sie die einmalige Ingest-Berechtigung aus diesem Setup-Panel. Nach dem Verlassen zeigt die Website sie nicht erneut.


## Beispiel für das erste SDK-Event ausführen
Prüfen Sie mit dem installierten Paketbeispiel die Form von Release, Environment, Request-Span, Product Action, Network Milestone und Metrik, bevor Sie Ihre App verdrahten.

```bash
node node_modules/@logbrew/node/examples/first-useful-telemetry.mjs
```

## Erstes Signal in LogBrew lesen
Nachdem das SDK ein info-Event mit der Projektberechtigung gesendet hat, bestätigen Sie es per CLI oder Dashboard-Logs, bevor Sie weitere Instrumentierung hinzufügen.

```bash
logbrew logs info --json
```

# Startpfad wählen
## Prüfen, ob LogBrew bereit ist
Zuerst status ausführen, um Erreichbarkeit, Anmeldestatus und den nächsten sicheren Read zu bestätigen.

```bash
logbrew status --json
```

## Mit den neuesten Fehlern starten
Aktuelle error Logs lesen und dann zu Issues oder Traces wechseln, wenn Release oder Projekt Kontext brauchen.

```bash
logbrew logs error --json
```

## Eine stabile Issue-Ansicht teilen
Offene Issues auflisten, wenn ein Teammitglied dieselben Fehlergruppen braucht.

```bash
logbrew issues open --json
```

# Befehlsübersicht
## Status
Lokale Authentifizierung, API-Erreichbarkeit und Recovery-Schritte vor jedem privaten Read prüfen.

```bash
logbrew status --json
```

## Logs
Mit aktuellen Fehlern starten, wenn ein Release, Projekt oder Trace Kontext braucht.

```bash
logbrew logs error --json
```

## Issues
Offene Fehlergruppen auflisten, bevor resolve, close, ignore oder reopen entschieden wird.

```bash
logbrew issues open --json
```

## Trace-Detail
Eine bekannte Trace-ID lesen, wenn Logs oder Issues auf einen fehlgeschlagenen Request zeigen.

```bash
logbrew trace <trace_id> --json
```

## Actions
User-Events nach Name filtern, wenn der wichtige Kontext eine Produktaktion ist.

```bash
logbrew actions --name checkout_failed --json
```

## Releases
Rollout-Kontext mit Log-, Issue-, Trace-Span- und Action-Zahlen vergleichen.

```bash
logbrew releases --json
```

## Lokale Authentifizierung und API-Erreichbarkeit prüfen
Der erste Read sollte zeigen, ob die CLI die LogBrew API erreicht, ohne Token-Material offenzulegen.

- JSON-Modus nutzen, wenn ein Script oder eine Automatisierung stabile Felder braucht.
- Menschliche Ausgabe nutzen, wenn eine Entwicklerin oder ein Entwickler den nächsten Befehl braucht.
- Auth-Recovery immer zurück zu Login und Status führen.

## Produktionssignale nach Ressource lesen
Logs, Issues, Actions, Traces, Releases und Projekte sollten getrennt genug für schnelles Scannen und verbunden genug für Kontext-Recovery bleiben.

- Logs behalten Schweregrad-, Release-, Umgebungs-, Projekt-, Trace- und Suchfilter.
- Issues behalten Status, Trace-Kontext und Mutationsvokabular.
- Traces behalten Span-Namen, Release-Kontext, Umgebungskontext und Projektumfang.

## Nützlichen Kontext senden, ohne Projektdaten offenzulegen
Nutzen Sie öffentliche Docs, Markdown und kopierbare Befehle, wenn jemand Setup-Hilfe oder eine sichere Übergabe braucht.

- Einen Docs-Link teilen, wenn der nächste Schritt Setup oder Befehlsfindung ist.
- Markdown teilen, wenn Klartext besser als ein Screenshot ist.
- Dashboard-Projektdaten hinter Anmeldung und Backend-Auth halten.

## Dashboard an Backend-Routen ausrichten
Der Web-Arbeitsbereich sollte dokumentierten LogBrew API-Verträgen folgen, ohne Dashboard-only-Speicher oder alternative Verträge zu erfinden.

- Logs werden über /api/logs mit Schweregrad-, Release-, Umgebungs-, Projekt-, Trace- und Suchfiltern gelesen.
- Issues werden über /api/telemetry/issues und /api/telemetry/issues/{issue_id} gelesen und geändert.
- Actions, Releases und Trace-Details werden über /api/telemetry/actions, /api/telemetry/releases und /api/telemetry/traces/{trace_id} gelesen.
- Projekte und Auth-Status kommen aus /api/projects, /api/auth und CLI-Statusbefehlen.

## Public agent links
- Full docs site: https://docs.logbrew.co
- Docs: https://logbrew.co/de/docs
- Docs Markdown: https://logbrew.co/de/docs.md
- Agent guide: https://logbrew.co/de/agents
- Home Markdown: https://logbrew.co/de/page.md
- llms.txt: https://logbrew.co/llms.txt
- Sitemap: https://logbrew.co/sitemap.xml