Przejdź do treści
Biblioteka skilli
Dane i analityka · Analiza

structured-logging

/structured-logging

Pomaga analizować duże dane w SQLite: zapytania do logów, wzorce w testach, korelacje błędów i agregacje, gdy wynik ma ponad sto linii.

Licencja
MIT
Ostatnia zmiana repozytorium
22.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 22.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Pomaga analizować duże dane w SQLite: zapytania do logów, wzorce w testach, korelacje błędów i agregacje, gdy wynik ma ponad sto linii.

Wyzwalacze z opisu

analyze data with SQLitequery logsfind patterns in test resultscorrelate errors across files
Oryginalny opis (EN)

This skill should be used when the user asks to "analyze data with SQLite", "query logs", "find patterns in test results", or "correlate errors across files". Automatically activates when parsing large output (>100 lines), correlating data from multiple sources, tracking state across operations, aggregating results (counts, averages, grouping), or querying the same dataset multiple times. Not for tiny datasets (<50 records) with a single simple query.

Jak działa

  1. Decision Check
  2. Core Principle
  3. When to Use SQLite
  4. When NOT to Use SQLite
  5. Red Flags -- Use SQLite Instead
  6. The Threshold
  7. Available Tools
  8. Quick Start
  9. Key Mindset Shift
  10. Additional Resources
Sekcje z nagłówków SKILL.md, w oryginale · 153 linii, 668 słów
Podgląd SKILL.md
---
name: structured-logging
description: This skill should be used when the user asks to "analyze data with SQLite", "query logs", "find patterns in test results", or "correlate errors across files". Automatically activates when parsing large output (>100 lines), correlating data from multiple sources, tracking state across operations, aggregating results (counts, averages, grouping), or querying the same dataset multiple times. Not for tiny datasets (<50 records) with a single simple query.
---

# SQLite for Structured Data

## Decision Check

Before writing any data analysis code, evaluate:

1. Will the data be queried more than once? -> **Use SQLite**
2. Are GROUP BY, COUNT, AVG, or JOIN operations needed? -> **Use SQLite**
3. Is custom Python/jq parsing code about to be written? -> **Use SQLite instead**
4. Is the dataset >100 records? -> **Use SQLite**

If the answer to any question above is YES, use SQLite. Do not write custom parsing code.

```bash
# Custom code for every query:
cat data.json | jq '.[] | select(.status=="failed")' | jq -r '.error_type' | sort | uniq -c

# SQL does the work:
sqlite3 data.db "SELECT error_type, COUNT(*) FROM errors WHERE status='failed' GROUP BY error_type"
```

## Core Principle

**SQLite is just a file** -- no server, no setup, zero dependencies. Apply it when custom parsing code would otherwise be written or data would be re-processed for each query.

## When to Use SQLite

Apply when ANY of these conditions hold:

- **>100 records** -- JSON/grep becomes unwieldy
- **Multiple aggregations** -- GROUP BY, COUNT, AVG needed
- **Multiple queries** -- Follow-up questions about the same data are expected
- **Correlation needed** -- Joining data from multiple sources
- **State tracking** -- Queryable progress/status over time is needed

## When NOT to Use SQLite

Skip SQLite when ALL of these are true:

- <50 records total
- Single simple query
- No aggregations needed
- No follow-up questions expected

For tiny datasets with simple access, JSON/grep is fine.

## Red Flags -- Use SQLite Instead

STOP and use SQLite when about to:

- Write Python/Node code to parse JSON/CSV for analysis
- Run the same jq/grep command with slight variations
- Write custom aggregation logic (COUNT, AVG, GROUP BY in code)
- Manually correlate data by timestamps or IDs
- Create temp files to store intermediate results
- Process the same data multiple times for different questions

**All of these mean: Load into SQLite once, query with SQL.**

## The Threshold

| Scenario | Tool | Why |
|----------|------|-----|
| 50 test results, one-time summary | Python/jq | Fast, appropriate |
| 200+ test results, find flaky tests | **SQLite** | GROUP BY simpler than code |
| 3 log files, correlate by time | **SQLite** | JOIN simpler than manual grep |
| Track 1000+ file processing state | **SQLite** | Queries beat JSON parsing |

**Rule of thumb:** If parsing code is being written or data is being re-processed, use SQLite instead.

## Available Tools

### sqlite3 (always available)

```bash
sqlite3 ~/.claude-logs/project.db
```

### sqlite-utils (optional, simplifies import)

Check availability before use:

```bash
command -v sqlite-utils >/dev/null 2>&1 && echo "available" || echo "not installed"
```

If sqlite-utils is available:
```bash
sqlite-utils insert data.db table_name data.json --pk=id
sqlite-utils query data.db "SELECT * FROM table"
```

If sqlite-utils is NOT available, fall back to sqlite3 with manual import:
```bash
sqlite3 data.db <<EOF
CREATE TABLE IF NOT EXISTS results (status TEXT, error_message TEXT);
.mode json
.import data.json results
EOF
```

Alternatively, install sqlite-utils: `uv tool install sqlite-utils`

## Quick Start

### Store Location
```bash
~/.claude-logs/<project-name>.db  # Persists across sessions
```

### Basic Workflow
```bash
# 1. Connect
PROJECT=$(basename $(git rev-parse --show-toplevel 2>/dev/null || pwd))
sqlite3 ~/.claude-logs/$PROJECT.db

# 2. Create table (first time)
CREATE TABLE results (
  id INTEGER PRIMARY KEY,
  name TEXT,
  status TEXT,
  duration_ms INTEGER
);

# 3. Load data
INSERT INTO results (name, status, duration_ms)
SELECT json_extract(value, '$.name'),
       json_extract(value, '$.status'),
       json_extract(value, '$.duration_ms')
FROM json_each(readfile('data.json'));

# 4. Query (SQL does the work)
SELECT status, COUNT(*), AVG(duration_ms)
FROM results
GROUP BY status;
```

## Key Mindset Shift

**From:** "Process data once and done"
**To:** "Make data queryable"

Benefits:
- Follow-up questions require no re-processing -- data is already loaded
- Different analyses run instantly against the same dataset
- State persists across sessions
- SQL handles complexity -- less custom code needed

## Additional Resources

- **`./references/patterns.md`** -- Python vs SQL side-by-side comparison and real-world examples (test analysis, error correlation, file processing state)
Pliki w paczce (2)
  • SKILL.md 5 KB
  • references/patterns.md 4 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · sjungling/sjungling-claude-plugins100MIT
Amey-Thakur/AI-SKILLS90MIT

Migawka bazy z 13.11.2026 · wersja paczki 2224d2b2eb2a (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100using-sqlite
    Pomaga w analizie danych w SQLite w sesjach DataPeeker: zapytania, import CSV, eksploracja schematów i optymalizacja wydajności.
  • 95sqlite-db
    Pokazuje, jak używać CLI sqlite3 do budowy bazy wiedzy: projektuje schemat, zapytania i relacje między danymi.
  • 100datasets
    Wyświetla listę podłączonych zbiorów danych ze statusem, liczbą tabel i datą ostatniej analizy.
  • 100data-processing
    Obsługuje strukturalne pliki danych (CSV, JSON, YAML, TOML, Parquet): zapytania, transformacje, filtrowanie, agregacje i konwersję między formatami.
  • 100sql
    Pisze, poprawia i uruchamia zapytania SQL oraz analizuje pliki CSV i SQLite przy pomocy narzędzia sqlite3.
  • 100analyze-data-quality
    Sprawdza, czy zbiór danych lub wynik zapytania nadaje się do użycia: świeżość, duplikaty, braki, zmiany schematu i sprzeczne źródła.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.