Sentry ప్రత్యామ్నాయాలు: self-hosted error tracking ఖర్చు
Sentry deployment profileను బట్టి RAM అవసరం మారుతుంది. GlitchTip 512 MBలో నడుస్తుంది. RAM, disk పెరుగుదల, containerల సంఖ్య, upgrade ఇబ్బందులను పోల్చండి.
ఒక్క event ను కూడా నిల్వ చేయకముందే self-hosted error tracking కు అయ్యే ఖర్చు
self-hosted error tracking విషయంలో మొత్తం ఎంపికను నిర్ణయించే ఒక ముఖ్యమైన అంశం ఉంది: అవసరమైన కనిష్ఠ RAM. Feature-complete stack కోసం Sentry అధికారిక self-hosted documentation లో 4 CPU cores, 16 GB RAM తో పాటు 16 GB swap, మరియు 20 GB ఖాళీ disk అవసరమని పేర్కొంటుంది. ఇవి మీ application ఒక్క event ను పంపకముందే అవసరమయ్యే వనరులు. Errors-only profile కోసం installer thresholds తక్కువగా ఉంటాయి: Docker కు అందుబాటులో 2 CPU cores మరియు 7000 MB RAM ఉండాలి. GlitchTip documentation లో 512 MB అవసరమని పేర్కొంటుంది. ఇక్కడి అన్ని options ఒకే Sentry SDKs నుంచి events స్వీకరిస్తాయి. కాబట్టి ఇది మీ code లో instrumentation ఎలా చేయాలనే నిర్ణయం కాదు. మీరు ఎంత పెద్ద server కోసం చెల్లించి, దాన్ని నిరంతరం నడిపించడానికి సిద్ధంగా ఉన్నారనే నిర్ణయం ఇది.
ప్రచురించిన వనరుల గణాంకాలు, పక్కపక్కనే
ఇవి అక్టోబర్ 2026 నాటికి ప్రతి ప్రాజెక్ట్ తన గురించి ప్రచురించిన గణాంకాలు. ఇవన్నీ ఒకే రకమైన కొలతలు కావు. అందువల్ల పోల్చే ముందు ప్రతి వరుసలోని గమనికను చదవండి.
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
{
"tool": "Sentry feature-complete",
"published_ram_gb": 16,
"notes": "documented minimum for the feature-complete profile, plus 16 GB of swap"
},
{
"tool": "Bugsink",
"published_ram_gb": 4,
"notes": "the vendor's own published benchmark box, 2 vCPU"
},
{
"tool": "GlitchTip",
"published_ram_gb": 0.5,
"notes": "documented recommendation, 256 MB stated as the minimum"
}
]Sentry పేర్కొన్న 16 GB పూర్తి ఫీచర్లు ఉన్న profile కోసం document చేసిన కనిష్ఠ పరిమాణం. అదే పేజీ 32 GB ను కూడా సిఫార్సు చేస్తుంది. GlitchTip పేర్కొన్న 0.5 GB ఒక సిఫార్సు మాత్రమే. ఈ ప్రాజెక్ట్ 256 MB ను పనిచేసే కనిష్ఠ పరిమాణంగా పేర్కొంటుంది. జాగ్రత్తగా configuration చేస్తే 128 MB మరియు swap తో కూడా పనిచేయవచ్చని చెబుతుంది. Bugsink పేర్కొన్న 4 GB ఈ రెండింటిలో ఏదీ కాదు. ఇది vendor తన స్వంత throughput benchmark కోసం ఉపయోగించిన machine పరిమాణం. ప్రచురించిన గణాంకం ప్రారంభ బిందువు మాత్రమే. మీ event volume గురించి అది హామీ ఇవ్వదు.
Sentry self-hosted: ఉత్పత్తిలో ఎక్కువ భాగం, మొత్తం నిర్వహణ భారం
అధికారిక stack getsentry/self-hosted. ఇది Docker Compose project. Productionలో Sentry నడిపే అదే components ఇందులో అమలవుతాయి. దీని documentationలో కొన్ని మినహాయింపులు ఉన్నాయి. వాటిలో Seer, ఇతర closed source AI మరియు ML features, billing, spike protection, అలాగే కొంత platform support ఉన్నాయి. మీకు Sentry featuresలో ఎక్కువ భాగం లభిస్తాయి. ఆ features పనిచేయడానికి అవసరమైన అన్ని భాగాలు కూడా మీరే నిర్వహించాలి.
master నుంచి కాకుండా, tag చేసిన release నుంచి install చేయండి:
VERSION=$(curl -Ls -o /dev/null -w %{url_effective} https://github.com/getsentry/self-hosted/releases/latest)
VERSION=${VERSION##*/}
git clone https://github.com/getsentry/self-hosted.git
cd self-hosted
git checkout ${VERSION}
./install.shFeature-complete profile defaultగా ఉంటుంది. errors-only కోసం చిన్న stackను install చేయాలంటే, ./install.sh అమలు చేయడానికి ముందు .env లో COMPOSE_PROFILES=errors-only ను set చేయండి.
తర్వాత దీన్ని start చేయండి:
docker compose up --waitSentry defaultగా అన్ని host interfacesపై port 9000ను publish చేస్తుంది. దాన్ని localhostకు bind చేయాలంటే .env లో SENTRY_BIND=127.0.0.1:9000 ను set చేయండి. Docker Engine 19.03.6 లేదా తర్వాతి version, Docker Compose 2.32.2 లేదా తర్వాతి version అవసరం. Installer రెండింటినీ తనిఖీ చేస్తుంది. పాత Compose version ఉంటే ./install.sh ఆగిపోతుంది. అప్పుడు FAIL: Expected minimum తో ప్రారంభమయ్యే lineలో కనుగొన్న version పేరు కనిపిస్తుంది, అలాగే script errorతో exit అవుతుంది. x86-64 hostsలో official ClickHouse 26.6 మరియు తర్వాతి imagesకు AVX2తో సహా పూర్తి x86-64-v3 CPU feature set కూడా అవసరం.
మీరు నిజంగా start చేసిన వాటిని పరిశీలించండి:
docker compose ps
free -hdocker compose ps stackలోని ప్రతి serviceను list చేస్తుంది. ఆ జాబితా పొడవుగా ఉంటుంది: Postgres, ClickHouse, Kafka, Valkey, Compose service name redis కింద, Relay, Snuba, Symbolicator, అలాగే అనేక worker మరియు cron processes. ఆ సంఖ్యను ఒకసారి లెక్కించండి. అదే మీ maintenance load. ప్రతి entry crash కావచ్చు, diskను నింపవచ్చు లేదా migrationను విఫలం చేయవచ్చు.
ఏదైనా service Restarting stateలో ఉంటే, ముందుగా memoryని పరిశీలించండి:
dmesg -T | grep -i 'out of memory'Out of memory: Killed process 3412 (java) వంటి line కనిపిస్తే, kernel యొక్క OOM killer (out of memory killer) ఒక containerను terminate చేసిందని అర్థం. Hostలో RAM అయిపోవడం వల్ల ఇది జరుగుతుంది. అందువల్ల ఆ service healthy stateకు రాదు, stack startup పూర్తికాదు. Installer అందుబాటులో ఉన్న RAMను కూడా తనిఖీ చేస్తుంది. నిర్దేశించిన కనిష్ఠ పరిమితికంటే తక్కువ RAM ఉన్న machineను అది తిరస్కరిస్తుంది. Documentation disk speed గురించి కూడా హెచ్చరిస్తుంది. iowait 10% కంటే ఎక్కువగా ఉంటే, ingest pipelineను machine తగిన వేగంతో నిర్వహించలేకపోతుందని సాధారణంగా అర్థం. దీన్ని top లోని wa column నుంచి చదవండి. లేదా sysstat install చేసి ఉంటే iostat -x 5 నుంచి చదవండి.
చాలామంది తక్కువగా అంచనా వేసే భాగం upgrades
Sentry self-hosted ప్రతి నెల CalVer కింద release అవుతుంది. ఇది calendar ఆధారిత version scheme. ప్రతి నెల 15వ తేదీన primary release వస్తుంది. పాత version నుంచి నేరుగా latest versionకు upgrade చేయలేరు. Project hard stop versionsను నిర్వచిస్తుంది. Database migrations వరుసగా అమలయ్యేలా ప్రతి versionను క్రమంలో checkout చేయాలి. October 2026 నాటికి ప్రచురించిన hard stops ఇవి: 9.1.2, 21.5.0, 21.6.3, 23.6.2, 23.11.0, 24.8.0, 25.5.1, 26.5.0 మరియు 26.7.0. Migration problems కారణంగా skip చేయాల్సిన releasesను కూడా documentationలో పేర్కొన్నారు. వాటిలో 23.7.0, 25.9.0, 25.12.0 మరియు 26.3.0 నుంచి 26.4.0 వరకు ఉన్న range ఉన్నాయి.
Upgrade అంటే checkout చేసి installerను మళ్లీ run చేయడం:
git fetch
git checkout 26.7.0
./install.sh
docker compose up --waitప్రారంభించే ముందు serverకు snapshot తీసుకోండి. పెద్ద ClickHouse datasetపై migration గంటలపాటు నడవవచ్చు. మధ్యలో failure వస్తే database రెండు schemas మధ్యలో ఉండిపోవచ్చు. Self-hosted Sentry upgrades విఫలమయ్యే ప్రధాన కారణం సులభమే: machine ఒక సంవత్సరం పాటు ఒకే versionలో ఉండిపోయింది. అందువల్ల upgradeలో ఒకేసారి అనేక hard stops దాటాల్సి వస్తుంది. వాటిలో skip చేయబడిన migrationలలో ఒకటి అవసరమైనదై ఉండవచ్చు.
మీరు నిర్ణయం తీసుకునే ముందు మరో విషయం తెలుసుకోవాలి. Sentry self-hosted, Sentry స్వయంగా ప్రవేశపెట్టిన Functional Source License (FSL) కింద ఉంది. ఇది OSI approved open source కాదు; fair source. మీరు దీన్ని మీ కోసం run చేయవచ్చు. కానీ పోటీ serviceగా దీన్ని విక్రయించకూడదు. ప్రతి release విడుదలైన రెండు సంవత్సరాల తర్వాత Apache 2.0కు మారుతుంది.
GlitchTip: 512 MB సమాధానం
GlitchTip MIT లైసెన్స్ కింద అందుబాటులో ఉంటుంది. ఇది Sentry యొక్క open source SDKs నుంచి events స్వీకరిస్తుంది. అందువల్ల instrumented application ను ఒక విలువ మార్చడం ద్వారా తరలించవచ్చు: DSN (data source name, మీ SDK events ను POST చేసే URL).
GlitchTip 7.0 కు PostgreSQL 15 లేదా తరువాతి version అవసరం. Valkey లేదా Redis 7 లేదా తరువాతి version ఐచ్ఛికం. ఇవి పెద్ద instances లో పనితీరును మెరుగుపరుస్తాయి.
ఇన్స్టాలేషన్కు Docker మరియు ఒక compose file చాలు:
sudo apt install docker.io
curl -O https://glitchtip.com/assets/compose.sample.yml
mv compose.sample.yml compose.ymlఏదైనా ప్రారంభించే ముందు environment section ను సవరించండి. secret మరియు domain సెట్ చేయండి. Email alerts మరియు password resets కావాలంటే mail ను కూడా configure చేయండి:
SECRET_KEY: <output of openssl rand -base64 50>
GLITCHTIP_DOMAIN: https://errors.example.com
DEFAULT_FROM_EMAIL: errors@example.com
EMAIL_URL: smtp://user:password@smtp.example.com:587మీ installation కు సంబంధించిన PostgreSQL connection string కు DATABASE_URL ను సెట్ చేయండి. GLITCHTIP_DOMAIN లో scheme తప్పనిసరిగా ఉండాలి. ముందు https:// లేకపోతే alert emails లోని links తప్పుగా రూపొందుతాయి. అవి స్పందించని URL కు దారి తీస్తాయి.
దాన్ని ప్రారంభించి, మొదటి boot ను monitor చేయండి:
docker compose up -d
docker compose logs -f webImage tags ను pinned గా ఉంచండి. compose file లో latest ఉంటే, తదుపరి docker compose pull సమయంలో కొత్త database engine ను fetch చేస్తుంది. తరువాత docker compose up -d container ను మళ్లీ సృష్టించినప్పుడు ఆ engine కు మారుతుంది. ఇప్పటికే ఉన్న data directory కింద Postgres major version మారడం వల్ల పనిచేస్తున్న error tracker ప్రారంభం కాకుండా పోవచ్చు.
256 MB నుంచి 512 MB పరిధికి చేరుకోవడానికి Valkey మరియు optional log, uptime features ను disable చేయండి. Valkey లేకుండా నడిపితే GlitchTip cache మరియు queue పనుల కోసం తన database ను ఉపయోగిస్తుంది. ఇది నెమ్మదిగా ఉంటుంది, కానీ సరైన విధంగానే పనిచేస్తుంది. All in one mode worker ను web process లోనే నడుపుతుంది. అందువల్ల రెండు application containers బదులుగా ఒకటినే నిర్వహించాలి.
దాని ముందు proxy ఉంచండి. Requests ను buffer చేసి chunked Transfer-Encoding ను handle చేసే proxy లేదా load balancer ను ఉపయోగించాలని GlitchTip documentation చెబుతుంది. అందులో nginx ను ఉదాహరణగా చూపిస్తుంది. Buffering లేకపోతే slow client మొత్తం upload సమయంలో application worker ను ఆక్రమించి ఉంచుతుంది. అందువల్ల కొద్దిమంది slow senders మీ వద్ద ఉన్న ప్రతి worker ను ఆక్రమించవచ్చు. ఆరోగ్యంగా ఉన్న clients కు timeouts రావడం ప్రారంభమవుతుంది.
Major versions మధ్య upgrade చేసే ముందు release notes చదవండి. మీరు 5.x ఉపయోగిస్తుంటే GlitchTip 7.0 కోసం ముందుగా 6.x కు upgrade చేయండి. GlitchTip 6.x లో ఉన్నప్పుడే PostgreSQL 14 కు upgrade చేయండి. Application image tag ను 7 కు మార్చే ముందు renamed environment variables, removed startup settings, కొత్త TRUSTED_PROXIES default మరియు మారిన permissions ను తనిఖీ చేయండి. తరువాత pull చేసి restart చేయండి:
docker compose pull
docker compose stop
docker compose up -dప్రారంభ సమయంలో database migrations స్వయంచాలకంగా అమలవుతాయి. అయినప్పటికీ ముందుగా dump తీసుకోండి. ఎందుకంటే automatic migration కూడా migrationనే.
Bugsink: ఒక container, తప్పనిసరిగా చదవాల్సిన licence
మూడు సాధనాల్లో Bugsink అత్యంత తేలికైనది. ఇది Sentry SDK protocol ను ఉపయోగిస్తుంది. Message queue లేదా database తప్ప మరే external service అవసరం లేకుండా నడుస్తుంది. SQLite default గా ఉంటుంది. మీరు దాని సామర్థ్యాన్ని మించితే MySQL మరియు PostgreSQL కూడా support చేస్తాయి.
మీరు నిర్ణయం తీసుకునే ముందు interface ను చూడటానికి తాత్కాలిక instance:
docker pull bugsink/bugsink:latest
docker run \
-e SECRET_KEY=PUT_AN_ACTUAL_RANDOM_SECRET_HERE_OF_AT_LEAST_50_CHARS \
-e CREATE_SUPERUSER=admin@example.org:admin \
-e PORT=8000 \
-p 8000:8000 \
bugsink/bugsinkhttp://localhost:8000/ ను తెరిచి, CREATE_SUPERUSER లో ఇచ్చిన address మరియు password తో sign in చేయండి. ఈ container ను remove చేసినప్పుడు దాని data కోల్పోతుంది. నిజమైన instance కోసం project యొక్క compose sample ను ఉపయోగించండి. అందులో bugsink/bugsink:2 ను postgres:17-alpine తో జత చేసి, DATABASE_URL, BASE_URL మరియు BEHIND_HTTPS_PROXY ను set చేస్తుంది. Secret ను సరైన విధంగా generate చేయండి:
openssl rand -base64 50BASE_URL మీరు users మరియు SDKs వాస్తవంగా ఉపయోగించే URL తో సరిపోవాలి. ఇందులో scheme కూడా ఉండాలి. మీరు https://errors.example.com ద్వారా చేరుకునే machine పై దీన్ని http://localhost:8000 గా ఉంచితే, notification email లోని ప్రతి link చదివే వ్యక్తికి resolve కాని host ను చూపిస్తుంది. nginx లేదా Caddy దాని ముందు TLS (transport layer security) ను terminate చేస్తే BEHIND_HTTPS_PROXY ను true గా set చేయండి. అలాగే X-Forwarded-Proto: https ను forward చేయండి. అప్పుడు Bugsink secure requests ను గుర్తిస్తుంది, దాని CSRF checks సరైన scheme ను ఉపయోగిస్తాయి.
Vendor ప్రచురించిన throughput గణాంకాలు ఇవి: ప్రతి event 50 KB పరిమాణంతో, సెకనుకు 18 events. ఇది 2 vCPU మరియు 4 GB VPS పై రోజుకు 1.5 million events కు సమానం. దీన్ని మీ workload కు హామీగా కాకుండా, ఈ tool సామర్థ్య పరిమాణంగా పరిగణించండి. ఒక చిన్న application ఉత్పత్తి చేసే పరిమాణం కంటే దీని ceiling చాలా ఎక్కువగా ఉందని ఇది సూచిస్తుంది.
ఇప్పుడు licence గురించి. మీ stack లోకి చేర్చే ముందు చదవాల్సిన ముఖ్యమైన భాగం ఇదే. Bugsink ను PolyForm Shield License 1.0.0 కింద release చేస్తారు. ఇది source available, open source కాదు. మీరు దీన్ని run చేయవచ్చు, modify చేయవచ్చు. కానీ Bugsink తో పోటీ పడే software ను నిర్మించడానికి దీన్ని ఉపయోగించకూడదు. Internal error tracker కోసం ఈ restriction సాధారణంగా వర్తించదు. మీ company developer tooling ను విక్రయిస్తే, ముందుగా licence text ను ఎవరైనా పరిశీలించాలి.
Error tracking మరియు LLM observability ఇప్పటికీ రెండు వేర్వేరు సాధనాలు
Error tracking మరియు large language model (LLM) observability రెండింటినీ కలిపి అందించే ఒకే సాధనం కోసం వెతికితే, రెండింటినీ అందిస్తామని చెప్పుకునే ఉత్పత్తులు కనిపిస్తాయి. కానీ వాటి డేటా నిర్మాణాలు వేరుగా ఉండటం వల్ల, ఈ రెండింటి విలీనం సాధ్యపడటం లేదు. ఒక error tracker మినహాయింపును (exception) దాని stack trace తో సహా స్వీకరించి, దాని నుండి ఒక fingerprint ను రూపొందించి, వేలకొద్దీ సంఘటనలను ఒకే సమస్యగా మార్చి లెక్కిస్తుంది. ఒక LLM tracing సాధనం మాత్రం prompt, response, token count మరియు latency ఉన్న span ను స్వీకరిస్తుంది. ఇది ప్రతి సంఘటనను భద్రపరచాలి, ఎందుకంటే ఒకే రకమైన inputs ఉన్న రెండు calls కూడా విడివిడి సంఘటనలే, వాటిని విడిగా పరిశీలించాల్సి ఉంటుంది.
కాబట్టి రెండింటినీ ఉపయోగించండి. Exceptions ను error tracker కు పంపండి, మరియు model calls ను వాటి కోసం ప్రత్యేకంగా రూపొందించిన చోటికి పంపండి: agent tracing కోసం self-hosted Langfuse ఆ అవసరాన్ని తీరుస్తుంది, మరియు self-hosted AI observability అదే పనిని వేరొక కోణంలో చూస్తుంది. మీ అప్లికేషన్ ఇప్పటికే ఈ రెండు రకాల వైఫల్యాలను ఉత్పత్తి చేస్తోంది. ఒక model call నమ్మదగిన తప్పుడు సమాచారాన్ని (confident nonsense) ఇచ్చినప్పుడు ఎటువంటి exception రాదు, కాబట్టి error tracker దానిని మీకు ఎప్పటికీ చూపించదు.
డిస్క్ పెరుగుదల తర్వాత మిమ్మల్ని ఇబ్బందిలోకి నెడుతుంది
ప్రతి error tracker అనేది అధికంగా write చేసే, పరిమితి లేని input కలిగిన database. అప్లికేషన్ ఎంత డేటా రాస్తుందో అది నిర్ణయిస్తుంది. Hot code pathలో వచ్చిన ఒక కొత్త bug రాత్రికిరాత్రే ఒక million events సృష్టించవచ్చు.
GlitchTip ప్రణాళిక కోసం ఉపయోగపడే ఒక గణాంకాన్ని అందిస్తుంది: నెలకు one million events నిర్వహించే instance కు 30 GB disk అవసరం కావచ్చు. ఆ ingestలో ఎంత భాగాన్ని నిల్వ ఉంచాలో మీ retention window నిర్ణయిస్తుంది.
Bugsink దీనిని మరో విధంగా నిర్వహిస్తుంది. స్థిర quota బదులుగా event count మరియు event age ఆధారంగా retention algorithm అమలు చేస్తుంది. ఇది పరిమితులను నేరుగా చూపిస్తుంది: MAX_RETENTION_EVENT_COUNT configured project retention counts మొత్తం budget ను నిర్దేశిస్తుంది, అలాగే MAX_RETENTION_PER_PROJECT_EVENT_COUNT ప్రతి project setting కు గరిష్ఠ పరిమితిని విధిస్తుంది. ఇవి configuration guardrails. మీరు bugsink-manage delete_old_events లేదా bugsink-manage vacuum --old-events అమలు చేసినప్పుడు MAX_EVENT_AGE_DAYS absolute age cut ను అందిస్తుంది. Event count byte limit కాదని గుర్తుంచుకుని, వాస్తవంగా నిల్వ చేస్తున్న event sizes ఆధారంగా event budget ను నిర్ణయించండి.
Serverలోని వాస్తవ సంఖ్యలను పరిశీలించండి:
df -h /
docker system df -v
du -sh /var/lib/docker/volumes/*docker system df -v ప్రతి volume పరిమాణాన్ని చూపిస్తుంది. అందువల్ల ఏ service పెరుగుతోందో చూడవచ్చు. Trafficలో మార్పు లేకుండా ఒక volume వారానికి అనేక gigabytes పెరుగుతుంటే, retention window ఇంకా డేటాను నింపుతోందని లేదా మీ event rate వద్ద partition సామర్థ్యాన్ని మించిపోయే డేటాను నిల్వ చేస్తోందని సాధారణంగా అర్థం. Retention ను మార్చకుండా వదిలేయడం వల్ల ఏదీ expire కాదని కాదు: Sentryతో వచ్చే .env, SENTRY_EVENT_RETENTION_DAYS=90 ను నిర్దేశిస్తుంది. GlitchTipలో GLITCHTIP_RETENTION_DAYS defaultగా 90 ఉంటుంది. Partition పూర్తిగా నిండే వరకు వేచి ఉండకుండా, disk సామర్థ్యానికి సరిపోయేలా window ను తగ్గించండి.
Memory సమస్య కూడా ఇదే, కానీ వేరే రూపంలో కనిపిస్తుంది. Limits లేని stack, kernel అందించే మొత్తం memoryని ఉపయోగిస్తుంది. Machineలో memory అయిపోయినప్పుడు OOM killer అత్యధిక badness score ఉన్న processను terminate చేస్తుంది. ఈ scoreను kernel ప్రధానంగా ప్రతి process ఉపయోగించే memory పరిమాణం ఆధారంగా లెక్కించి, దాని oom_score_adj ఆధారంగా సర్దుబాటు చేస్తుంది. అందువల్ల సమస్యకు కారణమైన tracker కాకుండా మీ web server terminate కావచ్చు. ప్రతి serviceకు ఒక ceiling ఇవ్వండి: Docker Composeలో memory limits syntaxను, container తన capను చేరుకున్నప్పుడు ఏమి జరుగుతుందో చూపిస్తుంది. Container తన స్వంత limit వద్ద terminate అయితే అది పరిమితమైన failure. Host memory పూర్తిగా అయిపోతే పక్కన నడుస్తున్న services కూడా ప్రమాదంలో పడతాయి.
ఏ VPS కు ఏ stack సరిపోతుంది
- 1 GB, లేదా అదనపు సామర్థ్యంతో 2 GB: Valkey ఆపివేసిన all in one mode లో GlitchTip లేదా SQLite పై Bugsink. కొన్ని అప్లికేషన్లకు ఈ రెండూ సరిపోతాయి.
- 4 GB: PostgreSQL తో Bugsink లేదా Valkey ప్రారంభించి, ప్రత్యేక worker service తో GlitchTip. ఈ పరిమాణంలో tuning ఆపి నేరుగా అమలు చేయవచ్చు.
- 8 GB: Docker కనీసం 7000 MB RAM ను గుర్తించినప్పుడు, అధికారిక Sentry errors-only profile installer యొక్క RAM తనిఖీని దాటుతుంది; దీనికి 2 CPU cores కూడా అవసరం. Installation కు ముందు
COMPOSE_PROFILES=errors-onlyను.envలో సెట్ చేయండి. - కనీసం 16 GB, సిఫార్సు 32 GB: అధికారిక Sentry feature-complete self-hosted stack ను, తేలికైన projects అమలు చేయని Sentry feature అవసరమైనప్పుడు మాత్రమే ఉపయోగించండి. ముందుగా ఆ feature ను ప్రతి project documentation తో సరిపోల్చి తనిఖీ చేయండి, ఎందుకంటే సాధారణ అవసరాలకు అనుకూలమైన projects అందుబాటులో ఉన్నాయి.
మీరు ఏదైనా అమలు చేసినా, error tracker తన స్వంత నిలిచిపోవడాన్ని నివేదించలేడు. వేరే machine నుంచి దాన్ని పర్యవేక్షించండి: మరో box నుంచి పర్యవేక్షించే Uptime Kuma tracker down అయిందని తెలియజేస్తుంది. అదే సమయంలో మీ application errorలను సృష్టించడం ప్రారంభిస్తుంది, కానీ వాటిని నమోదు చేసే tracker అందుబాటులో ఉండదు.
హోస్ట్ చేసిన ప్లాన్ చౌకైన ఎంపికగా ఉన్నప్పుడు
Data residency నియమాల కారణంగా మీ డేటాను మీరే హోస్ట్ చేయాల్సి వచ్చినప్పుడు లేదా event volume ఎక్కువగా ఉండి ప్రతి event కు వసూలు చేసే ధర భారంగా మారినప్పుడు self-hosting error tracker ప్రయోజనకరంగా ఉంటుంది. ఆ పరిస్థితులు లేకపోతే లెక్కలను వాస్తవికంగా పరిశీలించండి. Sentry యొక్క documented feature-complete కనీస అవసరాలు 16 GB RAM, 4 cores మరియు fast disk కలిగిన server. ఆ పరిమాణంలోని VPS చౌకైన VPS కాదు. Errors-only profile కోసం installer thresholds తక్కువగా ఉంటాయి: 2 cores మరియు Docker కు కనిపించే 7000 MB RAM. దీనికి operational పనిని కూడా జోడించాలి: ప్రతి hard stop ను క్రమంగా అధిగమించడం, ప్రతి migration కు ముందు snapshot తీసుకోవడం, అలాగే సంవత్సరానికి కొన్ని సార్లు ఈ ప్రక్రియను నిర్వహించడం.
GlitchTip మరియు Bugsink ఈ లెక్కలను పూర్తిగా మార్చేస్తాయి. 512 MB నుంచి 4 GB వరకు ఉన్న server తక్కువ ఖర్చుతో లభిస్తుంది. సాధారణ Docker updates కోసం image pull చేసి restart చేస్తే సరిపోతుంది. అయితే major upgrades కు ముందు release notes మరియు database requirements పరిశీలించాలి. అందుకే ఈ ప్రశ్న అడిగే చాలామంది official stack కంటే compatible projects లో ఒకదాన్ని ఎంచుకుంటారు. వారికి error tracking కావాలి, నిరంతరం పర్యవేక్షించాల్సిన distributed data pipeline కాదు.
మీ server లో అసలు ఏ సేవలు ఉండాలో ఇంకా నిర్ణయిస్తున్నట్లయితే, self-hosting కు విలువైన సేవల విస్తృత జాబితా అదే RAM కోసం పోటీ పడే ఇతర సేవల పక్కన error tracking ను కూడా చూపిస్తుంది.
FAQ
2 GB VPS పై Sentry ను స్వయంగా హోస్ట్ చేయవచ్చా?
లేదు. Sentry యొక్క errors-only profile కు కూడా Docker కోసం 2 CPU cores మరియు కనీసం 7000 MB RAM అందుబాటులో ఉండాలి. Feature-complete documentation ప్రకారం కనీసం 4 CPU cores, 16 GB RAM, అదనంగా 16 GB swap, అలాగే 20 GB ఖాళీ disk అవసరం. ఈ stack ఒకేసారి Postgres, ClickHouse, Kafka, Valkey మరియు అనేక worker processes ను నడుపుతుంది. RAM తనిఖీ సమయంలో installer 2 GB వ్యవస్థను తిరస్కరిస్తుంది. Containers నిలిపివేయబడుతుంటే, ఏ process నిలిపివేయబడిందో చూపించే dmesg -T | grep -i 'out of memory' ను పరిశీలించండి. 2 GB VPS కోసం 512 MB అవసరమని documentation లో పేర్కొన్న GlitchTip ను ఉపయోగించండి. SQLite పై single container గా నడిచే Bugsink ను కూడా ఉపయోగించవచ్చు.
Sentry నుంచి GlitchTip లేదా Bugsink కు మారడానికి application code మార్చాలా?
లేదు. రెండూ Sentry యొక్క open source SDKs నుంచి events ను స్వీకరిస్తాయి. అందువల్ల ఇప్పటికే install చేసిన SDK ను అలాగే ఉంచి, ఒక విలువను మాత్రమే మార్చాలి: DSN. DSN అనేది SDK events ను post చేసే URL. అది code లో hardcoded గా ఉంటే environment variable కు మార్చండి. తరువాత దాన్ని కొత్త host కు చూపించి, test exception ను trigger చేసి అది చేరుతుందో monitor చేయండి. ఏదీ కనిపించకపోతే DSN లోని project identifier కొత్త server లో ఉన్న project కు సరిపోతుందో తనిఖీ చేయండి. అలాగే application ఆ host మరియు port ను చేరుకోవడానికి firewall అనుమతిస్తుందో పరిశీలించండి.
Self-hosted error tracking కు ఎంత disk అవసరం?
ఇది tool పై కాకుండా event volume మరియు retention window పై ఆధారపడి ఉంటుంది. నెలకు one million events ను నిర్వహించే instance కోసం GlitchTip 30 GB ను సూచిస్తుంది. Bugsink లో MAX_RETENTION_EVENT_COUNT తో project retention ను configure చేసి, cleanup commands ద్వారా MAX_EVENT_AGE_DAYS ను అమలు చేయవచ్చు. అయినప్పటికీ disk sizing event sizes మరియు database overhead పై ఆధారపడి ఉంటుంది. మొదటి రోజే retention ను తనిఖీ చేయండి. Sentry మరియు GlitchTip రెండూ default గా 90 day window తో వస్తాయి. మీ event rate వద్ద ఇది మీ disk సామర్థ్యాన్ని మించవచ్చు. Disk లో పట్టే పరిమాణం కంటే ఎక్కువ data ను tracker నిల్వ చేస్తే, వినియోగం పెరుగుతూ df -h 100% చూపిస్తుంది. ఆ సమయంలో ingest ఆగిపోతుంది. మీరు అత్యంతగా చూడాలనుకున్న errors కోల్పోతారు.
Self-hosted Sentry ను upgrade చేస్తే పదేపదే ఎందుకు విఫలమవుతోంది?
Upgrade సమయంలో తప్పనిసరిగా ఆపాల్సిన version ను దాటవేయడం వల్ల ఇది జరుగుతుంది. Sentry self-hosted లో database migrations కలిగిన నిర్దిష్ట versions ఉన్నాయి. వాటి ద్వారా తప్పనిసరిగా క్రమంగా వెళ్లాలి. October 2026 నాటికి ఆ versions 9.1.2, 21.5.0, 21.6.3, 23.6.2, 23.11.0, 24.8.0, 25.5.1, 26.5.0 మరియు 26.7.0. పాత release నుంచి నేరుగా తాజా release కు వెళ్లడం వల్ల ఈ migrations దాటిపోతాయి. అందువల్ల schema మరియు code పరస్పరం సరిపోక upgrade మధ్యలో ఆగిపోతుంది. ప్రతి hard stop వద్ద క్రమంగా checkout చేసి ./install.sh ను అమలు చేయండి. ప్రారంభించే ముందు server snapshot తీసుకోండి. నివారించాల్సిన releases జాబితాను documentation లో చదవండి. అందులో 23.7.0, 25.9.0 మరియు 25.12.0 ఉన్నాయి.