SSD Nodes Learn Hosting plans →
מדריכים Matt Connorמאת Matt Connor

חלופות ל-Sentry בניהול עצמי: השוואת משאבים וביצועים

מתלבטים אם להריץ Sentry בניהול עצמי? גלו את דרישות הזיכרון המינימליות, השוו בין GlitchTip ל-Sentry ובדקו את צריכת ה-RAM האמיתית לפני שתבחרו את פתרון הניטור שלכם.

מה העלות של מערכת ניטור שגיאות בניהול עצמי לפני אחסון אירוע בודד

למערכת ניטור שגיאות בניהול עצמי יש נתון אחד שקובע את ההחלטה כולה, והוא רף ה-RAM המינימלי. התיעוד הרשמי של Sentry לניהול עצמי דורש 4 ליבות CPU, זיכרון RAM בנפח 16 GB בתוספת 16 GB של swap, ו-20 GB של שטח דיסק פנוי עבור חבילת השירות המלאה, וזאת עוד לפני שהיישום שלכם שלח אירוע אחד. פרופיל ה-errors-only של המערכת מציב רף כניסה נמוך יותר: 2 ליבות CPU ו-7000 MB של RAM זמין עבור Docker. לעומת זאת, GlitchTip מציינת דרישה של 512 MB. כל האפשרויות כאן מקבלות אירועים מאותם ה-SDKs של Sentry, כך שזו אינה החלטה הנוגעת לאופן שבו אתם מבצעים אינסטרומנטציה לקוד שלכם. זו החלטה הנוגעת לגודל השרת שאתם מוכנים לשלם עבורו ולתחזק אותו פעיל.

נתוני משאבים מפורסמים, זה לצד זה

אלו הם הנתונים שכל פרויקט מפרסם אודות עצמו, נכון לאוקטובר 2026. אין מדובר באותו סוג של מדידה, לכן יש לקרוא את ההערה בכל שורה לפני ביצוע השוואה.

תרשיםPublished RAM figures per error tracking stack, October 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"
  }
]

הערך 16 GB של Sentry הוא מינימום מתועד עבור פרופיל עם מלוא התכונות, ואותו דף ממליץ על 32 GB. הערך 0.5 GB של GlitchTip הוא המלצה, כאשר הפרויקט מציין 256 MB כמינימום לעבודה, או 128 MB בתוספת swap עם הגדרה זהירה. הערך 4 GB של Bugsink אינו אף אחד מאלה: זהו המפרט הטכני של השרת שבו השתמש הספק עבור מדד ה-throughput שלו. נתון מפורסם הוא נקודת התחלה, לא הבטחה לגבי נפח האירועים שלכם.

Sentry בניהול עצמי: רוב המוצר, וכל החשבון

החבילה הרשמית היא getsentry/self-hosted, פרויקט Docker Compose שמריץ את אותם רכיבים ש־Sentry מריצה בסביבת הייצור. התיעוד שלה מפרט החרגות, כולל Seer ותכונות AI ו־ML אחרות בקוד סגור, חיוב, הגנה מפני עומסים (spike protection) ותמיכה בחלק מהפלטפורמות. אתם מקבלים את רוב התכונות של Sentry, ואת כל הרכיבים הדינמיים שגורמים לתכונות הללו לעבוד.

התקינו מתוך גרסה מתויגת (tagged release) ולא מתוך master:

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.sh

פרופיל הפיצ'רים המלא הוא ברירת המחדל. כדי להתקין את החבילה המצומצמת לשגיאות בלבד, הגדירו את COMPOSE_PROFILES=errors-only בתוך .env לפני הרצת ./install.sh.

לאחר מכן הפעילו אותה:

docker compose up --wait

Sentry מפרסמת את פורט 9000 על כל ממשקי המארח כברירת מחדל; הגדירו את SENTRY_BIND=127.0.0.1:9000 בתוך .env כדי לקשור אותו ל־localhost. נדרשים Docker Engine בגרסה 19.03.6 ומעלה ו־Docker Compose בגרסה 2.32.2 ומעלה, והמתקין בודק את שניהם: גרסת Compose ישנה תעצור את ./install.sh עם שורה שמתחילה ב-FAIL: Expected minimum שמציינת את הגרסה שנמצאה, והסקריפט יסתיים עם שגיאה. במארחי x86-64, תמונות ClickHouse רשמיות מגרסה 26.6 ומעלה דורשות גם את סט תכונות המעבד המלא x86-64-v3, כולל AVX2.

בדקו מה באמת הפעלתם:

docker compose ps
free -h

docker compose ps מציג כל שירות בחבילה, והרשימה ארוכה: Postgres, ClickHouse, Kafka, Valkey (תחת שם שירות ה-Compose redis), Relay, Snuba, Symbolicator, וכמה תהליכי worker ו-cron. ספרו אותם פעם אחת, כי המספר הזה הוא עומס התחזוקה שלכם. כל רשומה היא תהליך שיכול לקרוס, למלא את הדיסק או להיכשל בביצוע מיגרציה.

אם שירות נמצא במצב Restarting, בדקו את הזיכרון לפני כל דבר אחר:

dmesg -T | grep -i 'out of memory'

שורה כמו Out of memory: Killed process 3412 (java) משמעותה ש-OOM killer (מנגנון הריגת תהליכים עקב חוסר זיכרון) של ה-kernel לקח מכולה כי לשרת נגמר ה-RAM, לכן השירות לעולם לא הופך לתקין והחבילה לעולם לא מסיימת לעלות. המתקין גם בודק את ה-RAM הזמין ודוחה מכונה שנמצאת מתחת למינימום האכיפה שלו. התיעוד גם מסמן את מהירות הדיסק: iowait מעל 10% כנראה אומר שהמכונה לא מצליחה לעמוד בקצב של צינור העיבוד (ingest pipeline). קראו זאת מעמודת wa בתוך top, או מ-iostat -x 5 אם מותקן אצלכם sysstat.

שדרוגים הם החלק שאנשים ממעיטים בערכו

Sentry בניהול עצמי משתחררת מדי חודש תחת CalVer, שיטת גרסאות מבוססת לוח שנה, עם גרסה ראשית ב-15 לכל חודש. אי אפשר לקפוץ מגרסה ישנה ישר לגרסה האחרונה. הפרויקט מגדיר גרסאות "עצירה קשיחה" (hard stop), ועליכם לבצע checkout לכל אחת מהן לפי הסדר כדי להחיל את המיגרציות של מסד הנתונים. נכון לאוקטובר 2026, נקודות העצירה הקשיחות שפורסמו הן 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. התיעוד גם מפרט גרסאות שיש לדלג עליהן בגלל בעיות מיגרציה, כולל 23.7.0, 25.9.0, 25.12.0 והטווח שבין 26.3.0 ל-26.4.0.

שדרוג הוא ביצוע checkout והרצה חוזרת של המתקין:

git fetch
git checkout 26.7.0
./install.sh
docker compose up --wait

בצעו Snapshot לשרת לפני שתתחילו, כיוון שמיגרציה על סט נתונים גדול של ClickHouse יכולה להימשך שעות, וכישלון באמצע הדרך משאיר את מסד הנתונים בין שני סכימות. הסיבה הפשוטה לרוב השדרוגים הכושלים של Sentry בניהול עצמי: השרת נשאר על גרסה אחת במשך שנה, כך שהקפיצה חוצה כמה נקודות עצירה קשיחות בבת אחת, ואחת המיגרציות שדלגתם עליהן הייתה זו שהייתה קריטית.

עוד דבר אחד שכדאי לדעת לפני שמתחייבים. Sentry בניהול עצמי נמצאת תחת רישיון Functional Source License (FSL), ש-Sentry עצמה הציגה. זהו "קוד הוגן" (fair source) ולא קוד פתוח מאושר OSI: מותר לכם להריץ אותו עבור עצמכם, ואסור לכם למכור אותו כשירות מתחרה. כל גרסה הופכת ל-Apache 2.0 שנתיים לאחר שחרורה.

GlitchTip: הפתרון ל-512 MB

GlitchTip מופץ תחת רישיון MIT ומקבל אירועים מ-SDKs בקוד פתוח של Sentry. לכן, העברת יישום מנוטר מתבצעת על ידי שינוי ערך אחד: ה-DSN (Data Source Name, ה-URL שאליו ה-SDK שולח אירועים). GlitchTip 7.0 דורש PostgreSQL 15 ומעלה. Valkey או Redis 7 ומעלה הם אופציונליים, אך הם מאיצים מופעים גדולים יותר.

ההתקנה מתבצעת באמצעות Docker וקובץ compose אחד:

sudo apt install docker.io
curl -O https://glitchtip.com/assets/compose.sample.yml
mv compose.sample.yml compose.yml

ערכו את סעיף ה-environment לפני שתתחילו בתהליך כלשהו. הגדירו את ה-secret ואת ה-domain, והגדירו דואר אלקטרוני אם ברצונכם לקבל התראות במייל ואיפוס סיסמאות:

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

הגדירו את DATABASE_URL למחרוזת החיבור של PostgreSQL עבור ההתקנה שלכם. GLITCHTIP_DOMAIN חייב לכלול את ה-scheme. ללא https:// בתחילת הכתובת, הקישורים בהתראות המייל ייווצרו באופן שגוי ויפנו ל-URL שאינו מגיב.

הפעילו את השירות ועקבו אחר האתחול הראשון:

docker compose up -d
docker compose logs -f web

שמרו על תגיות image מקובעות. קובץ compose שמציין latest ימשוך מנוע מסד נתונים חדש ב-docker compose pull הבא ויעבור אליו בפעם הבאה ש-docker compose up -d יצור מחדש את ה-container. קפיצת גרסה ראשית של Postgres תחת ספריית נתונים קיימת היא הדרך שבה כלי מעקב שגיאות תקין מפסיק לעבוד.

כדי להגיע לטווח של 256 MB עד 512 MB, השביתו את Valkey ואת תכונות ה-log וה-uptime האופציונליות. הרצה ללא Valkey משמעותה ש-GlitchTip משתמש במסד הנתונים שלו עבור עבודות cache ו-queue; זה איטי יותר אך עדיין תקין. מצב "הכל באחד" (all in one) מריץ את ה-worker בתוך תהליך ה-web, כך שאתם מתחזקים container יישום אחד במקום שניים.

הציבו proxy לפניו. התיעוד של GlitchTip דורש proxy או load balancer שמבצע buffering לבקשות ומטפל ב-Transfer-Encoding מקוטע, והוא מציע את nginx כדוגמה עובדת. ללא buffering, לקוח איטי מחזיק worker של היישום פתוח לאורך כל ה-upload, כך שמספר שולחים איטיים יכולים לתפוס את כל ה-workers שברשותכם ולקוחות תקינים יתחילו לקבל שגיאות timeout.

קראו את הערות השחרור (release notes) לפני שדרוג בין גרסאות ראשיות. עבור GlitchTip 7.0, שדרגו תחילה ל-6.x אם אתם בגרסה 5.x, ושדרגו את PostgreSQL 14 בעודכם ב-GlitchTip 6.x. בדקו משתני סביבה ששמם שונה, הגדרות אתחול שהוסרו, ברירת המחדל החדשה של TRUSTED_PROXIES והרשאות שהשתנו לפני שינוי תגית ה-image של היישום ל-7. לאחר מכן בצעו pull ואתחול:

docker compose pull
docker compose stop
docker compose up -d

מיגרציות של מסד הנתונים רצות אוטומטית בעת האתחול. בכל מקרה, בצעו dump תחילה, כיוון שמיגרציה אוטומטית היא עדיין מיגרציה.

Bugsink: מכולה אחת, ורישיון שחובה לקרוא

Bugsink הוא הקל ביותר מבין השלושה. הוא תומך בפרוטוקול ה-Sentry SDK, ופועל ללא תור הודעות וללא שירות חיצוני מלבד מסד נתונים. SQLite הוא ברירת המחדל, עם תמיכה ב-MySQL וב-PostgreSQL כאשר תזדקקו ליכולות גבוהות יותר.

מופע זמני (throwaway), כדי להתרשם מהממשק לפני שתחליטו:

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/bugsink

פתחו את http://localhost:8000/ והתחברו עם הכתובת והסיסמה שהעברתם ב-CREATE_SUPERUSER. מכולה זו מאבדת את הנתונים שלה ברגע שהיא מוסרת. עבור מופע אמיתי, השתמשו ב-compose sample של הפרויקט, המשלב את bugsink/bugsink:2 עם postgres:17-alpine ומגדיר את DATABASE_URL, BASE_URL ו-BEHIND_HTTPS_PROXY. צרו את ה-secret בצורה תקינה:

openssl rand -base64 50

הערך ב-BASE_URL חייב להתאים ל-URL שהמשתמשים וה-SDK שלכם משתמשים בו בפועל, כולל ה-scheme. אל תשאירו אותו על http://localhost:8000 בשרת שאליו אתם ניגשים דרך https://errors.example.com, אחרת כל קישור בהודעת דוא"ל יצביע על מארח שלא ניתן לפתור עבור האדם שקורא אותו. הגדירו את BEHIND_HTTPS_PROXY ל-true כאשר Nginx או Caddy מבצעים TLS termination לפניו, והעבירו את X-Forwarded-Proto: https, כדי ש-Bugsink יזהה בקשות מאובטחות ובדיקות ה-CSRF שלו ישתמשו ב-scheme הנכון.

הספק מפרסם נתוני תעבורה משלו: 18 אירועים בשנייה בגודל 50 KB כל אחד, מה שמסתכם ב-1.5 מיליון אירועים ביום, על גבי VPS עם 2 vCPU ו-4 GB זיכרון. התייחסו לנתונים אלו כאל הערכה למבנה הכלי ולא כהתחייבות לעומס העבודה שלכם. עם זאת, זה מעיד על כך שהתקרה גבוהה בהרבה ממה שיישום קטן מייצר.

כעת לגבי הרישיון, וזה החלק שחובה לקרוא לפני שהוא נכנס ל-stack שלכם. Bugsink משוחרר תחת רישיון PolyForm Shield License 1.0.0. זהו רישיון source available, לא קוד פתוח: מותר לכם להריץ אותו ולשנות אותו, אך אסור לכם להשתמש בו כדי לבנות מוצר שמתחרה ב-Bugsink. עבור מערכת פנימית למעקב אחר שגיאות, הגבלה זו אינה רלוונטית. אם החברה שלכם מוכרת כלי פיתוח, ודאו שמישהו קורא את טקסט הרישיון תחילה.

מעקב אחר שגיאות וניטור LLM הם עדיין שני כלים נפרדים

חפשו כלי אחד שמבצע גם מעקב אחר שגיאות וגם ניטור (observability) של מודלי שפה גדולים (LLM), ותמצאו מוצרים שטוענים שהם עושים את שניהם. מבני הנתונים שונים, וזו הסיבה שהמיזוג ביניהם לא מתרחש. כלי למעקב אחר שגיאות מקבל חריגה (exception) עם stack trace, מחשב עבורה טביעת אצבע (fingerprint), ומאחד אלפי מופעים לבעיה אחת עם מונה. כלי לניטור LLM מקבל span המכיל prompt, תגובה, ספירת tokens וזמן תגובה (latency), ועליו לשמור את כל אחד מהם בנפרד; זאת מכיוון ששתי קריאות עם קלטים זהים הן עדיין אירועים נפרדים שראוי לבחון.

לכן, הריצו את שניהם. שלחו חריגות לכלי המעקב אחר שגיאות, ושלחו קריאות למודל למקום שנבנה עבורן: Langfuse בהתקנה עצמית למעקב אחר סוכנים מכסה את הצד הזה, ו-ניטור AI בהתקנה עצמית ניגש לאותה משימה מזווית אחרת. היישום שלכם כבר מייצר את שני סוגי הכשלים. קריאה למודל שמחזירה תשובה שגויה בביטחון עצמי אינה זורקת חריגה כלל, ולכן כלי למעקב אחר שגיאות לעולם לא יציג לכם אותה.

גידול בנפח הדיסק הוא כשל שמתגלה באיחור

כל מערכת למעקב אחר שגיאות היא מסד נתונים עתיר כתיבות עם קלט בלתי מוגבל. היישום שלכם קובע את היקף הכתיבה, ובאג חדש בנתיב קוד פעיל עלול לייצר מיליון אירועים במהלך לילה אחד.

GlitchTip מפרסמת נתון שכדאי לתכנן לפיו: מופע שמטפל במיליון אירועים בחודש עשוי להזדקק ל-30 GB של שטח דיסק. חלון השמירה (retention) שלכם קובע כמה מתוך הקלט הזה יישמר.

Bugsink ניגשת לנושא מהכיוון ההפוך. במקום מכסה קבועה, היא מפעילה אלגוריתם שמירה המבוסס על כמות אירועים וגיל האירוע, והיא חושפת את המגבלות ישירות: MAX_RETENTION_EVENT_COUNT מגדירה את סכום כמויות השמירה המוגדרות לפרויקטים, ו-MAX_RETENTION_PER_PROJECT_EVENT_COUNT מגבילה את ההגדרה של כל פרויקט. אלו הם מנגנוני הגנה בתצורה. MAX_EVENT_AGE_DAYS מספקת סף גיל מוחלט בעת הרצת bugsink-manage delete_old_events או bugsink-manage vacuum --old-events. קבעו את תקציב האירועים בהתאם לגודל האירועים המאוחסנים בפועל, שכן כמות אירועים אינה שקולה למגבלת בתים.

עקבו אחר המספרים האמיתיים על השרת:

df -h /
docker system df -v
du -sh /var/lib/docker/volumes/*

docker system df -v מציגה את גדלי הנפחים, כך שתוכלו לראות איזה שירות הוא זה שגדל. נפח שגדל בכמה ג'יגה-בייט בשבוע ללא שינוי בתעבורה מעיד בדרך כלל על כך שחלון השמירה עדיין מתמלא, או שהוא מכיל יותר ממה שהמחיצה יכולה להכיל בקצב האירועים שלכם. השארת הגדרות השמירה ללא שינוי אינה אומרת שדבר אינו פג תוקף: ה-.env שמגיע עם Sentry מגדיר את SENTRY_EVENT_RETENTION_DAYS=90, וערך ברירת המחדל של GLITCHTIP_RETENTION_DAYS ב-GlitchTip הוא 90. הקטינו את החלון כדי שיתאים לדיסק במקום להמתין למילוי המחיצה.

זיכרון הוא אותה בעיה בתחפושת אחרת. מחסנית ללא מגבלות תצרוך כל מה שה-kernel מציע, וכאשר המכונה תגיע לקצה גבול היכולת, ה-OOM killer יחסל את התהליך עם ציון ה-badness הגבוה ביותר, שה-kernel מחשב בעיקר לפי כמות הזיכרון שכל תהליך צורך, בתוספת התאמה לפי oom_score_adj. ייתכן מאוד שזה יהיה שרת האינטרנט שלכם ולא מערכת המעקב שגרמה לבעיה. הגדירו לכל שירות תקרה: מגבלות זיכרון ב-Docker Compose מציג את התחביר ואת התנהגות המכולה כשהיא מגיעה למכסה שלה. מכולה שמחוסלת בגלל מגבלה של עצמה היא כשל מבודד. מיצוי זיכרון של המארח מסכן גם את השירותים השכנים.

איזה stack מתאים לאיזה VPS

  • 1 GB, או 2 GB עם מרווח נשימה: GlitchTip במצב all in one עם Valkey כבוי, או Bugsink על גבי SQLite. שניהם ירוצו בנוחות על הגדרות אלו עבור מספר קטן של יישומים.
  • 4 GB: Bugsink עם PostgreSQL, או GlitchTip עם Valkey פעיל ושירות worker נפרד. זהו הגודל שבו ניתן להפסיק לבצע כוונונים ולהריץ את השירות כפי שהוא.
  • 8 GB: הפרופיל הרשמי של Sentry (עבור שגיאות בלבד) עובר את בדיקת ה-RAM של תוכנית ההתקנה כאשר Docker מזהה לפחות 7000 MB; הוא דורש גם 2 ליבות CPU. הגדירו את COMPOSE_PROFILES=errors-only בתוך .env לפני ההתקנה.
  • 16 GB מינימום, 32 GB מומלץ: ה-stack הרשמי והמלא של Sentry בהתקנה עצמית, וזאת רק אם אתם זקוקים לפיצ'ר של Sentry שפרויקטים קלים יותר אינם מיישמים. בדקו תחילה את הפיצ'ר הספציפי מול התיעוד של כל פרויקט, כיוון שהפרויקטים התואמים מכסים את הצרכים הנפוצים.

לא משנה מה תריצו, כלי המעקב אחר שגיאות אינו יכול לדווח על מותו שלו. הגדירו בדיקת תקינות עבורו ממכונה אחרת: Uptime Kuma המנטר ממכונה אחרת יתריע בפניכם שהכלי אינו זמין, וזהו בדיוק הרגע שבו היישום שלכם מתחיל להפיק שגיאות שאף אחד לא מתעד.

מתי תוכנית אירוח היא הפתרון הזול יותר

אירוח עצמי של מערכת לניטור שגיאות משתלם כאשר כללי שמירת נתונים מחייבים זאת, או כאשר נפח האירועים שלכם גבוה מספיק כדי שהתמחור לפי אירוע יהיה יקר. מחוץ למקרים אלו, בצעו את החישוב בכנות. הדרישה המינימלית המתועדת של Sentry עבור פונקציונליות מלאה היא שרת עם 16 GB זיכרון, 4 ליבות ודיסק מהיר; VPS בגודל כזה אינו VPS זול. הפרופיל המיועד לשגיאות בלבד דורש רף התקנה נמוך יותר של 2 ליבות ו-7000 MB של זיכרון RAM זמין ל-Docker. לאחר מכן, הוסיפו את העבודה התפעולית: מעבר על כל שלב קריטי לפי הסדר, וביצוע snapshot לפני כל הגירה, מספר פעמים בשנה.

GlitchTip ו-Bugsink משנים את החישוב הזה לחלוטין, כיוון ששרת עם 512 MB עד 4 GB הוא מכונה לא יקרה, ועדכוני Docker שגרתיים מסתכמים ב-image pull ולאחריו restart, תוך בדיקת הערות השחרור ודרישות מסד הנתונים לפני שדרוגים משמעותיים. זו הסיבה שרוב האנשים ששואלים את השאלה הזו מסיימים עם אחד הפרויקטים התואמים במקום עם ה-stack הרשמי. הם רצו ניטור שגיאות, לא צינור נתונים מבוזר שצריך להשגיח עליו.

אם אתם עדיין מנסים להחליט מה בכלל ראוי להישאר על השרת, הרשימה הרחבה של מה כדאי לארח באופן עצמי מציבה את ניטור השגיאות לצד שירותים אחרים המתחרים על אותו זיכרון RAM.

FAQ

האם ניתן לארח Sentry באופן עצמאי על שרת VPS עם 2 GB RAM?

לא. אפילו פרופיל ה-errors-only של Sentry דורש 2 ליבות CPU ולפחות 7000 MB של RAM פנוי עבור Docker; התיעוד המלא של המערכת מציין דרישות מינימום של 4 ליבות CPU, 16 GB של RAM בתוספת 16 GB של swap, ו-20 GB של שטח דיסק פנוי. ה-stack מריץ את Postgres, ClickHouse, Kafka, Valkey ומספר תהליכי worker בו-זמנית, והמתקין דוחה שרת עם 2 GB במהלך בדיקת ה-RAM. אם מכולות נסגרות (killed), בדקו את dmesg -T | grep -i 'out of memory', שמציג שורה המציינת את התהליך שנסגר. עבור שרת VPS עם 2 GB, השתמשו ב-GlitchTip, שמתועד לעבוד עם 512 MB, או ב-Bugsink, שרץ כמכולה בודדת על גבי SQLite.

האם עליי לשנות את קוד היישום כדי לעבור מ-Sentry ל-GlitchTip או ל-Bugsink?

לא. שניהם מקבלים אירועים מ-SDKs בקוד פתוח של Sentry, כך שניתן להשאיר את ה-SDK שכבר הותקן ולשנות ערך אחד בלבד: ה-DSN, כלומר ה-URL שאליו ה-SDK שולח אירועים. העבירו אותו למשתנה סביבה אם הוא עדיין מוטמע בקוד (hardcoded), כוונו אותו לשרת החדש, ולאחר מכן צרו חריגה (exception) לבדיקה וודאו שהיא מגיעה. אם דבר לא מופיע, בדקו שמזהה הפרויקט ב-DSN תואם לפרויקט שקיים בשרת החדש, ושה-firewall מאפשר ליישום להגיע לאותו מארח (host) ופורט.

כמה שטח דיסק נדרש למעקב שגיאות באירוח עצמי?

זה תלוי בנפח האירועים שלכם ובתקופת השמירה (retention) ולא בכלי עצמו. GlitchTip מפרסמים דרישה של 30 GB עבור מופע המטפל במיליון אירועים בחודש. Bugsink מאפשר לנהל את תקופת השמירה של פרויקטים מוגדרים באמצעות MAX_RETENTION_EVENT_COUNT ולהחיל MAX_EVENT_AGE_DAYS דרך פקודות הניקוי שלו; גודל הדיסק עדיין תלוי בגודל האירועים ובתקורה של מסד הנתונים. בדקו את תקופת השמירה ביום הראשון: Sentry ו-GlitchTip מגיעים שניהם עם הגדרת ברירת מחדל של 90 יום, שעלולה לתפוס יותר מקום ממה שיש בדיסק שלכם בהתאם לקצב האירועים. כלי מעקב ששומר נתונים מעבר לקיבולת הדיסק יגדל עד ש-df -h יציג 100%, ובנקודה זו הקליטה (ingest) תיעצר ותאבדו את השגיאות שהכי חשוב לכם לראות.

מדוע שדרוג של Sentry באירוח עצמי נכשל שוב ושוב?

מכיוון שהשדרוג דילג על נקודת עצירה הכרחית (hard stop). גרסת ה-self-hosted של Sentry מגדירה גרסאות ספציפיות הכוללות מיגרציות של מסד הנתונים שחובה לעבור דרכן. נכון לאוקטובר 2026, אלו הן הגרסאות: 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. מעבר ישיר מגרסה ישנה לחדשה ביותר מדלג על המיגרציות הללו, לכן ה-schema והקוד אינם תואמים והשדרוג נעצר באמצע. בצעו את השדרוג דרך כל נקודת עצירה לפי הסדר והריצו את ./install.sh בכל אחת מהן. בצעו snapshot לשרת לפני תחילת התהליך, וקראו את רשימת הגרסאות המתועדות שיש להימנע מהן, הכוללת את 23.7.0, 25.9.0 ו-25.12.0.

האם המאמר הזה היה מועיל?

#error-tracking#sentry#glitchtip#observability#self-hosting