Superlog ను మీ సొంత VPS లో self-host చేయడం ఎలా?
Superlog ను self-host చేయడానికి Docker Compose ద్వారా Postgres, ClickHouse మరియు OTLP collector లను ఎలా సెటప్ చేయాలో తెలుసుకోండి. దీనివల్ల కలిగే ప్రయోజనాలు మరియు పరిమితులను ఇక్కడ
Superlog self-hosting ద్వారా వాస్తవంగా ఏమి ఇన్స్టాల్ అవుతుంది
Superlog ను self-host చేయడానికి repository ను clone చేసి, Docker Compose తో Postgres, ClickHouse మరియు OpenTelemetry collector ను ప్రారంభించాలి. తరువాత ఒక database migration ను అమలు చేసి, source నుంచి నాలుగు Node services ను start చేయాలి. మీ applications OTLP (OpenTelemetry protocol) traces, logs మరియు metrics ను intake port కు పంపుతాయి. Superlog వాటికి fingerprinting చేసి, పునరావృతమయ్యే వాటిని ఒకే incident గా group చేస్తుంది. తరువాత ఒక agent triage యొక్క మొదటి దశను రాస్తుంది. ఇన్స్టాల్కు ఒక మధ్యాహ్నం సమయం పడుతుంది. మీరు ప్రారంభించే ముందు footprint మరియు వాస్తవ పరిమితులను చదవడం ముఖ్యమైన భాగం.
Superlog కు Apache 2.0 license ఉంది. ఇది github.com/superloglabs/superlog వద్ద ఉంది. 13 October 2026 నాటికి దీనికి సుమారు 1.5k stars, main పై దాదాపు 490 commits ఉన్నాయి. అయితే release tags ఏవీ లేవు. ఈ చివరి విషయం install విధానాన్ని ప్రభావితం చేస్తుంది: git checkout v1.0.0 లో checkout చేయడానికి ఏదీ లేదు. అందువల్ల మీరు స్వయంగా ఒక commit ను pin చేయాలి. లేకపోతే మీరు clone చేసిన ఉదయం main లో ఉన్నదానినే run చేస్తారు.
Uptime Kuma మరియు Langfuse అందించని సమాచారాన్ని Superlog ఎలా అందిస్తుంది
Self-hosted మానిటరింగ్ టూల్స్ పైకి ఒకేలా కనిపిస్తాయి. కానీ అవి వేర్వేరు, తప్పు టూల్ను ఎంచుకోవడం వల్ల సర్వర్ వనరులు వృథా అవుతాయి.
- Uptime Kuma మీ ఎండ్పాయింట్లను బయటి నుంచి పరిశీలిస్తుంది మరియు అది పనిచేస్తుందా లేదా అనే ఒకే ప్రశ్నకు సమాధానమిస్తుంది.
- Zabbix మీ Ubuntu 24.04 హోస్ట్లు మరియు సర్వీసులను పర్యవేక్షిస్తుంది, మీరు సెట్ చేసిన పరిమితులకు అనుగుణంగా CPU, మెమరీ, డిస్క్ మరియు సర్వీస్ స్థితిని తనిఖీ చేస్తుంది.
- Langfuse LLM కాల్లను ట్రేస్ చేస్తుంది, ప్రతి కాల్కు సంబంధించిన ప్రాంప్ట్, మోడల్, టోకెన్లు, లేటెన్సీ మరియు ఖర్చును రికార్డ్ చేస్తుంది.
- Superlog మీ సాధారణ సర్వీసులు ఇప్పటికే పంపే టెలిమెట్రీని తీసుకుని, పదేపదే జరిగే వైఫల్యాలను ఇన్సిడెంట్స్గా మారుస్తుంది.
Superlog ఒక ప్రత్యేకమైన ప్రశ్నకు సమాధానమిస్తుంది: ఏదో విఫలమైంది, అది ఏమిటి మరియు ఎందుకు విఫలమైంది. దీనికి LLM కాల్లపై ఎటువంటి అభిప్రాయం లేదు మరియు ఇది బయటి నుంచి మిమ్మల్ని ప్రోబ్ చేయదు. ఇది మీ అప్లికేషన్ కోడ్ నుండి OTLPని స్వీకరిస్తుంది మరియు ట్రయాజ్ దశలో ఒక ఏజెంట్ను ఉంచుతుంది, ఇది ఆన్-కాల్లో ఉన్న వ్యక్తి చేసే మొదటి పని.
VPS బడ్జెట్ విషయంలో ముఖ్యమైన వ్యత్యాసం స్టోరేజ్. Uptime Kuma 1 GB RAMతో హాయిగా నడుస్తుంది, ఎందుకంటే ఇది కొన్ని వేల చెక్ ఫలితాలను మాత్రమే నిల్వ చేస్తుంది. Superlog ఒక కాలమ్ స్టోర్ను ఉపయోగిస్తుంది, ఎందుకంటే టెలిమెట్రీ ఒకసారి రాయబడి, మిలియన్ల కొద్దీ వరుసలలో సమయ పరిధిని బట్టి క్వెరీ చేయబడుతుంది. ClickHouse చేసే పని ఇదే, Postgres చేయలేని పని కూడా ఇదే. Postgres ఇప్పటికీ స్టాక్లోనే ఉంది, ఇది ప్రాజెక్ట్లు, వినియోగదారులు, ఇన్సిడెంట్లు మరియు ఇన్జెస్ట్ కీలు వంటి చిన్న రిలేషనల్ డేటాను కలిగి ఉంటుంది.
docker compose up -d వాస్తవంగా ఏమి ప్రారంభిస్తుంది?
మూడు containers ప్రారంభమవుతాయి. వాటిలో ఏదీ Superlog కాదు. ఒకే command తో మొత్తం install పూర్తవుతుందని భావించే వారికి ఇది ఆశ్చర్యంగా ఉంటుంది.
postgres:16, host port 5434 పై publish చేయబడుతుందిclickhouse/clickhouse-server:26.1, HTTP కోసం 8123 పై, native protocol కోసం 9000 పైotel/opentelemetry-collector-contrib:0.150.1, gRPC కోసం 4317 పై, HTTPపై OTLP కోసం 4318 పై
Superlog అప్లికేషన్లు host పై source నుంచి నడుస్తాయి. వాటిని pnpm dev ప్రారంభిస్తుంది. 13 October 2026 నాటికి repositoryలో production compose file లేదు. అందువల్ల దీర్ఘకాలిక install కోసం మీ స్వంత systemd units ఉపయోగించాలి లేదా treeలో ఉన్న ప్రతి appకు సంబంధించిన Dockerfiles ఉపయోగించాలి. api, worker, proxy appsలో unit చుట్టూ అమలు చేయడానికి ఒక్కొక్కదానికి start script ఉంది. web appకు అలాంటిది లేదు. అది Vite app కాబట్టి, దాని build scriptతో build చేసి outputను nginx లేదా Caddy నుంచి static filesగా serve చేయాలి. ప్రత్యామ్నాయంగా దాని preview scriptను నడపవచ్చు. అది vite preview.
ఒక request అనుసరించే మార్గాన్ని స్పష్టంగా గుర్తుంచుకోండి. దిగువ కనిపించే ప్రతి failure ఆ మార్గంలోని ఒక hop విరిగినప్పుడు సంభవిస్తుంది. మీ app OTLPను Superlog intake proxyకు post చేస్తుంది. proxy మీ ingest keyతో requestను authenticate చేసి, దానిపై project idను జత చేసి, collectorకు forward చేస్తుంది. client సెట్ చేయడానికి ప్రయత్నించిన ఏదైనా superlog.* attributesను collector తొలగిస్తుంది. proxy అందించిన header నుంచి superlog.project_idను జత చేస్తుంది. తరువాత dataను batchesగా చేసి ClickHouseలో రాస్తుంది. web app మరియు API telemetryని ClickHouse నుంచి తిరిగి చదువుతాయి. మిగతా data అంతా Postgres నుంచి చదువుతాయి.
ఆ attributes తొలగింపు నిజమైన multi-tenancy నియంత్రణ. ఇది కేవలం అలంకరణ కాదు. ఇది లేకపోతే, చెల్లుబాటు అయ్యే ఒక ingest key ఉన్న ఎవరైనా స్వయంగా superlog.project_idను సెట్ చేసి, మరొక project dataలో రాయగలరు.
VPS పరిమాణం ఎంత ఉండాలి?
తక్కువ ingest volume ఉన్న సింగిల్ నోడ్ ఇన్స్టాలేషన్ కోసం 4 vCPU, 8 GB RAM మరియు 40 GB SSD ఉండేలా ప్లాన్ చేసుకోండి. ఇది కేవలం ప్రాథమిక అంచనా మాత్రమే, కాబట్టి దీనిని ప్రారంభ పరిమాణంగా పరిగణించి, మీ ట్రాఫిక్ అవసరాలకు అనుగుణంగా సరిచూసుకోండి.
మెమరీ నాలుగు ప్రధాన భాగాలకు అవసరమవుతుంది. ClickHouse ఎక్కువ RAM ఉన్న మెషీన్ల కోసం రూపొందించబడింది, దాని డిఫాల్ట్ సెట్టింగ్లు కూడా అలాగే ఉంటాయి. Postgres 16 ఇక్కడ తక్కువ మెమరీని తీసుకుంటుంది, ఎందుకంటే ఇది టెలిమెట్రీ కంటే మెటాడేటాను మాత్రమే నిల్వ చేస్తుంది. కలెక్టర్ కూడా తక్కువ మెమరీనే వాడుతుంది. కానీ నాలుగు Node ప్రాసెస్లు అలా కాదు: ఒక Vite డెవలప్మెంట్ సర్వర్ మరియు మూడు tsx watch ప్రాసెస్లు ఒక్కొక్కటి వందల మెగాబైట్ల మెమరీని ఆక్రమిస్తాయి. అందుకే 2 GB RAM ఉన్న బాక్సులో pnpm dev రన్ చేయడం చాలా కష్టతరమైన పని.
డిస్క్ వినియోగం మరొక ముఖ్యమైన అంశం. ఈ monorepo లోని pnpm install, మీరు ఒక్క span ను కూడా ingest చేయకముందే AWS SDK, ClickHouse client, OpenTelemetry SDK మరియు React toolchain వంటి వాటిని డౌన్లోడ్ చేస్తుంది. ఆ తర్వాత మీ ట్రాఫిక్ను బట్టి ClickHouse డేటా పెరుగుతుంది. ఈ రెండింటినీ గమనించండి:
df -h /
free -m
docker stats --no-stream
docker compose exec clickhouse clickhouse-client --database superlog --query "SELECT table, formatReadableSize(sum(bytes_on_disk)) AS size FROM system.parts WHERE active AND database = 'superlog' GROUP BY table ORDER BY sum(bytes_on_disk) DESC"తక్కువ వాల్యూమ్ ఉన్నప్పుడు, అంటే కొన్ని సర్వీసులు నిమిషానికి కొన్ని వందల spans పంపుతున్నప్పుడు, సర్వర్ ప్రశాంతంగా ఉంటుంది మరియు ClickHouse చాలా సమయం ఖాళీగా ఉంటుంది. కానీ అకస్మాత్తుగా వచ్చే లోడ్ (burst) సమస్యలను కలిగిస్తుంది: ఉదాహరణకు, ఒక తప్పు డెప్లాయ్ వల్ల నిమిషానికి వేలకొద్దీ ఒకే రకమైన ఎర్రర్స్ రావడం. Fingerprinting వీటిని ఒకే ఇన్సిడెంట్గా చూపిస్తుంది, కానీ ClickHouse మాత్రం ప్రతి రోను (row) డేటాబేస్లో రాస్తూనే ఉంటుంది.
Retention పీరియడ్ను మీరే నిర్ణయించుకోవాలి. కలెక్టర్ యొక్క ClickHouse ఎక్స్పోర్టర్ టేబుళ్లను, otel_traces, otel_logs మరియు ప్రతి మెట్రిక్ రకానికి ఒక టేబుల్ను సృష్టిస్తుంది. infra/collector/config.yaml లోని కాన్ఫిగరేషన్లో సెట్ చేస్తే తప్ప, ఇది ఏ డేటాకు కూడా time to live (TTL) ను వర్తింపజేయదు. ఏదీ ఆటోమేటిక్గా డిలీట్ అవ్వదు కాబట్టి, మీరు ముందుగా ప్లాన్ చేసుకోకపోతే బిజీగా ఉండే నెలలో డిస్క్ నిండిపోయే అవకాశం ఉంది.
పిన్ చేసిన commit నుంచి ఇన్స్టాల్ చేయండి
git clone https://github.com/superloglabs/superlog.git
cd superlog
git tag -l
git log -1 --format='%H %cs %s'git tag -l ఏమీ ముద్రించకపోవడం 13 October 2026 నాటికి ఆశించిన ఫలితం. మీరు పరీక్షించిన commit ను ఎంచుకుని దానిపైనే ఉండండి:
git checkout 0d3a6c8bb63eda3493e6ba0003e7c2a70750bc1eతర్వాత toolchain:
node -v
corepack enable
corepack prepare pnpm@9.12.0 --activate
pnpm -vpackage.json, engines.node ను >=20.0.0 గా, packageManager ను pnpm@9.12.0 గా ప్రకటిస్తుంది. పాత Node పై install నడిపితే pnpm ERR_PNPM_UNSUPPORTED_ENGINE తో ఆగిపోతుంది. అది కోరిన version ను కూడా చూపిస్తుంది. Ubuntu 24.04 archive లోని nodejs package 20 కంటే పాతది. అందువల్ల Node 20 లేదా అంతకంటే కొత్త version ను NodeSource లేదా nvm నుంచి install చేయండి. Repository లో .nvmrc ఉంది. కాబట్టి nvm ఉపయోగిస్తే nvm use ఉద్దేశించిన version ను ఎంచుకుంటుంది.
pnpm install
docker compose up -d
docker compose psup -d అంటే service సిద్ధంగా ఉందని భావించకుండా, health checks పూర్తయ్యే వరకు వేచి ఉండండి. compose file లో Postgres మరియు ClickHouse రెండింటికీ health check ఉంది:
curl -sS http://127.0.0.1:8123/ping
pg_isready -h 127.0.0.1 -p 5434 -U postgresClickHouse Ok. కు సమాధానం ఇస్తుంది. pg_isready, accepting connections కు సమాధానం ఇస్తుంది. 8123 పై connection refused వస్తే container ఇంకా ప్రారంభమవుతోందని లేదా ఆగిపోయిందని అర్థం. ఏది జరిగిందో docker compose logs clickhouse చూపిస్తుంది. Kernel memory కారణంగా దాన్ని terminate చేసినప్పుడు docker inspect $(docker compose ps -q clickhouse) | grep -i oomkilled, true ను report చేస్తుంది. ఇది మీ config సమస్యకన్నా machine పరిమాణం తక్కువగా ఉందని సూచిస్తుంది.
తర్వాత migration మరియు applications:
pnpm --filter @superlog/db db:migrate
pnpm devPort ను గమనించండి: 5432 కాదు, 5434. Host పై ఇప్పటికే install చేసిన Postgres తో ఘర్షణ పడకుండా compose file Postgres ను 5434 పై publish చేస్తుంది. App యొక్క .env.example files కూడా ఇదే port ను ఉపయోగిస్తాయి, DATABASE_URL=postgres://postgres:postgres@localhost:5434/superlog తో. ఇప్పటికే Postgres నడుస్తున్న machine పై migration ను 5432 కు point చేస్తే connection refused రావచ్చు. ఇంకా దారుణంగా, migration తప్పు database పై అమలు కావచ్చు.
pnpm dev, turbo run dev ను run చేస్తుంది. ఇది Turborepo ద్వారా ప్రతి app యొక్క dev script ను ప్రారంభిస్తుంది. ఇందులో api, web, worker మరియు proxy ఉంటాయి. వాటి output అంతా ఒకే terminal లో కలిసిపోతుంది. Repository లోని Procfile ఇదే నాలుగు processes ను list చేస్తుంది. ప్రతి process యొక్క output ను tmp/logs/ లోకి tee చేస్తుంది. pnpm dev కు బదులుగా overmind లేదా foreman వంటి Procfile runner తో దీన్ని ప్రారంభించండి. అప్పుడు tail -f tmp/logs/proxy.log లో ingest ను monitor చేయవచ్చు. README web app ను http://localhost:5173 పై, API ను http://localhost:4100 పై, OTLP intake ను http://localhost:4101 పై ఉంచుతుంది.
ఏదైనా దానికి point చేయడానికి ముందు వాస్తవంగా ఏ port bind అయిందో నిర్ధారించండి:
ss -lntp | grep -E '4000|4100|4101|5173'
curl -sS http://127.0.0.1:4101/healthఇది తరువాత ముఖ్యమైనది. Proxy తన port ను PORT environment variable నుంచి చదువుతుంది. PORT unset అయితే 4000 ను fallback గా ఉపయోగిస్తుంది. అది load చేసే apps/proxy/.env.example కూడా PORT=4000 ను set చేస్తుంది. అయితే README intake ను 4101 పై చూపిస్తుంది (రెండింటినీ 13 October 2026 న తనిఖీ చేశారు). ss చూపించే port నే ఉపయోగించండి. దిగువ ఉదాహరణలు 4101 ను ఉపయోగిస్తున్నాయి. Bind అయిన port 4000 అయితే 4000 తో మార్చండి. మీరు స్వయంగా రాసిన systemd unit లో PORT పెట్టకపోతే అది ఏదీ set చేయదు. అందువల్ల 4000 పై వినే proxy కి 4101 ను లక్ష్యంగా చేసుకున్న exporter connection refused తో విఫలమవుతుంది. దీనికి మరే ఇతర స్పష్టమైన సూచన ఉండదు.
ఒక trace పంపండి, ఒక error ను సృష్టించండి, ఒక incident ను చూడండి
వెబ్ యాప్లో ఒక ప్రాజెక్ట్ను సృష్టించి, దాని ingest key ని కాపీ చేయండి. intake ప్రతి అభ్యర్థనను ఆ key తో ప్రామాణీకరిస్తుంది, కాబట్టి ఆ key లేకుండా పంపిన telemetry ఏదీ ClickHouse కు చేరదు.
ఏదైనా OpenTelemetry SDK ని కింది standard environment variables ఉపయోగించి intake వైపు మళ్లించండి:
export OTEL_SERVICE_NAME=checkout-api
export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_ENDPOINT=http://127.0.0.1:4101
export OTEL_EXPORTER_OTLP_HEADERS='x-api-key=YOUR_INGEST_KEY'intake ఈ key ని x-api-key header నుండి చదువుతుంది, ఒకవేళ మీ exporter ను ఆ విధంగా కాన్ఫిగర్ చేయడం సులభమైతే authorization: bearer YOUR_INGEST_KEY ని కూడా అంగీకరిస్తుంది. ఇది మూడు standard OTLP paths, అంటే /v1/traces, /v1/logs మరియు /v1/metrics, అలాగే /health లపై సేవలను అందిస్తుంది.
ఒక ముఖ్యమైన పొరపాటును గమనించాలి. OTEL_EXPORTER_OTLP_ENDPOINT అనేది ఒక base URL, SDK దీనికి signal path ని కలుపుతుంది. OTEL_EXPORTER_OTLP_TRACES_ENDPOINT వంటి signal-specific variables ను ఎటువంటి path కలపకుండా, ఉన్నది ఉన్నట్లుగా ఉపయోగించాలి. ఒకవేళ signal-specific variable ను http://127.0.0.1:4101 కి సెట్ చేస్తే, ప్రతి export / కి పంపబడుతుంది. ఇది సరైన route కాదు, కాబట్టి ఏ డేటా చేరదు మరియు మీ యాప్ ఆరోగ్యంగా ఉన్నట్లు కనిపించినప్పటికీ, SDK లో export failure కనిపిస్తుంది.
Node సర్వీస్ కోసం, pipeline ని పరీక్షించడానికి zero code path సరిపోతుంది:
npm install @opentelemetry/api @opentelemetry/auto-instrumentations-node
node --require @opentelemetry/auto-instrumentations-node/register server.jsఇప్పుడు ఉద్దేశపూర్వకంగా ఏదైనా తప్పు చేయండి. error ని ఇచ్చే ఏదైనా route సరిపోతుంది:
curl -sS -o /dev/null -w '%{http_code}\n' http://127.0.0.1:3000/boomhops ను వరుసగా తనిఖీ చేయండి, ఎందుకంటే మొదటి gap ఎక్కడ ఏర్పడిందో అదే విఫలమైన భాగాన్ని సూచిస్తుంది:
tail -n 50 tmp/logs/proxy.log
docker compose exec clickhouse clickhouse-client --database superlog --query 'SELECT count() FROM otel_traces'వెబ్ యాప్లో ఏమీ లేనప్పుడు otel_traces లో count పెరుగుతుంటే, అది project mismatch అని అర్థం, కాబట్టి ingest key ఏ ప్రాజెక్ట్కు చెందినదో తనిఖీ చేయండి. proxy log లో activity ఉండి, count పెరగకపోతే, అది collector లేదా ClickHouse write లో సమస్య అని అర్థం, కాబట్టి docker compose logs collector ని చదవండి. proxy log లో ఎటువంటి activity లేకపోతే, exporter అసలు intake ని చేరుకోలేదని అర్థం: అంటే తప్పు port, తప్పు path, లేదా తిరస్కరించబడిన key కారణం కావచ్చు.
వెబ్ యాప్లో, ఆ పదేపదే వచ్చే failures ప్రతి అభ్యర్థనకు ఒక row లా కాకుండా, ఒకే incident గా కనిపిస్తాయి. Superlog ఇన్కమింగ్ సిగ్నల్స్ను fingerprint చేసి, సరిపోలే వాటిని గ్రూప్ చేస్తుంది. దీనివల్ల 4,000 ఒకే రకమైన errors తో inbox నిండిపోకుండా, ఒకే పేజీలో incident కనిపిస్తుంది. ఆ తర్వాత agent ఆ గ్రూప్ పైన తన విశ్లేషణను రాస్తుంది.
విశ్లేషణ దశ ఒక model ని పిలుస్తుంది, కాబట్టి worker కి ఒక model provider కాన్ఫిగర్ చేయబడి ఉండాలి. ఆ variable పేర్లను మీరు pin చేసిన commit లోని ప్రతి app directory లో ఉన్న .env.example ఫైల్ నుండి తీసుకోండి, బయట ఉన్న డాక్యుమెంటేషన్ నుండి కాదు, ఎందుకంటే అవి main తో పాటు మారుతుంటాయి. GitHub మరియు Sentry integrations కు కూడా ఇదే వర్తిస్తుంది; వాటికి సంబంధించిన setup పత్రాలు docs/github-app-setup.md మరియు docs/sentry-app-setup.md లలో ఉంటాయి, మరియు webhook payloads వివరాలు docs/webhooks.md లో డాక్యుమెంట్ చేయబడ్డాయి.
ఇన్టేక్ను ప్రైవేట్గా ఉంచి, agent కు read-only అనుమతి ఇవ్వండి
Docker container ports ను డిఫాల్ట్గా 0.0.0.0 పై publish చేస్తుంది. ఈ published ports ufw ను దాటిపోతాయి. Docker container traffic ను nat table లో route చేస్తుంది. అందువల్ల published port కు వచ్చిన packet, ufw నియమాలు ఉన్న INPUT మరియు OUTPUT chains కు చేరకముందే మళ్లించబడుతుంది. ufw కు దానిపై నియంత్రణ ఉండదు. Public IP ఉన్న VPS లో, అందిన compose file ClickHouse HTTP ను 8123 పై, Postgres ను 5434 పై ఉంచుతుంది. ఈ ports ను internet నుంచి చేరుకోవచ్చు. ఆ file లోని credentials development defaults. ClickHouse user default మరియు password ఖాళీగా ఉంటాయి. Postgres లో postgres ను user మరియు password రెండింటిగానూ ఉపయోగిస్తుంది.
వాటిని loopback కు bind చేయండి. Compose file లోని ప్రతి published port తన host-side విలువను environment variable నుంచి తీసుకుంటుంది. అందువల్ల repository root లో .env file ఉంటే సరిపోతుంది:
POSTGRES_HOST_PORT=127.0.0.1:5434
CLICKHOUSE_HTTP_HOST_PORT=127.0.0.1:8123
CLICKHOUSE_TCP_HOST_PORT=127.0.0.1:9000
COLLECTOR_GRPC_HOST_PORT=127.0.0.1:4317
COLLECTOR_HTTP_HOST_PORT=127.0.0.1:4318దాన్ని నమ్మే ముందు ఫలితాన్ని ధృవీకరించండి. తరువాత containers ను మళ్లీ సృష్టించండి:
docker compose config
docker compose up -d
ss -lntp | grep -E '5434|8123|9000|4317|4318'docker compose config resolved file ను ప్రింట్ చేస్తుంది. అందువల్ల ఊహించకుండా 127.0.0.1:5434:5432 ను చదవవచ్చు. అప్పుడు ss లో 127.0.0.1:5434 కనిపించాలి. 0.0.0.0:5434 మాత్రం ఎప్పుడూ కనిపించకూడదు. దీన్ని compose override file తో సరిచేయడానికి ప్రయత్నించవద్దు. ఆ file లో ports ను మళ్లీ ప్రకటిస్తే, Compose వివిధ files లోని port lists ను కలిపేస్తుంది; వాటిని భర్తీ చేయదు. ఫలితంగా రెండు bindings ఉంటాయి. Public binding ఇంకా తెరిచి ఉంటుంది.
ఇన్టేక్కూ ఇదే జాగ్రత్త అవసరం. మీ ingest key header లో పంపబడుతుంది. అందువల్ల దాని ముందు TLS (transport layer security) అవసరం. Proxy ముందు nginx లేదా Caddy లో TLS termination చేయండి. లేదా ingest ను private network లో లేదా WireGuard tunnel లో ఉంచండి. 5173 పై నడిచే web app ఒక Vite development server. ఇది internet కు అసలు అందుబాటులో ఉండకూడదు.
తరువాత agent ను పరిశీలించండి. Superlog యొక్క ప్రధాన ఉద్దేశం agent దర్యాప్తు చేసి ఒక పరిష్కారాన్ని ప్రతిపాదించడమే. ఇక్కడ ముఖ్యమైన పదం “ప్రతిపాదిస్తుంది”. కొన్ని నిజమైన incidents పై agent పనిచేసే విధానాన్ని గమనించే వరకు production కు వ్యతిరేకంగా దానికి read-only అనుమతినే ఇవ్వండి. GitHub App కు read scopes ఇవ్వండి. అది pull requests తెరవగలిగేలా చేయండి, కానీ వాటిని మీరు review చేయాలి. Telemetry చదివి patch రాసే agent ఉపయోగకరంగా ఉంటుంది. మీ services ను restart చేయగల agent వేరే స్థాయి ప్రమాదం. అలాంటి అనుమతి default గా ఇవ్వకండి. దాన్ని ఉద్దేశపూర్వకంగా మీరు నిర్ణయించాలి. ఖర్చుకూ ఇదే శ్రద్ధ అవసరం, ఎందుకంటే ప్రతి investigation ఒక model call. Noisy production system పై agent ను ఉపయోగించే ముందు VPS పై agent ఖర్చు కోసం బడ్జెట్ కేటాయించండి. అలాగే agent నిజంగా చేసిన పనుల రికార్డును ఉంచండి, తద్వారా అనూహ్యమైన pull request కు audit trail ఉంటుంది.
మీరు ఎదుర్కొనే వైఫల్యాలు మరియు వాటిని గుర్తించే సందేశాలు
ERR_PNPM_UNSUPPORTED_ENGINEసమయంలోpnpm installకనిపిస్తే Node వెర్షన్ 20 కంటే పాతదని అర్థం.node -vదీన్ని ఒకే లైన్లో నిర్ధారిస్తుంది.- migration సమయంలో
ECONNREFUSED 127.0.0.1:5434కనిపిస్తే compose stack నడుస్తూ లేదు లేదాDATABASE_URLలో తప్పు port పేర్కొన్నారు. - ClickHouse పదేపదే restart అవుతుంటే కారణం సాధారణంగా memory సమస్యే.
docker compose logs clickhouseచదివి, తరువాత containerలోOOMKilled,trueగా ఉందో పరిశీలించండి. - web app ఖాళీగా ఉన్నప్పటికీ exporter విజయాన్ని నివేదిస్తే, data నేరుగా 4318లోని collectorకు వెళ్లి ఉండవచ్చు. అలా జరిగితే proxy చేసే project stamping దశ తప్పిపోతుంది.
- 4101లో connection refused కనిపిస్తే, proxy 4000లో listening చేస్తోందని సాధారణంగా అర్థం. ఇది code fallbackగా ఉపయోగించే port, అలాగే దాని
.env.exampleసెట్ చేసే port కూడా. unit fileలో లేదా app యొక్క.envలోPORTను స్పష్టంగా సెట్ చేయండి. docker compose psలో0.0.0.0:8123కనిపిస్తే loopback bindings అమలులో లేవని అర్థం.docker compose configను అమలు చేసి resolved ports చదవండి.
Flawless, HyperProbe, మరియు Superlog స్థానం
ఈ విభాగం కొత్తది, మరియు ఏ ఏజెంట్కు దేనిని తాకే అనుమతి ఉందనే విషయంలో సాధనాలు భిన్నంగా ఉంటాయి. Flawless అనేది Kubernetes కోసం రూపొందించబడిన ఒక open source AI SRE (site reliability engineering) సాధనం. ఇది పైప్లైన్ను తన ఆధీనంలో ఉంచుకోకుండా, ఇప్పటికే ఉన్న Prometheus, Loki మరియు Grafana stack నుండి సమాచారాన్ని చదువుతుంది. HyperProbe దీనికి భిన్నంగా పనిచేస్తుంది: ఇది ఒక hosted product. ఆగస్టు 2026 నాటికి ఇది closed source గా ఉంది. ఇది రన్ అవుతున్న process లోపల read-only probes ను ఉంచి, variable state ను సేకరిస్తుంది మరియు ఆ సమాచారాన్ని MCP (model context protocol) ద్వారా ఒక assistant కు అందిస్తుంది.
Superlog ఈ రెండింటి మధ్య ఉంటుంది. ఇది OTLP intake నుండి ClickHouse storage వరకు పైప్లైన్ మొత్తాన్ని తన ఆధీనంలో ఉంచుకుంటుంది. ఇది ఏజెంట్ను fix చేసే దశలో కాకుండా, triage చేసే దశలో ఉంచుతుంది. ఆ డిజైన్ కారణంగానే, దీన్ని self-host చేయడం అనేది ఒక మౌలిక సదుపాయాల (infrastructure) నిర్ణయం అవుతుంది, అంతే కానీ ఇది కేవలం మనం మర్చిపోయే ఒక container కాదు. మీరు Superlog ను రన్ చేస్తున్నారంటే, మీరు ఒక column store ను రన్ చేస్తున్నారని అర్థం. మీరు నిర్వహించే ఇతర database లకు ఇచ్చే జాగ్రత్తే దీనికి కూడా అవసరం.
FAQ
self-hosted Superlog కు ఎంత RAM అవసరం?
తక్కువ ingest పరిమాణంలో ఒకే node కోసం 8 GB RAM, 4 vCPU మరియు 40 GB disk కేటాయించండి. ఈ stack లో Postgres, ClickHouse, ఒక OpenTelemetry collector మరియు నాలుగు Node processes ఉంటాయి. ClickHouse కు అదనపు headroom అవసరం. 1 GB లేదా 2 GB VPS సరిపోదు: pnpm install ఒక్కటే ఎక్కువ వనరులు వినియోగిస్తుంది. Load సమయంలో kernel out of memory killer ClickHouse ను terminate చేయవచ్చు. ప్రచురించిన ఏ గణాంకాన్నీ, ఇందులో ఉన్నదాన్నీ కూడా, నమ్మకుండా docker stats --no-stream మరియు free -m తో మీ స్వంత గణాంకాలను కొలవండి.
నా OTLP exporter ను ఏ port కు point చేయాలి?
README లో http://localhost:4101 పై configure చేసిన Superlog intake proxy కు point చేయండి. ఇది /v1/traces, /v1/logs మరియు /v1/metrics ను అందిస్తుంది. ఇది మీ project యొక్క ingest key తో authentication చేస్తుంది. ఆ key ను x-api-key header లేదా authorization: bearer header నుంచి తీసుకుంటుంది. Port 4318 కింద నడుస్తున్న OpenTelemetry collector కు చెందినది. అక్కడికి నేరుగా export చేస్తే proxy దాటిపోతుంది. Data పై మీ project id ను జతచేసేది proxy. PORT unset గా ఉంటే proxy port 4000 కు fallback అవుతుంది. దాని .env.example కూడా 4000 ను set చేస్తుంది. అందువల్ల 4101 అని ఊహించే ముందు ss -lntp run చేసి అది ఏ port కు bind అయిందో నిర్ధారించండి.
Superlog, Uptime Kuma లేదా Zabbix స్థానాన్ని భర్తీ చేస్తుందా?
లేదు. మీ network వెలుపల నుంచి endpoint స్పందిస్తుందో లేదో Uptime Kuma నిర్ధారిస్తుంది. మీరు నిర్ణయించిన thresholds కు అనుగుణంగా host మరియు service metrics ను Zabbix monitor చేస్తుంది. మీ applications పంపే traces, logs మరియు metrics ను Superlog స్వీకరించి, పదేపదే సంభవించే failures ను incidents గా సమూహపరుస్తుంది. దీనితో పాటు external uptime probe ను ఉంచండి. ఎందుకంటే మీ telemetry pipeline ఉన్న server నే ఆ probe వేరే చోటు నుంచి monitor చేస్తే, అది server నిలిచిపోయిన విషయాన్ని కూడా తెలియజేస్తుంది.
Superlog agent నా production systems ను మార్చగలదా?
మీరు ఇచ్చిన permissions పరిధిలో మాత్రమే మార్చగలదు. దీని output ఒక investigation మరియు ప్రతిపాదిత change. వీటిని మానవుడు review చేస్తాడు. మొదట GitHub App ను read scopes కు పరిమితం చేసి, pull requests ను ఉంచండి. Worker వద్ద ఉన్న credentials ను కూడా reading కు మాత్రమే పరిమితం చేయండి. Production కు write access ఇవ్వడం ప్రత్యేకంగా, ఉద్దేశపూర్వకంగా తీసుకోవాల్సిన నిర్ణయంగా పరిగణించండి. Services ను restart చేయగల agent కు production telemetry చదివి review కోసం patch రాసే agent కంటే చాలా ఎక్కువ బాధ్యత ఉంటుంది.
నేను ఒక commit ను pin చేయాలా లేదా main ను track చేయాలా?
ఒక commit ను pin చేయండి. 13 October 2026 నాటికి repository లో release tags లేవు. అందువల్ల main మాత్రమే అందుబాటులో ఉన్న moving target. ఇది వారానికి అనేక commits తీసుకుంటుంది. మీరు పరీక్షించిన SHA ను నమోదు చేసి, అదే version ను deploy చేయండి. ముందుకు వెళ్లే ముందు diff ను చదవండి. git log --oneline <old-sha>..main review కోసం ఉపయోగించాల్సినది. ఏదైనా bump చేసిన తర్వాత కొత్తగా అవసరమైన variables కోసం ముందుగా చూడాల్సినవి ప్రతి app కు చెందిన .env.example files.