check_postgres_table_sizep - מקוון בענן

תָכְנִית:

שֵׁם

check_postgres - סקריפט ניטור Postgres עבור Nagios, MRTG, Cacti ואחרים

מסמך זה מתאר את גרסה 2.22.0 של check_postgres

תַקצִיר

## צור את כל הקישורים הסמליים
check_postgres --symlinks

## בדוק את החיבור למסד הנתונים 'pluto' של Postgres:
check_postgres --action=חיבור --db=pluto

## אותם דברים, אבל באמצעות ה-Symlink
check_postgres_connection --db=pluto

## הזהר אם > 100 נעילות, קריטי אם > 200, או > 20 בלעדיים
check_postgres_locks --warning=100 --critical="total=200:exclusive=20"

## הצג את המספר הנוכחי של חיבורים סרק ביציאה 6543:
check_postgres_txn_idle --port=6543 --output=simple

## ישנן פעולות ואפשרויות רבות אחרות, אנא המשיכו לקרוא.

את החדשות והתיעוד האחרונות ניתן למצוא תמיד בכתובת:
http://bucardo.org/check_postgres/

תיאור

check_postgres הוא סקריפט Perl המריץ בדיקות רבות ושונות כנגד אחד או יותר
מאגרי מידע של Postgres. הוא משתמש בתוכנת psql כדי לאסוף את המידע, ומוציא את
תוצאות באחד משלושה פורמטים: Nagios, MRTG או פשוט.

תְפוּקָה מצבים
ניתן לשנות את הפלט על ידי שימוש באפשרות "--output". פלט ברירת המחדל הוא nagios,
אם כי ניתן לשנות זאת בחלק העליון של הסקריפט אם תרצה. האפשרות הנוכחית
בחירות הן נגיוס, mrtg, ו פשוט. כדי להימנע מהצורך להזין את ארגומנט הפלט כל אחד
זמן, סוג הפלט מוגדר אוטומטית אם לא ניתן ארגומנט --output, ואם ה-
בספרייה הנוכחית יש אחת מאפשרויות הפלט בשמה. לדוגמה, יצירת א
ספרייה בשם mrtg ומאכלסת אותה בקישורים סימליים דרך ה --קישורים סימנים הטיעון היה
ודא שכל הפעולות המופעלות מאותה ספרייה תמיד יהיו ברירת המחדל לפלט של "mrtg"
כקיצור דרך עבור --output=simple, אתה יכול להזין --simple, שגם מחליף את ה
טריק למתן שמות של ספריות.

נאגיוס תפוקה

פורמט הפלט המוגדר כברירת מחדל הוא עבור Nagios, שהוא שורת מידע בודדת, יחד עם
ארבעה קודי יציאה ספציפיים:

0 (בסדר)
1 (אזהרה)
2 (קריטי)
3 (לא ידוע)

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

MRTG תפוקה

פלט MRTG הוא ארבע שורות, כאשר השורה הראשונה תמיד נותנת מספר בודד של
חֲשִׁיבוּת. במידת האפשר, מספר זה מייצג ערך ממשי כגון מספר של
בתים, אבל זה יכול להיות גם 1 או 0 עבור פעולות שמחזירות רק "true" או "false", כגון
בתור check_postgres_version. השורה השנייה היא נתון נוסף ומשמשת רק עבור
כמה פעולות. השורה השלישית מציינת "זמן פעולה" ואינה בשימוש. השורה הרביעית היא א
תיאור ובדרך כלל מציין את שם מסד הנתונים הנתון מהשורה הראשונה
נשלף, אך עשוי להיות שונה בהתאם לפעולה.

חלק מהפעולות מקבלות אופציונלי --mrtg ארגומנט לשליטה נוספת על הפלט.

עיין בתיעוד על כל פעולה לפרטים על הפלט המדויק של MRTG עבור כל פעולה.

פָּשׁוּט תפוקה

הפלט הפשוט הוא פשוט גרסה קטומה של ה-MRTG, ופשוט מחזיר את
מספר ראשון ותו לא. זה מאוד שימושי כאשר אתה רק רוצה לבדוק את המצב
של משהו, ללא קשר לסף כלשהו. אתה יכול לשנות את הפלט המספרי על ידי
הוספת KB, MB, GB, TB או EB לארגומנט הפלט, לדוגמה:

--output=פשוט,MB

קקטוס תפוקה

פלט הקקטוסים מורכב מפריט אחד או יותר באותה שורה, עם שם פשוט, א
נקודתיים, ולאחר מכן מספר. כרגע, הפעולה היחידה עם פלט קקטוסים מפורש היא
'dbstats', ושימוש באפשרות --output אינו נחוץ במקרה זה, מכיוון שקקטוסים הם היחידים
פלט עבור פעולה זו. עבור פעולות רבות אחרות, מספיק שימוש ב--simple כדי ליצור קקטוסים
שמח.

מאגר מידע חיבור אפשרויות

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

-H שֵׁם or --host=NAME
התחבר למארח המצוין על ידי NAME. יכולה להיות רשימה של שמות מופרדים בפסיקים.
מותרים ארגומנטים מרובים של מארח. אם לא ניתן מארח, ברירת המחדל היא "PGHOST"
משתנה סביבה או ללא מארח כלל (מה שמצביע על שימוש בשקע Unix מקומי).
אתה יכול גם להשתמש ב---dbhost.

-p נמל or --port=PORT
מתחבר באמצעות מספר ה-PORT שצוין. יכולה להיות רשימה מופרדת בפסיקים של יציאות
מספרים וארגומנטים של יציאה מרובים מותרים. אם לא ניתן מספר יציאה, ברירת המחדל
למשתנה הסביבה "PGPORT". אם זה לא מוגדר, ברירת המחדל היא 5432. אתה יכול
השתמש גם ב---dbport

-db שֵׁם or --dbname=NAME
מציין לאיזה מסד נתונים להתחבר. יכולה להיות רשימה מופרדת בפסיקים של שמות, ו
מותרים ארגומנטים מרובים של dbname. אם לא מסופקת אפשרות dbname, ברירת המחדל היא
משתנה הסביבה "PGDATABASE". אם זה לא מוגדר, ברירת המחדל היא 'postgres'
אם psql הוא גרסה 8 ומעלה, ו-'template1' אחרת.

-u את USERNAME or --dbuser=USERNAME
שם משתמש מסד הנתונים שיש להתחבר אליו. יכולה להיות רשימה מופרדת בפסיקים של
שמות משתמש וארגומנטים מרובים של dbuser מותרים. אם זה לא מסופק, זה
ברירת המחדל למשתנה הסביבה "PGUSER", אחרת ברירת המחדל היא 'postgres'.

--dbpass=PASSWORD
מספק את הסיסמה לחיבור למסד הנתונים. השימוש באפשרות זו הוא רב
מיואש. במקום זאת, יש להשתמש בקובץ .pgpass או pg_service.conf.

--dbservice=NAME
שם שירות בתוך הקובץ pg_service.conf. לפני גרסה 9.0 של
Postgres, זהו קובץ גלובלי שנמצא בדרך כלל ב- /etc/pg_service.conf. אם אתה
באמצעות גרסה 9.0 ומעלה של Postgres, אתה יכול להשתמש בקובץ ".pg_service.conf" ב
ספריית הבית של המשתמש המריץ את הסקריפט, למשל nagios.

קובץ זה מכיל רשימה פשוטה של ​​אפשרויות חיבור. אתה יכול גם לעבור נוסף
מידע בעת שימוש באפשרות זו כגון --dbservice="maindatabase sslmode=require"

ניתן למצוא את התיעוד לקובץ זה בכתובת
http://www.postgresql.org/docs/current/static/libpq-pgservice.html

ניתן לקבץ את אפשרויות החיבור למסד הנתונים: --host=a,b --host=c --port=1234
--port=3344 יתחבר ל-a-1234, b-1234 ו-c-3344. שימו לב שלאחר ההגדרה, אפשרות
ממשיך עד שהוא משתנה שוב.

דוגמאות:

--host=a,b --port=5433 --db=c
מתחבר פעמיים ליציאה 5433, באמצעות מסד נתונים c, למארחים a ו-b: a-5433-c b-5433-c

--host=a,b --port=5433 --db=c,d
מתחבר ארבע פעמים: a-5433-c a-5433-d b-5433-c b-5433-d

--host=a,b --host=foo --port=1234 --port=5433 --db=e,f
מתחבר שש פעמים: a-1234-e a-1234-f b-1234-e b-1234-f foo-5433-e foo-5433-f

--host=a,b --host=x --port=5432,5433 --dbuser=alice --dbuser=bob -db=baz
מתחבר שלוש פעמים: a-5432-alice-baz b-5433-alice-baz x-5433-bob-baz

--dbservice="foo" --port=5433
מתחבר באמצעות השירות בשם 'foo' בקובץ pg_service.conf, אך עוקף את היציאה

אחר אפשרויות

אפשרויות אחרות כוללות:

--action=NAME
מציין איזו פעולה אנו מפעילים. נדרש אלא אם כן משתמשים בקובץ עם קישור סימול, שבו
במקרה ששם הקובץ משמש כדי להבין את הפעולה.

-- אזהרה=VAL or -w מדד
מגדיר את הסף שבו מופעלת התראת אזהרה. האפשרויות התקפות לכך
האפשרות תלויה בפעולה שבה נעשה שימוש.

--critical=VAL or -c מדד
מגדיר את הסף שבו מופעלת התראה קריטית. האפשרויות התקפות לכך
האפשרות תלויה בפעולה שבה נעשה שימוש.

-t מדד or --timeout=VAL
מגדיר את הזמן הקצוב בשניות שלאחריו הסקריפט יבטל את כל מה שהוא עושה
להחזיר סטטוס לא ידוע. הזמן הקצוב הוא לכל אשכול Postgres, לא עבור כולו
תַסרִיט. ערך ברירת המחדל הוא 10; היחידות הן תמיד בשניות.

--הנחה-מצב המתנה
אם צוין, ראשית הבדיקה אם השרת במצב המתנה יבוצע (--datadir
נדרש), אם כן, כל הבדיקות הדורשות שאילתות SQL יתעלמו ו"שרת
במצב המתנה" עם מצב אישור יוחזר במקום זאת.

דוגמא:

postgres@db$./check_postgres --action=version --warning=8.1 --datadir /var/lib/postgresql/8.3/main/ --assume-standby-mode
POSTGRES_VERSION אישור: שרת במצב המתנה | זמן=0.00

--הנחה-פרוד
אם צוין, בדוק אם השרת במצב ייצור מבוצע (--datadir נדרש).
האפשרות רלוונטית רק עבור ("קישור סימן: check_postgres_checkpoint").

דוגמא:

postgres@db$./check_postgres --action=checkpoint --datadir /var/lib/postgresql/8.3/main/ --assume-prod
POSTGRES_CHECKPOINT בסדר: המחסום האחרון היה לפני 72 שניות | age=72;;300 mode=MASTER

-h or - עזרה
מציג מסך עזרה עם סיכום של כל הפעולות והאפשרויות.

--איש
מציג את כל המדריך.

-V or --גִרְסָה
מציג את הגרסה הנוכחית.

-v or --מִלוּלִי
הגדר את רמת הדיבור. יכול להתקשר יותר מפעם אחת כדי להגביר את הרמה. מגדיר את זה ל
שלוש ומעלה (במילים אחרות, הנפקת "-v -v -v") מפעילה מידע ניפוי באגים
עבור תוכנית זו שנשלחת אל stderr.

--showperf=VAL
קובע אם נוציא נתוני ביצועים נוספים בפורמט Nagios סטנדרטי (בסוף
של מחרוזת, אחרי סמל צינור, באמצעות שם=ערך). VAL צריך להיות 0 או 1. ברירת המחדל
הוא 1. נכנס לתוקף רק אם משתמשים במצב פלט של Nagios.

--perflimit=i
מגדיר מגבלה לגבי מספר פריטי עניין המדווחים בעת השימוש ב-
showperf אוֹפְּצִיָה. זה משפיע רק על פעולות שמחזירות מספר רב של
פריטים, כגון table_size. ברירת המחדל היא 0, או ללא הגבלה. היזהר בעת השימוש בזה
עם --לִכלוֹל or --לא לכלול אפשרויות, ככל שההגבלות הללו נעשות לאחר מה היא
השאילתה הופעלה, ולכן ייתכן שהמגבלה שלך לא תכלול את הפריטים הרצויים. רק לוקח
השפעה אם משתמשים במצב פלט של Nagios.

--showtime=VAL
קובע אם הזמן שנדרש להפעלת כל שאילתה מוצג בפלט. VAL צריך להיות 0
או 1. ברירת המחדל היא 1. אין השפעה אלא אם כן showperf פועל. נכנס לתוקף רק אם משתמשים
מצב פלט של Nagios.

--מִבְחָן
מאפשר מצב בדיקה. עיין בסעיף "מצב בדיקה" להלן.

--PGBINDIR=PATH
אומר לסקריפט היכן למצוא את הקבצים הבינאריים של psql. שימושי אם יש לך יותר מאחד
גירסה של קובצי ההפעלה של PostgreSQL במערכת שלך, או אם לא קיימים במערכת שלך
נָתִיב. שימו לב שהאפשרות הזו מופיעה באותיות רישיות. כברירת מחדל, אפשרות זו היא לֹא
מותר. כדי להפעיל את זה, עליך לשנות את $NO_PSQL_OPTION ליד החלק העליון של הסקריפט
ל-0. הימנע משימוש באפשרות זו אם אתה יכול, ובמקום זאת השתמש במשתנה סביבה
ג או משתנה $PGBINDIR בקוד קשיח, גם ליד החלק העליון של הסקריפט, להגדרה
הנתיב ל-PostgreSQL לשימוש.

--PSQL=PATH
(הוצא משימוש, זֶה אוֹפְּצִיָה אולי be הוסר in a עתיד לְשַׁחְרֵר!) אומר לתסריט היכן
כדי למצוא את תוכנית psql. שימושי אם יש לך יותר מגרסה אחת של psql
קובץ הפעלה במערכת שלך, או אם אין תוכנית psql בנתיב שלך. שימו לב שזה
האפשרות היא באותיות רישיות. כברירת מחדל, אפשרות זו היא לֹא מותר. כדי לאפשר זאת, אתה
חייב לשנות את $NO_PSQL_OPTION ליד החלק העליון של הסקריפט ל-0. הימנע משימוש זה
אפשרות אם אתה יכול, ובמקום זה קודד קשיח את מיקום ה-psql שלך למשתנה $PSQL,
גם ליד החלק העליון של התסריט.

--קישורים סימנים
יוצר סימלינקים לתוכנית הראשית עבור כל פעולה.

--output=VAL
קובע את הפורמט של הפלט, לשימוש בתוכניות שונות. ברירת המחדל היא
'נגיוס'. האפשרויות הזמינות הן 'nagios', 'mrtg', 'simple' ו-'cacti'.

--mrtg=VAL
משמש רק עבור MRTG או פלט פשוט, עבור כמה פעולות ספציפיות.

--debugoutput=VAL
מוציא את המחרוזת המדויקת שהוחזרה על ידי psql, לשימוש באיתור באגים. הערך הוא אחד או
יותר אותיות, שקובעות אם הפלט מוצג או לא, כאשר 'a' = all, 'c'
= קריטי, 'w' = אזהרה, 'o' = בסדר, ו-'u' = לא ידוע. ניתן לשלב אותיות.

--get_method=VAL
מאפשר פירוט של השיטה המשמשת לאחזור מידע עבור "new_version_cp",
בדיקות "new_version_pg", "new_version_bc", "new_version_box" ו-"new_version_tnm".
התוכנות הבאות ניסו, על מנת, לתפוס את המידע מהאינטרנט: GET,
wget, fetch, curl, lynx, links. כדי לכפות שימוש באחד בלבד (ובכך להסיר את
על מנת לנסות את כל האחרים עד שאחת מאותן עובדות), הזינו את אחד השמות כ
הטיעון לקבל_שיטה. לדוגמה, תיבת BSD עשויה להזין את השורה הבאה
הקובץ ".check_postgresrc" שלהם:

get_method=fetch

--language=VAL
הגדר את השפה לשימוש עבור כל הודעות הפלט. בדרך כלל, זה מזוהה על ידי
בוחנים את משתני הסביבה LC_ALL, LC_MESSAGES ו-LANG, אך מגדירים זאת
האפשרות תעקוף כל זיהוי כזה.

פעולות

הסקריפט מפעיל פעולה אחת או יותר. זה יכול להיעשות עם דגל --action, או על ידי
באמצעות קישור סימן לקובץ הראשי המכיל בתוכו את שם הפעולה. ל
לדוגמה, כדי להפעיל את הפעולה "timesync", אתה יכול להפיק:

check_postgres --action=timesync

או השתמש בתוכנה בשם:

check_postgres_timesync

כל הקישורים הסמליים נוצרים עבורך בספרייה הנוכחית אם תשתמש באפשרות --symlinks

perl check_postgres --symlinks

אם שם הקובץ כבר קיים, הוא לא יוחלף. אם הקובץ קיים והוא א
symlink, אתה יכול לאלץ אותו לדרוס באמצעות "--action=build_symlinks_force"

רוב הפעולות לוקחות א --אַזהָרָה וכן --קריטי אפשרות, המציינת באיזו נקודה אנו משנים
מ-OK ל-WARNING, ובאיזו נקודה אנחנו הולכים ל-CRITICAL. שים לב כי הם קריטיים
תמיד מסומן קודם, הגדרת האזהרה שווה לקריטית היא דרך יעילה
כבה אזהרות ותמיד תן קריטי.

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

ארכיון_מוכן
("Symlink: check_postgres_archive_ready") בודק כמה קבצי WAL עם סיומת .מוּכָן
קיימים ב pg_xlog/archive_status ספרייה, שנמצאת מחוץ שלך data_directory.
פעולה זו חייבת להיות מופעלת כמשתמש-על, על מנת לגשת לתוכן של
pg_xlog/archive_status מַדרִיך. הגרסה המינימלית לשימוש בפעולה זו היא Postgres 8.1.
אל האני --אַזהָרָה ו --קריטי האפשרויות הן פשוט המספר של .מוּכָן קבצים ב-
pg_xlog/archive_status מַדרִיך. בדרך כלל, ערכים אלה צריכים להיות נמוכים, ולהפעיל את
מנגנון ארכיון, אנחנו בדרך כלל רוצים שהוא יאחסן קבצי WAL במהירות האפשרית.

אם פקודת הארכיון נכשלת, מספר ה-WAL שלך pg_xlog ספרייה תגדל עד
למצות את כל שטח הדיסק ולאלץ את PostgreSQL להפסיק מיד.

דוגמה 1: בדוק שמספר קבצי WAL המוכנים הוא 10 או פחות במארח "pluto"

check_postgres_archive_ready --host=pluto --critical=10

עבור פלט MRTG, מדווח על מספר קבצי WAL מוכנים בשורה 1.

autovac_freeze
("symlink: check_postgres_autovac_freeze") בודק עד כמה כל מסד נתונים קרוב ל-
פוסטגרס autovacuum_freeze_max_age הגדרה. פעולה זו תעבוד רק עבור מסדי נתונים
גרסה 8.2 ומעלה. ה --אַזהָרָה ו --קריטי אפשרויות צריכות להתבטא כ
אחוזים. ה'גיל' של העסקאות בכל מסד נתונים מושווה ל-
הגדרת autovacuum_freeze_max_age (200 מיליון כברירת מחדל) כדי ליצור מעוגל
אֲחוּזִים. ערכי ברירת המחדל הם 90% עבור האזהרה ו 95% עבור הקריטיים. מאגרי מידע
ניתן לסנן על ידי שימוש ב- --לִכלוֹל ו --לא לכלול אפשרויות. ראה "סינון בסיסי"
סעיף לפרטים נוספים.

דוגמה 1: תן אזהרה כאשר מסדי נתונים כלשהם ביציאה 5432 הם מעל 97%

check_postgres_autovac_freeze --port=5432 --warning="97%"

עבור תפוקת MRTG, האחוז הכולל הגבוה ביותר מדווח בשורה הראשונה, וה-
הגיל הגבוה ביותר מדווח בשורה השנייה. כל מסדי הנתונים שיש להם את האחוז מ
השורה הראשונה מדווחת בשורה הרביעית, מופרדת על ידי סמל צינור.

backends
("Symlink: check_postgres_backends") בודק את מספר החיבורים הנוכחי עבור אחד או
יותר מסדי נתונים, ואופציונלי משווה אותו למקסימום המותר, שנקבע על ידי
משתנה התצורה Postgres max_connections. ה --אַזהָרָה ו --קריטי אפשרויות
יכול ללבוש אחת משלוש צורות. ראשית, ניתן לתת מספר פשוט, המייצג את
מספר החיבורים שבהם תינתן ההתראה. בחירה זו אינה משתמשת ב-
max_connections הגדרה. שנית, ניתן לתת את אחוז החיבורים הזמינים.
שלישית, ניתן לתת מספר שלילי המייצג את מספר החיבורים שנותרו
עד max_connections מגיע. ערכי ברירת המחדל עבור --אַזהָרָה ו --קריטי יש לו
'90%' ו'95%'. אתה יכול גם לסנן את מסדי הנתונים באמצעות ה --לִכלוֹל ו --לא לכלול
אפשרויות. עיין בסעיף "סינון בסיסי" לפרטים נוספים.

כדי להציג רק תהליכים שאינם פעילים, אתה יכול להשתמש ב- --נודל טַעֲנָה. שים לב שהמשתמש אתה
מתחברים כי הם חייבים להיות משתמש-על כדי שזה יעבוד כמו שצריך.

דוגמה 1: תן אזהרה כאשר מספר החיבורים ב-quirm המארח מגיע ל-120, ו-
קריטי אם הוא מגיע ל-150.

check_postgres_backends --host=quirm --warning=120 --critical=150

דוגמה 2: תן קריטי כאשר נגיע ל-75% מהגדרת max_connections שלנו במארחים
lancre או lancre2.

check_postgres_backends --warning='75%' --critical='75%' --host=lancre,lancre2

דוגמה 3: תן אזהרה כאשר נותרו רק 10 חריצי חיבור נוספים במארח
פלסמיד, וקריטי כשנותרו לנו רק 5.

check_postgres_backends --warning=-10 --critical=-5 --host=plasmid

דוגמה 4: בדוק את כל מסדי הנתונים מלבד אלה עם "מבחן" בשמם, אבל אפשר כאלה
נקראים "pg_greatest". התחבר כיציאה 5432 בשני המארחים הראשונים, וכיציאה 5433 פועלת
השלישי. אנחנו רוצים תמיד לזרוק קריטי כשאנחנו מגיעים ל-30 חיבורים או יותר.

check_postgres_backends --dbhost=hong,kong --dbhost=fooey --dbport=5432 --dbport=5433 --warning=30 --critical=30 --exclude="~test" --include="pg_greatest,~prod "

עבור פלט MRTG, מספר החיבורים מדווח בשורה הראשונה והרביעית
line נותן את שם מסד הנתונים, בתוספת ה-max_connections הנוכחיים. אם יותר מ
מסד נתונים אחד נבדק, זה עם מספר החיבורים הגבוה ביותר הוא פלט.

לְהַתְפִּיחַ
("Symlink: check_postgres_bloat") בודק את כמות הנפיחות בטבלאות ובאינדקסים. (לְהַתְפִּיחַ
הוא בדרך כלל כמות השטח המת שאינו מנוצל שנלקח בטבלה או באינדקס. החלל הזה הוא
בדרך כלל תוחזר על ידי שימוש בפקודת VACUUM.) פעולה זו דורשת נתונים סטטיסטיים
אוסף יהיה זמין במסדי הנתונים היעד, ודורש הפעלת ANALYZE
בתדירות גבוהה. ה --לִכלוֹל ו --לא לכלול ניתן להשתמש באפשרויות כדי לסנן לאילו טבלאות
להסתכל על. עיין בסעיף "סינון בסיסי" לפרטים נוספים.

אל האני --אַזהָרָה ו --קריטי ניתן לציין אפשרויות כגדלים, אחוזים או שניהם. תָקֵף
יחידות הגודל הן בתים, קילובייט, מגה-בייט, גיגה-בייט, טרה-בייט, אקס-בייט, פטה-בייט ו
זטה-בייט. אתה יכול לקצר את כל אלה באות הראשונה. פריטים ללא יחידות הם
ההנחה היא 'בתים'. ערכי ברירת המחדל הם '1 GB' ו-'5 GB'. הערך מייצג את
מספר ה"בייטים מבוזבזים", או ההבדל בין מה שבפועל משמש את הטבלה ו
אינדקס, ומה אנחנו מחשבים שהוא צריך להיות.

שים לב שלפעולה זו יש שני ערכים מקודדים כדי למנוע אזעקות שווא בקטנה
יחסים. טבלאות חייבות לכלול לפחות 10 עמודים, ואינדקסים לפחות 15, לפני שיוכלו להיות
נחשב בבדיקה זו. אם אתה באמת רוצה להתאים את הערכים האלה, אתה יכול לחפש את
משתנים $MINPAGES ו $MINIPAGES בחלק העליון של תת-השגרה "check_bloat". אלה
הערכים מתעלמים אם אחד מהם --לא לכלול or --לִכלוֹל משמש.

רק 10 היחסים הנפוחים ביותר מוצגים. אתה יכול לשנות את המספר הזה על ידי שימוש ב-
--perflimit אפשרות להגדיר את הגבול שלך.

הסכימה בשם 'information_schema' אינה נכללת בבדיקה זו, כטבלאות היחידות שלה
מכיל הם קטנים ואינם משתנים.

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

דוגמה 1: אזהרה אם טבלה כלשהי ביציאה 5432 היא מעל 100 מגה-בייט מנופחת, וקריטית אם מעל 200
MB

check_postgres_bloat --port=5432 --warning='100 M' --critical='200 M'

דוגמה 2: תן קריטי אם 'הזמנות' בטבלה ב-'sami' המארח יש יותר מ-10 מגה של נפיחות

check_postgres_bloat --host=sami --include=orders --critical='10 MB'

דוגמה 3: תן קריטי אם הטבלה 'q4' על 'מכירות' של מסד הנתונים היא מעל 50% נפוחה

check_postgres_bloat --db=sales --include=q4 --critical='50%'

דוגמה 4: תן קריטי כל טבלה היא מעל 20% נפוח ו יש יותר מ-150 MB של נפיחות:

check_postgres_bloat --port=5432 --critical='20% ו-150 M'

דוגמה 5: תן קריטי כל טבלה היא מעל 40% נפוח or יש יותר מ-500 MB של נפיחות:

check_postgres_bloat --port=5432 --warning='500 M or 40%'

עבור פלט MRTG, השורה הראשונה נותנת את המספר הגבוה ביותר של בתים מבוזבזים עבור הטבלאות,
והשורה השנייה נותנת את המספר הגבוה ביותר של בתים מבוזבזים עבור האינדקסים. הרביעי
שורה מספקת את שם מסד הנתונים, שם הטבלה ושם האינדקס. אם אתה רוצה
פלט את יחס הנפיחות במקום (פי כמה גדול היחס לעומת איך
גדול זה צריך להיות), פשוט העבירו ב-"--mrtg=ratio".

מחסום
("Symlink: check_postgres_checkpoint") קובע כמה זמן עבר מאז המחסום האחרון
הופעל. זה חייב לפעול באותו שרת כמו מסד הנתונים שנבדק (למשל
דגל -h לא יעבוד). בדיקה זו נועדה לפעול על שרת "המתנה חמה", כלומר
מעבד באופן פעיל קבצי WAL שנשלחו, והוא נועד לבדוק שההמתנה החמה שלך היא
באמת 'חם'. יש להגדיר את ספריית הנתונים, או על ידי משתנה הסביבה
"PGDATA", או העברת הארגומנט "--datadir". זה מחזיר את מספר השניות מאז
המחסום האחרון הופעל, כפי שנקבע על ידי ניתוח הקריאה ל-"pg_controldata". בגלל
זה, קובץ ההפעלה pg_controldata חייב להיות זמין בנתיב הנוכחי. לחלופין,
אתה יכול לציין "PGBINDIR" בתור הספרייה שבה הוא חי. זה גם אפשרי להשתמש
האפשרויות המיוחדות --הנחה-פרוד or --הנחה-מצב המתנה, אם המצב שנמצא אינו ה
אחד צפוי, קריטי נפלט.

יש להגדיר לפחות אזהרה או ארגומנט קריטי אחד.

פעולה זו דורשת את מודול Date::Parse.

עבור MRTG או פלט פשוט, מחזיר את מספר השניות.

cluster_id
("symlink: check_postgres_cluster-id") בודק שמזהה מערכת מסד הנתונים סיפק
מאת pg_controldata זהה לפעם האחרונה שבדקת. זה חייב לפעול באותו שרת
בתור מסד הנתונים שנבדק (לדוגמה, הדגל -h לא יעבוד). או את
--אַזהָרָה או --קריטי יש לתת אפשרות, אבל לא את שניהם. הערך של כל אחד הוא
מזהה האשכול, ערך מספר שלם. אתה יכול לרוץ עם "--critical=0" המיוחד
אפשרות לגלות מזהה אשכול קיים.

דוגמה 1: מצא את המזהה הראשוני

check_postgres_cluster_id --critical=0 --datadir=/var//lib/postgresql/9.0/main

דוגמה 2: ודא שהאשכול זהה והזהיר אם לא, באמצעות התוצאה מלמעלה.

check_postgres_cluster_id --critical=5633695740047915135

עבור פלט MRTG, מחזיר 1 או 0 המציין הצלחה של כישלון של המזהה
התאמה. יש לספק מזהה כארגומנט "--mrtg". השורה הרביעית תמיד
נותן את המזהה הנוכחי.

התחייבות
("Symlink: check_postgres_commitratio") בודק את יחס ההתחייבויות של כל מסדי הנתונים
מתלונן כשהם נמוכים מדי. אין צורך להפעיל פקודה זו יותר מפעם אחת בכל
אשכול מסד נתונים. ניתן לסנן מסדי נתונים באמצעות ה --לִכלוֹל ו --לא לכלול אפשרויות. לִרְאוֹת
הסעיף "סינון בסיסי" לפרטים נוספים. ניתן לסנן אותם גם על ידי הבעלים של
מסד הנתונים עם ה --includeuser ו --excludeuser אפשרויות. ראה את "שם המשתמש
סעיף סינון" לפרטים נוספים.

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

דוגמה: הזהר אם מסד נתונים כלשהו על דגל המארח הוא פחות מ-90% בהתחייבות, וקריטי
אם פחות מ-80%.

check_postgres_database_commitratio --host=flagg --warning='90%' --critical='80%'

עבור פלט MRTG, מחזיר את אחוז מסד הנתונים עם ההתחייבות הקטנה ביותר
השורה הראשונה, ושם מסד הנתונים בשורה הרביעית.

הקשר
("symlink: check_postgres_connection") פשוט מתחבר, מוציא 'SELECT גִרְסָה()', ו
משאיר. לוקח לא --אַזהָרָה or --קריטי אפשרויות.

עבור פלט MRTG, פשוט מוציא 1 (חיבור טוב) או 0 (חיבור גרוע) בראשון
קו.

שאילתה_מותאמת אישית
("Symlink: check_postgres_custom_query") מפעיל שאילתה מותאמת אישית לבחירתך ומנתח
התוצאות. השאילתה עצמה מועברת דרך הארגומנט "שאילתה", וצריכה להיות
נשמר פשוט ככל האפשר. אם אפשר, עטפו אותו בתצוגה או בפונקציה שיש לשמור
דברים קלים יותר לניהול. השאילתה צריכה להחזיר עמודה אחת או שתיים. זה מתבקש
אחת העמודות תיקרא "תוצאה" והיא הפריט שייבדק מול שלך
אזהרה וערכים קריטיים. העמודה השנייה מיועדת לנתוני הביצועים ולכל שם
ניתן להשתמש: זה יהיה ה'ערך' בקטע נתוני ביצועים.

יש לציין לפחות אזהרה או ארגומנט קריטי אחד. למה אלה מוגדרים תלוי
על סוג השאילתה שאתה מפעיל. ישנם ארבעה סוגים של custom_queries שיכולים להיות
run, שצוין על ידי הארגומנט "valtype". אם אף אחד לא צוין, פעולה זו מוגדרת כברירת מחדל
'מספר שלם'. ארבעת הסוגים הם:

מספר שלם: עושה השוואה פשוטה של ​​מספרים שלמים. העמודה הראשונה צריכה להיות מספר שלם פשוט,
והערכי האזהרה והקריטיים צריכים להיות זהים.

מחרוזת: האזהרה והקריטית הן מחרוזות, ומופעלות רק אם הערך ב-
העמודה הראשונה תואמת אותו בדיוק. זה תלוי רישיות.

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

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

בדרך כלל, התראה מופעלת אם הערכים המוחזרים הם יותר מֵאֲשֶׁר או שווה ל-
ערך קריטי או אזהרה. עם זאת, אפשרות של --לַהֲפוֹך יפעיל את ההתראה אם
הערך המוחזר הוא להוריד מֵאֲשֶׁר או שווה לערך הקריטי או האזהרה.

דוגמה 1: אזהרה אם קשר כלשהו מעל 100 עמודים נקרא "רד", שים את מספר העמודים
בתוך קטע נתוני ביצועים.

check_postgres_custom_query --valtype=string -w "rad" --query=
"בחר relname AS result, relpages AS pages FROM pg_class WHERE relpages > 100"

דוגמה 2: תן קריטי אם הפונקציה "foobar" מחזירה מספר מעל 5MB:

check_postgres_custom_query --critical='5MB'--valtype=size --query="SELECT foobar() AS result"

דוגמה 2: אזהרה אם הפונקציה "snazzo" מחזירה פחות מ-42:

check_postgres_custom_query --critical=42 --query="SELECT snazzo() AS result" --reverse

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

פעולה זו אינה תומכת עדיין ב-MRTG או בפלט פשוט.

גודל_בסיס הנתונים
("Symlink: check_postgres_database_size") בודק את הגודל של כל מסדי הנתונים ומתלונן
כשהם גדולים מדי. אין צורך להפעיל פקודה זו יותר מפעם אחת בכל מסד נתונים
אֶשׁכּוֹל. ניתן לסנן מסדי נתונים באמצעות ה --לִכלוֹל ו --לא לכלול אפשרויות. ראה את
סעיף "סינון בסיסי" לפרטים נוספים. ניתן לסנן אותם גם על ידי הבעלים של
מסד נתונים עם ה --includeuser ו --excludeuser אפשרויות. ראה את "סינון שם משתמש"
סעיף לפרטים נוספים.

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

דוגמה 1: הזהר אם מסד נתונים כלשהו על דגל המארח הוא בגודל של יותר מ-1 TB, וחיוני אם הוא מעל
1.1TB

check_postgres_database_size --host=flagg --warning='1 TB' --critical='1.1 t'

דוגמה 2: תן קריטי אם תבנית מסד הנתונים1 ביציאה 5432 היא מעל 10 MB.

check_postgres_database_size --port=5432 --include=template1 --warning='10MB' --critical='10MB'

דוגמה 3: תן אזהרה אם מסד נתונים כלשהו במארח 'tardis' שבבעלות המשתמש 'tom' נגמר
5 GB

check_postgres_database_size --host=tardis --includeuser=tom --warning='5 GB' --critical='10 GB'

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

dbstats
("symlink: check_postgres_dbstats") מדווח על מידע מתצוגת pg_stat_database,
ומוציא אותו בצורה ידידותית לקקטוסים. אין תמיכה בפלט אחר, כפי שהוא נתמך
אינפורמטיבי ואינו מתאים להתראות, כגון בשימוש עם Nagios. אם אין אפשרויות
ניתנים, כל מסדי הנתונים מוחזרים, אחד בכל שורה. אתה יכול לכלול מסד נתונים ספציפי
על ידי שימוש באפשרות "--include", או שאתה יכול להשתמש באפשרות "--dbname".

XNUMX פריטים מוחזרים בכל שורה, בפורמט name:value, מופרדים ביחיד
מֶרחָב. הפריטים הם:

backends
מספר ה-backends הפועלים כעת עבור מסד נתונים זה.

מתחייב
המספר הכולל של commits עבור מסד נתונים זה מאז שנוצר או איפוס.

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

לקרוא
המספר הכולל של בלוקי דיסק שנקראו.

hit המספר הכולל של כניסות חיץ.

ret המספר הכולל של שורות שהוחזרו.

לְהָבִיא
המספר הכולל של שורות שנלקחו.

ins המספר הכולל של שורות שנוספו.

upd המספר הכולל של שורות שעודכנו.

del המספר הכולל של שורות שנמחקו.

dbname
שם מסד הנתונים.

שימו לב שפריטי ret, fetch, ins, upd ו-del יהיו תמיד 0 אם Postgres היא גרסה 8.2
או נמוך יותר, מכיוון שהנתונים הסטטיסטיים לא היו זמינים בגרסאות אלו.

אם ניתן ארגומנט dbname, יוחזרו שבעה פריטים נוספים:

idxscan
המספר הכולל של סריקות אינדקס משתמש.

idxtupread
המספר הכולל של ערכי אינדקס משתמשים שהוחזרו.

idxtupfetch
המספר הכולל של שורות שנלקחו על ידי סריקות אינדקס משתמש פשוטות.

idxblksread
המספר הכולל של בלוקי דיסק שנקראו עבור כל אינדקסי המשתמש.

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

seqscan
המספר הכולל של סריקות עוקבות מול כל טבלאות המשתמש.

sequpread
המספר הכולל של tuples שהוחזרו מכל טבלאות המשתמש.

דוגמה 1: קח את הנתונים הסטטיסטיים של מסד נתונים בשם "מוצרים" על המארח "ווילו":

check_postgres_dbstats --dbhost willow --dbname מוצרים

הפלט שיוחזר יהיה כך (הכל בשורה אחת, לא עטוף):

backends:82 commits:58374408 rollbacks:1651 read:268435543 hit:2920381758 idxscan:310931294 idxtupread:2777040927
idxtupfetch:1840241349 idxblksread:62860110 idxblkshit:1107812216 seqscan:5085305 seqtupread:5370500520
ret:0 fetch:0 ins:0 upd:0 del:0 dbname:willow

disabled_triggers
("קישור סימלי: check_postgres_disabled_triggers") בודק את מספר הטריגרים המושבתים
בתוך מסד הנתונים. ה --אַזהָרָה ו --קריטי אפשרויות הן מספר הטריגרים כאלה
נמצא, ושניהם כברירת מחדל ל-"1", שכן בשימוש רגיל ביטול טריגרים הוא מסוכן
מִקרֶה. אם מסד הנתונים הנבדק הוא 8.3 ומעלה, הבדיקה מיועדת למספר של
טריגרים שנמצאים בסטטוס 'מושבת' (בניגוד להיותם 'תמיד' או 'עותק'). ה
הפלט יציג את שם הטבלה ואת שם הטריגר עבור כל מושבת
הדק.

דוגמה 1: ודא שאין טריגרים מושבתים

check_postgres_disabled_triggers

עבור פלט MRTG, מחזיר את מספר הטריגרים המושבתים בשורה הראשונה.

דיסק_space
("Symlink: check_postgres_disk_space") בודק את שטח הדיסק הפיזי הפנוי בשימוש על ידי
Postgres. פעולה זו מחייבת את קובץ ההפעלה "/bin/df"זמין לדיווח
על גדלי דיסקים, והוא גם צריך להיות מופעל בתור משתמש-על, כדי שהוא יוכל לבחון את
data_directory הגדרה בתוך Postgres. ה --אַזהָרָה ו --קריטי ניתנות אפשרויות
בגדלים או באחוזים או בשניהם. אם משתמשים בגדלים, סוגי היחידות הסטנדרטיים הם
מותר: בייטים, קילובייטים, ג'יגה-בייט, מגה-בייט, ג'יגה-בייט, טרה-בייט או אקס-בייט. כל אחד
ניתן לקצר לאות הראשונה בלבד; אין יחידות כלל מציינת 'בתים'. ה
ערכי ברירת המחדל הם '90%' ו-'95%'.

פקודה זו בודקת את הדברים הבאים כדי לקבוע את כל הדיסקים הפיזיים השונים
בשימוש על ידי Postgres.

data_directory - הדיסק שבו נמצאת ספריית הנתונים הראשית.

היכנס בספרייה - הדיסק שבו נמצאים קובצי היומן.

וול פילה בספרייה - הדיסק שבו נמצאים יומני הכתיבה קדימה (למשל עם קישור סימלי pg_xlog)

מרחבי שולחנות - כל שטח טבלה שנמצא בדיסק נפרד.

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

דוגמה 1: ודא שאף מערכת קבצים אינה עולה על 90% עבור מסד הנתונים ביציאה 5432.

check_postgres_disk_space --port=5432 --warning='90%' --critical='90%'

דוגמה 2: בדוק שכל מערכות הקבצים המתחילות ב-/dev/sda קטנות מ-10 GB ו
11 GB (אזהרה וקריטי)

check_postgres_disk_space --port=5432 --warning='10 GB' --critical='11 GB' --include="~^/dev/sda"

דוגמה 4: ודא שאף מערכת קבצים אינה מעל 50% ו יש מעל 15 GB

check_postgres_disk_space --critical='50% ו-15 GB'

דוגמה 5: הפק אזהרה אם מערכת קבצים כלשהי מלאה במעל 70%. or יש יותר מ-1T

check_postgres_disk_space --warning='1T או 75'

עבור פלט MRTG, מחזיר את הגודל בבייטים של מערכת הקבצים בשורה הראשונה, וה-
שם מערכת הקבצים בשורה הרביעית.

fsm_pages
("symlink: check_postgres_fsm_pages") בודק כמה קרוב אשכול ל-Postgres
max_fsm_pages הגדרה. פעולה זו תעבוד רק עבור מסדי נתונים של 8.2 ומעלה, והיא
דורש את מודול התרומה pg_freespacemap להיות מותקן. ה --אַזהָרָה ו --קריטי
יש לבטא את האפשרויות באחוזים. מספר הדפים בשימוש במפת השטח הפנוי
נקבע על ידי הסתכלות בתצוגת pg_freespacemap_relations, והפעלת נוסחה
מבוסס על הנוסחה המשמשת להפקת משבצות עמודים של שטח פנוי במפה במילולי ואקום
פקודה. ערכי ברירת המחדל הם 85% עבור האזהרה ו 95% עבור הקריטיים.

דוגמה 1: תן אזהרה כאשר האשכול שלנו מנצל 76% משטחי הדפים הפנוי,
עם pg_freespacemap מותקן במסד הנתונים רוברט

check_postgres_fsm_pages --dbname=robert --warning="76%"

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

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

fsm_relations
("symlink: check_postgres_fsm_relations") בודק כמה קרוב אשכול ל-Postgres
max_fsm_relations הגדרה. פעולה זו תעבוד רק עבור מסדי נתונים של 8.2 ומעלה, ו
זה דורש את מודול התרומה pg_freespacemap להיות מותקן. ה --אַזהָרָה ו --קריטי
יש לבטא את האפשרויות באחוזים. מספר היחסים בשימוש ב-free-
space-map נקבע על ידי הסתכלות בתצוגת pg_freespacemap_relations. ברירת המחדל
הערכים הם 85% עבור האזהרה ו 95% עבור הקריטיים.

דוגמה 1: תן אזהרה כאשר האשכול שלנו ניצל 80% מיחסי השטח הפנוי,
עם pg_freespacemap מותקן במסד הנתונים Dylan

check_postgres_fsm_relations --dbname=dylan --warning="75%"

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

עבור פלט MRTG, מחזיר את האחוז של מפת השטח הפנוי בשורה הראשונה, המספר של
היחסים המשמשים כיום בקו השני.

hitratio
("Symlink: check_postgres_hitratio") בודק את יחס הפגיעה של כל מסדי הנתונים ומתלונן
כשהם נמוכים מדי. אין צורך להפעיל פקודה זו יותר מפעם אחת בכל מסד נתונים
אֶשׁכּוֹל. ניתן לסנן מסדי נתונים באמצעות ה --לִכלוֹל ו --לא לכלול אפשרויות. ראה את
סעיף "סינון בסיסי" לפרטים נוספים. ניתן לסנן אותם גם על ידי הבעלים של
מסד נתונים עם ה --includeuser ו --excludeuser אפשרויות. ראה את "סינון שם משתמש"
סעיף לפרטים נוספים.

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

דוגמה: הזהר אם מסד נתונים כלשהו על דגל המארח הוא פחות מ-90% בשיעור יחס, וקריטי אם
פחות מ-80%.

check_postgres_hitratio --host=flagg --warning='90%' --critical='80%'

עבור פלט MRTG, מחזיר את האחוז של מסד הנתונים עם היחס הקטן ביותר ב-
שורה ראשונה, ושם מסד הנתונים בשורה הרביעית.

חם_המתנה_עיכוב
("Symlink: check_hot_standby_delay") בודק את השהיית השכפול בסטרימינג על ידי מחשוב
delta בין מיקום ה-xlog הנוכחי של שרת מאסטר לבין מיקום ההשמעה החוזרת של a
עבד מחובר אליו. שרת העבד חייב להיות במצב hot_standby (למשל לקריאה בלבד),
לכן הגרסה המינימלית לשימוש בפעולה זו היא Postgres 9.0. ה --אַזהָרָה ו
--קריטי האפשרויות הן הדלתא בין מיקומי ה-xlog. מכיוון שהערכים הללו הם בתים
קיזוזים ב-WAL הם צריכים להתאים לנפח העסקאות הצפוי של היישום שלך
כדי למנוע תוצאות חיוביות או שליליות שגויות.

האפשרויות הראשונות "--dbname", "--host" ו-"--port" וכו' נחשבות למאסטר; ה
השני שייך לעבד.

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

עליך לספק מידע כיצד להגיע למאגרי המידע על ידי מתן פסיק מופרד
רשימה לפרמטרים --dbhost ו--dbport, כגון "--dbport=5432,5543". אם לא ניתן,
הפעולה נכשלת.

דוגמה 1: אזהרה שמסד נתונים עם העתק מקומי ביציאה 5433 נמצא מאחורי כל שידור חוזר של xlog
בכלל

check_hot_standby_delay --dbport=5432,5433 --warning='1'

דוגמה 2: תן קריטי אם רפליקת העסקה האחרונה שמקבלת היא יותר מ-1
לפני דקות

check_hot_standby_delay --dbhost=master,replica1 --critical='10 דקות'

דוגמה 3: אפשר לרפליקה1 להיות קטע WAL אחד מאחור, אם המאסטר רואה לרגע
יותר פעילות ממה שחיבור השכפול בסטרימינג יכול להתמודד, או 10 דקות אחרי,
אם המאסטר רואה מעט מאוד פעילות ואינו מעבד עסקאות, אבל לא
שניהם, מה שיעיד על בעיה מתמשכת בחיבור השכפול.

check_hot_standby_delay --dbhost=master,replica1 --warning='1048576 ו-2 דקות' --critical='16777216 ו-10 דקות'

index_size
table_size
גודל_יחס
(קישורים סימליים: "check_postgres_index_size", "check_postgres_table_size", וכן
"check_postgres_relation_size") הפעולות table_size ו index_size הם פשוט
וריאציות של גודל_יחס פעולה, שבודקת גם קשר שצמח
גָדוֹל. ניתן לסנן קשרים (במילים אחרות, טבלאות ואינדקסים) באמצעות ה- --לִכלוֹל
ו --לא לכלול אפשרויות. עיין בסעיף "סינון בסיסי" לפרטים נוספים. יחסים יכולים
יסוננו גם על ידי המשתמש שבבעלותו, על ידי שימוש ב- --includeuser ו --excludeuser
אפשרויות. עיין בסעיף "סינון שם משתמש" לפרטים נוספים.

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

אם --showperf האפשרות מופעלת, את כל של היחסים עם הגדלים שלהם יינתנו.
כדי למנוע זאת, מומלץ להגדיר את --perflimit אפשרות, שתגרום
השאילתה לבצע "ORDER BY size DESC LIMIT (perflimit)".

דוגמה 1: תן קריטי אם טבלה כלשהי היא גדולה מ-600MB בבוריק מארח.

check_postgres_table_size --critical='600 MB' --warning='600 MB' --host=burrick

דוגמה 2: התריע אם מוצרי השולחן הם בגודל של מעל 4 GB, ותן קריטי ב-4.5 GB.

check_postgres_table_size --host=burrick --warning='4 GB' --critical='4.5 GB' --include=products

דוגמה 3: הזהר אם אינדקס כלשהו שאינו בבעלות postgres עולה על 500 MB.

check_postgres_index_size --port=5432 --excludeuser=postgres -w 500MB -c 600MB

עבור פלט MRTG, מחזיר את הגודל בבייטים של היחס הגדול ביותר, ואת השם של ה-
מסד נתונים ויחס בתור השורה הרביעית.

ניתוח_אחרון
ואקום_אחרון
last_autoanalyze
ואקום_אוטומטי אחרון
(קישורים סימליים: "check_postgres_last_analyze", "check_postgres_last_vacuum",
"check_postgres_last_autoanalyze", ו-"check_postgres_last_autovacuum") בודק כמה זמן
זה היה מאז שוואקום (או ניתוח) הופעל לאחרונה על כל טבלה במסד נתונים אחד או יותר.
השימוש בפעולות אלו מחייב שמסד הנתונים היעד הוא גרסה 8.3 או מתעלה, או משהו כזה
הגרסה היא 8.2 ומשתנה התצורה stats_row_level הופעל. טבלאות
ניתן לסנן עם --לִכלוֹל ו --לא לכלול אפשרויות. ראה "סינון בסיסי"
סעיף לפרטים נוספים. ניתן לסנן טבלאות גם על ידי בעליהם על ידי שימוש ב-
--includeuser ו --excludeuser אפשרויות. עיין בסעיף "סינון שם משתמש" למידע נוסף
פרטים.

היחידות עבור --אַזהָרָה ו --קריטי מצוינים כזמנים. יחידות חוקיות הן שניות,
דקות, שעות וימים; ניתן לקצר את כולם לאות הראשונה. אם אין יחידות
בהינתן, מניחים 'שניות'. ערכי ברירת המחדל הם 'יום אחד' ו'יומיים'. שימו לב
שיש מקרים שבהם שדה זה אינו מאוכלס אוטומטית. אם בטוח
טבלאות נותנות לך בעיות, ודא שיש להן שורות מתות לשאוב, או סתם
להוציא אותם מהמבחן.

הסכימה בשם 'information_schema' אינה נכללת בבדיקה זו, כטבלאות היחידות שלה
מכיל הם קטנים ואינם משתנים.

שים לב שהגרסאות הלא 'אוטומטיות' יבדקו גם את הגרסאות האוטומטיות. באחר
מילים, שימוש ב-last_vacuum ידווח על הוואקום האחרון, בין אם זה היה ואקום רגיל,
או אחד המופעל על ידי דמון האוטווואקום.

דוגמה 1: התריעו אם שולחן כלשהו לא שואב אבק במשך 3 ימים, ותן קריטי ב-a
שבוע, עבור לענה מארחת

check_postgres_last_vacuum --host=לעננה --warning='3d' --critical='7d'

דוגמה 2: זהה לעיל, אבל דלג על טבלאות השייכות למשתמשים 'ערב' או 'מלורי'

check_postgres_last_vacuum --host=לעננה --warning='3d' --critical='7d' --excludeusers=eve,mallory

עבור פלט MRTG, מחזיר (בשורה הראשונה) את פרק הזמן הקטן ביותר בשניות מאז א
הטבלה שואבה או נותחה לאחרונה. השורה הרביעית מחזירה את שם מסד הנתונים ו
שם הטבלה.

מאזין
("Symlink: check_postgres_listener") אשר שמישהו מקשיב לאחד או יותר
מחרוזות ספציפיות (באמצעות מערכת LISTEN/NOTIFY), על ידי התבוננות בטבלה pg_listener.
יש צורך רק באחד של אזהרה או קריטי. הפורמט הוא מחרוזת פשוטה המייצגת את
LISTEN target, או תו טילדה ואחריו מחרוזת לבדיקת ביטוי רגיל.
שימו לב שבדיקה זו לא תעבוד על גרסאות של Postgres 9.0 ומעלה.

דוגמה 1: תן אזהרה אם אף אחד לא מקשיב למחרוזת bucardo_mcp_ping ביציאות
5555 ו5556

check_postgres_listener --port=5555,5556 --warning=bucardo_mcp_ping

דוגמה 2: תן קריטי אם אין בקשות LISTEN פעילות המתאימות ל-'grimm'
מסד נתונים אוסקר

check_postgres_listener --db oskar --critical=~grimm

עבור פלט MRTG, מחזיר 1 או 0 על הראשון, מציין הצלחה או כישלון. השם
של ההודעה יש לספק באמצעות --mrtg אוֹפְּצִיָה.

מנעולים
("Symlink: check_postgres_locks") בדוק את המספר הכולל של מנעולים באחד או יותר
מסדי נתונים. אין צורך להפעיל זאת יותר מפעם אחת בכל אשכול מסד נתונים. מסדי נתונים יכולים
להיות מסונן עם --לִכלוֹל ו --לא לכלול אפשרויות. עיין בסעיף "סינון בסיסי".
לקבלת פרטים נוספים.

אל האני --אַזהָרָה ו --קריטי ניתן לציין אפשרויות כמספרים פשוטים, המייצגים
המספר הכולל של המנעולים, או שניתן לחלק אותם לפי סוג המנעול. שמות מנעולים חוקיים
הם 'סה"כ', 'ממתין', או שם של סוג מנעול המשמש את Postgres. השמות האלה הם
לא רגיש לאותיות גדולות ולא צריך את החלק ה"נעול" בקצה, אז בלעדי יתאים
'נעלה בלעדית'. הפורמט הוא שם=מספר, עם פריטים שונים מופרדים באמצעות נקודתיים או
נקודה-פסיק (או כל סמל אחר).

דוגמה 1: אזהרה אם מספר המנעולים הוא 100 או יותר, וקריטי אם 200 או יותר, ב-
מארח גארט

check_postgres_locks --host=garrett --warning=100 --critical=200

דוגמה 2: ב-artemus המארח, הזהר אם קיימים 200 מנעולים או יותר, ותן קריטי אם
קיימים למעלה מ-250 מנעולים בסך הכל, או אם קיימים למעלה מ-20 מנעולים בלעדיים, או אם למעלה מ-5 חיבורים
מחכים למנעול.

check_postgres_locks --host=artemus --warning=200 --critical="total=250:waiting=5:exclusive=20"

עבור פלט MRTG, מחזיר את מספר המנעולים בשורה הראשונה, ואת השם של
מסד הנתונים בשורה הרביעית.

קובץ לוג
("Symlink: check_postgres_logfile") מבטיח שקובץ היומן נמצא במיקום הצפוי
ונרשמת אליו. פעולה זו מנפיקה פקודה שמטילה שגיאה על כל אחד מהם
מסד הנתונים שהוא בודק, ומבטיח שההודעה מופיעה ביומנים. זה סורק את
הגדרות log_* שונות בתוך Postgres כדי להבין היכן היומנים צריכים להיות. אם אתה
משתמשים ב-syslog, הוא מבצע סריקה גסה (אך לא חסינת תקלות) של /etc/syslog.conf.
לחלופין, אתה יכול לספק את שם קובץ היומן עם ה- --קובץ לוג אוֹפְּצִיָה. זה
שימושי במיוחד אם ביומנים יש סכימת סיבוב מותאמת אישית המונעת על ידי תוכנית חיצונית.
אל האני --קובץ לוג האופציה תומכת בתווי הבריחה הבאים: "%Y %m %d %H", אשר
מייצגים את השנה, החודש, התאריך והשעה הנוכחיים בהתאמה. שגיאה היא תמיד
דווח כקריטי אלא אם אפשרות האזהרה הועברה כערך שאינו אפס.
מלבד השימוש הספציפי הזה, האפשרויות "--אזהרה" ו-"--קריטיות". לֹא be
מְשׁוּמָשׁ.

דוגמה 1: ביציאה 5432, ודא שקובץ היומן נכתב לקובץ
/home/greg/pg8.2.log

check_postgres_logfile --port=5432 --logfile=/home/greg/pg8.2.log

דוגמה 2: זהה לעיל, אבל העלה אזהרה, לא קריטי

check_postgres_logfile --port=5432 --logfile=/home/greg/pg8.2.log -w 1

עבור פלט MRTG, מחזיר 1 או 0 בשורה הראשונה, המציין הצלחה או כישלון. ב
במקרה של כשל, השורה הרביעית תספק פרטים נוספים על הכשל שנתקל בו.

new_version_bc
("קישור סימלי: check_postgres_new_version_bc") בודק אם גרסה חדשה יותר של הבוקרדו
תוכנית זמינה. הגרסה הנוכחית מתקבלת על ידי הפעלת "bucardo_ctl --version".
אם יש שדרוג גדול, מוחזרת אזהרה. אם שדרוג גרסה הוא
זמין, מוחזר קריטי. (בוקרדו הוא אדון לעבד, ואדון לאדון
מערכת שכפול עבור Postgres: ראה http://bucardo.org למידע נוסף). ראה גם
המידע על האפשרות "--get_method".

new_version_box
("קישור סימלי: check_postgres_new_version_box") בודק אם גרסה חדשה יותר של ה-boxinfo
תוכנית זמינה. הגרסה הנוכחית מתקבלת על ידי הפעלת "boxinfo.pl --version".
אם יש שדרוג גדול, מוחזרת אזהרה. אם שדרוג גרסה הוא
זמין, מוחזר קריטי. (boxinfo היא תוכנית לתפוס חשוב
מידע משרת והכנסתו לפורמט HTML: ראה
http://bucardo.org/wiki/boxinfo למידע נוסף). ראה גם את המידע על
אפשרות "--get_method".

new_version_cp
("Symlink: check_postgres_new_version_cp") בודק אם גרסה חדשה יותר של תוכנית זו
(check_postgres) זמין, על ידי נטילת הגרסה מקובץ טקסט קטן ב-main
עמוד הבית של הפרויקט. מחזיר אזהרה אם הגרסה המוחזרת לא
להתאים לזה שאתה רץ. המרווח המומלץ לבדיקה הוא פעם ביום. ראה גם את
מידע על האפשרות "--get_method".

new_version_pg
("Symlink: check_postgres_new_version_pg") בודק אם קיימת גרסה חדשה יותר של Postgres
עבור כל מסד נתונים שמחובר אליו. שים לב שזה רק בודק עדכון, למשל מעבר מ
8.3.6 עד 8.3.7. תיקונים תמיד תואמים 100% בינאריים ואינם כוללים dump ו
שחזר כדי לשדרג. נעשו תיקונים כדי לטפל בבאגים, לכן שדרוג בהקדם האפשרי
תמיד מומלץ. מחזיר אזהרה אם אין לך את הגרסה האחרונה. זה
מומלץ לבצע בדיקה זו לפחות פעם ביום. ראה גם את המידע על
אפשרות "--get_method".

new_version_tnm
("symlink: check_postgres_new_version_tnm") בודק אם גרסה חדשה יותר של ה-tail_n_mail
תוכנית זמינה. הגרסה הנוכחית מתקבלת על ידי הפעלת "tail_n_mail --version".
אם יש שדרוג גדול, מוחזרת אזהרה. אם שדרוג גרסה הוא
זמין, מוחזר קריטי. (tail_n_mail הוא כלי ניטור יומן שיכול לשלוח
דואר כאשר אירועים מעניינים מופיעים ביומני Postgres שלך. לִרְאוֹת:
http://bucardo.org/wiki/Tail_n_mail למידע נוסף). ראה גם את המידע על
האפשרות "--get_method".

pgb_pool_cl_active
pgb_pool_cl_waiting
pgb_pool_sv_active
pgb_pool_sv_idle
pgb_pool_sv_used
pgb_pool_sv_tested
pgb_pool_sv_login
pgb_pool_maxwait
(קישורים סימליים: "check_postgres_pgb_pool_cl_active", "check_postgres_pgb_pool_cl_waiting",
"check_postgres_pgb_pool_sv_active", "check_postgres_pgb_pool_sv_idle",
"check_postgres_pgb_pool_sv_used", "check_postgres_pgb_pool_sv_tested",
"check_postgres_pgb_pool_sv_login", ו-"check_postgres_pgb_pool_maxwait")

בוחן את סטטיסטיקת הבריכה של pgbouncer. לכל בריכה יש קבוצה של חיבורי "לקוח",
הכוונה לחיבורים מלקוחות חיצוניים, וחיבורי "שרת", הכוונה
חיבורים ל-PostgreSQL עצמו. הפעולות הקשורות ל-check_postgres מופיעות בקידומת "cl_"
ו-"sv_", בהתאמה. חיבורי לקוח פעילים הם אותם חיבורים המקושרים כעת
עם חיבור שרת פעיל. חיבורי לקוחות עשויים גם להיות "ממתינים", כלומר הם
עדיין לא הוקצה להם חיבור לשרת. חיבורי השרת "פעילים" (מקושרים
ללקוח), "בטלה" (עמידה לחיבור לקוח לקשר איתו), "משומש" (סתם
מנותק מלקוח, ועדיין לא הוחזר למאגר הבטלה), "נבדק" (נמצא כרגע
נבדק) ו"כניסה" (בתהליך ההתחברות). ערך maxwait מראה כמה זמן פנימה
שניות חיבור הלקוח הממתין הישן ביותר חיכה.

pgbouncer_backends
("Symlink: check_postgres_pgbouncer_backends") בודק את מספר החיבורים הנוכחי
עבור מסד נתונים אחד או יותר באמצעות pgbouncer, ואופציונלי משווה אותו למקסימום
מותר, אשר נקבע על ידי משתנה התצורה pgbouncer max_client_conn. ה
--אַזהָרָה ו --קריטי אפשרויות יכולות ללבוש אחת משלוש צורות. ראשית, מספר פשוט יכול
להיות נתון, המייצג את מספר החיבורים שבהם תינתן ההתראה.
בחירה זו אינה משתמשת ב- max_connections הגדרה. שנית, אחוז הפנוי
ניתן לתת קשרים. שלישית, ניתן לתת מספר שלילי המייצג את
מספר החיבורים שנותרו עד max_connections מגיע. ערכי ברירת המחדל עבור
--אַזהָרָה ו --קריטי הם '90%' ו-'95%'. אתה יכול גם לסנן את מסדי הנתונים על ידי שימוש ב
מה היא --לִכלוֹל ו --לא לכלול אפשרויות. עיין בסעיף "סינון בסיסי" לפרטים נוספים.

כדי להציג רק תהליכים שאינם פעילים, אתה יכול להשתמש ב- --נודל טַעֲנָה. שים לב שהמשתמש אתה
מתחברים כי הם חייבים להיות משתמש-על כדי שזה יעבוד כמו שצריך.

דוגמה 1: תן אזהרה כאשר מספר החיבורים ב-quirm המארח מגיע ל-120, ו-
קריטי אם הוא מגיע ל-150.

check_postgres_pgbouncer_backends --host=quirm --warning=120 --critical=150 -p 6432 -u pgbouncer

דוגמה 2: תן קריטי כאשר נגיע ל-75% מהגדרת max_connections שלנו במארחים
lancre או lancre2.

check_postgres_pgbouncer_backends --warning='75%' --critical='75%' --host=lancre,lancre2 -p 6432 -u pgbouncer

דוגמה 3: תן אזהרה כאשר נותרו רק 10 חריצי חיבור נוספים במארח
פלסמיד, וקריטי כשנותרו לנו רק 5.

check_postgres_pgbouncer_backends --warning=-10 --critical=-5 --host=plasmid -p 6432 -u pgbouncer

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

pgbouncer_checksum
("Symlink: check_postgres_pgbouncer_checksum") בודק שכל ההגדרות של pgBouncer הן
זהה לפעם האחרונה שבדקת. זה נעשה על ידי הפקת סכום ביקורת של רשימה ממוינת
של קביעת שמות וערכיהם. שים לב שאתה לא צריך לציין את שם מסד הנתונים, זה
ברירת המחדל תהיה אוטומטית ל-pgbouncer. או את --אַזהָרָה או --קריטי אוֹפְּצִיָה
צריך לתת, אבל לא את שניהם. הערך של כל אחד מהם הוא סכום הבדיקה, 32 תווים
ערך הקסדצימלי. אתה יכול לרוץ עם האפשרות המיוחדת "--critical=0" כדי לגלות
סכום בדיקה קיים.

פעולה זו דורשת את המודול Digest::MD5.

דוגמה 1: מצא את סכום הבדיקה הראשוני עבור תצורת pgbouncer ביציאה 6432 באמצעות ה-
משתמש ברירת מחדל (בדרך כלל postgres)

check_postgres_pgbouncer_checksum --port=6432 --critical=0

דוגמה 2: ודא ששום הגדרות לא השתנו והזהיר אם כן, באמצעות סכום הבדיקה מ
מֵעַל.

check_postgres_pgbouncer_checksum --port=6432 --warning=cd2f3b5e129dc2b4f5c0f6d8d2e64231

עבור פלט MRTG, מחזיר 1 או 0 המצביע על הצלחה של כישלון בהתאמה של סכום הבדיקה.
יש לספק סכום ביקורת כארגומנט "--mrtg". השורה הרביעית תמיד נותנת את ה
סכום בדיקה נוכחי.

pgagent_jobs
("Symlink: check_postgres_pgagent_jobs") בודק שכל המשרות של pgAgent שיש להן
שבוצעו במרווח הזמן הקודם הצליחו. זה נעשה על ידי בדיקה עבור
כל השלבים שיש להם תוצאה שאינה אפס.

ניתן לציין "--אזהרה" או "--קריטי", או שניהם, כזמנים, והעבודות יהיו
נבדק עבור כשלים בתוך פרקי הזמן שצוינו לפני השעה הנוכחית. תָקֵף
יחידות הן שניות, דקות, שעות וימים; ניתן לקצר את כולם לאות הראשונה.
אם לא ניתנות יחידות, מניחים 'שניות'.

דוגמה 1: תן קריטי כאשר כל עבודות שבוצעו ביממה האחרונה נכשלו.

check_postgres_pgagent_jobs --critical=1d

דוגמה 2: תן אזהרה כאשר כל עבודות שבוצעו בשבוע האחרון נכשלו.

check_postgres_pgagent_jobs --warning=7d

דוגמה 3: תן קריטי עבור עבודות שנכשלו ב-2 השעות האחרונות ואזהרה עבור
עבודות שנכשלו ב-4 השעות האחרונות:

check_postgres_pgagent_jobs --critical=2h --warning=4h

ready_txns
("קישור סימלי: check_postgres_prepared_txns") בדוק את הגיל של כל מוכן קיים
עסקאות. שימו לב שרוב האנשים לא ישתמשו בעסקאות מוכנות, מכיוון שהן חלק
מחויבות דו-חלקית ומסובכת לתחזוקה. אסור גם לבלבל ביניהם
הצהרות מוכנות, וזה מה שרוב האנשים חושבים עליו כשהם שומעים להכין. ה
ערך ברירת המחדל לאזהרה הוא שנייה אחת, כדי לזהות כל שימוש בעסקאות מוכנות, אשר
זו כנראה טעות ברוב המערכות. אזהרה וקריטי הם מספר השניות א
עסקה מוכנה נפתחה לפני מתן התראה.

דוגמה 1: תן אזהרה על זיהוי עסקאות מוכנות:

check_postgres_prepared_txns -w 0

דוגמה 2: תן קריטי אם עסקה מוכנה הייתה פתוחה יותר מ-10
שניות, אך אפשר עד 360 שניות עבור מסד הנתונים 'shrike':

check_postgres_prepared_txns --critical=10 --exclude=shrike
check_postgres_prepared_txns --critical=360 --include=shrike

עבור פלט MRTG, מחזיר את מספר השניות שהעסקה הישנה ביותר הייתה פתוחה בתור
השורה הראשונה, ומאיזה מסד נתונים הגיע בתור השורה האחרונה.

query_runtime
("symlink: check_postgres_query_runtime") בודק כמה זמן לוקח שאילתה ספציפית לרוץ,
על ידי ביצוע "הסבר ניתוח" נגדו. ה --אַזהָרָה ו --קריטי אפשרויות הן
משך הזמן המקסימלי שהשאילתה צריכה לקחת. יחידות תקפות הן שניות, דקות ושעות;
ניתן לקצר כל אחד לאות הראשונה. אם לא ניתנות יחידות, מניחים 'שניות'.
יש לתת גם את האזהרה וגם את האפשרות הקריטית. שם התצוגה או הפונקציה
כדי להפעיל יש להעביר ל- --שם שאילתה אוֹפְּצִיָה. זה חייב להיות מורכב ממילה אחת
(או schema.word), עם עותקים אופציונליים בסוף.

דוגמה 1: תן קריטי אם הפונקציה בשם "speedtest" לא מצליחה לפעול תוך 10 שניות או
פָּחוּת.

check_postgres_query_runtime --queryname='speedtest()' --critical=10 --warning=10

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

שאילתה_זמן
("Symlink: check_postgres_query_time") בודק את משך השאילתות הרצות באחת או יותר
מסדי נתונים. אין צורך להפעיל את זה יותר מפעם אחת על אותו אשכול מסד נתונים. הערה
שזה כבר לא כולל שאילתות שהן "בטלות בעסקה". מסדי נתונים יכולים להיות
מסונן על ידי שימוש ב- --לִכלוֹל ו --לא לכלול אפשרויות. עיין בסעיף "סינון בסיסי".
לפרטים נוספים. אתה יכול גם לסנן על המשתמש שמפעיל את השאילתה עם ה --includeuser
ו --excludeuser אפשרויות. עיין בסעיף "סינון שם משתמש" לפרטים נוספים.

הערכים עבור --אַזהָרָה ו --קריטי האפשרויות הן כמויות זמן, וברירת המחדל היא '2
דקות' ו-'5 דקות' בהתאמה. יחידות חוקיות הן 'שניות', 'דקות', 'שעות' או
'ימים'. כל אחד יכול להיכתב ביחיד או בקיצור לאות הראשונה בלבד. אם אין יחידות
ניתנים, ההנחה היא שהיחידה היא שניות.

פעולה זו דורשת Postgres 8.1 ומעלה.

דוגמה 1: תן אזהרה אם שאילתה כלשהי רצה יותר מ-3 דקות, וכן א
קריטי אם יותר מ-5 דקות.

check_postgres_query_time --port=5432 --warning='3 דקות' --critical='5 דקות'

דוגמה 2: באמצעות ערכי ברירת מחדל (2 ו-5 דקות), בדוק את כל מסדי הנתונים מלבד אלה
מתחיל ב'תבנית'.

check_postgres_query_time --port=5432 --exclude=~^תבנית

דוגמה 3: אזהרה אם למשתמש 'don' יש שאילתה שפועלת מעל 20 שניות

check_postgres_query_time --port=5432 --includeuser=don --warning=20s

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

replicate_row
("Symlink: check_postgres_replicate_row") בודק ששכפול מאסטר-עבד עובד
לעבד אחד או יותר.

האפשרויות הראשונות "--dbname", "--host" ו-"--port" וכו' נחשבות למאסטר;
השימושים הבאים הם העבדים. הערכים או ה --אַזהָרָה ו --קריטי האפשרויות הן
יחידות זמן, ויש לספק לפחות אחת (ללא ברירת מחדל). יחידות חוקיות הן 'שניות',
'דקות', 'שעות' או 'ימים'. כל אחד יכול להיכתב ביחיד או בקיצור ל-
מכתב ראשון. אם לא ניתנות יחידות, ההנחה היא שהיחידות הן שניות.

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

דוגמה 1: סלוני משכפל טבלה בשם 'הזמנות' מהמארח 'אלפא' לארח 'בטא',
במסד הנתונים 'מכירות'. המפתח הראשי של הטבלה נקרא id, ואנחנו הולכים לעשות זאת
בדוק את השורה עם מזהה של 3 (שהוא היסטורי ולעולם לא השתנה). יש עמודה
בשם 'salesrep' שאנו הולכים להחליף מערך 'slon' ל-'nols' כדי לבדוק
השכפול. אנחנו רוצים לזרוק אזהרה אם השכפול לא מתרחש תוך 10
שניות.

check_postgres_replicate_row --host=alpha --dbname=sales --host=beta
--dbname=sales --warning=10 --repinfo=orders,id,3,salesrep,slon,nols

דוגמה 2: בוקרדו משכפל טבלה בשם 'קבלה' מהמארח 'ירוק' למארחים
'אדום', 'כחול' ו'צהוב'. מסד הנתונים של שני הצדדים הוא 'ציבורי'. מסדי הנתונים של העבדים
פועלים ביציאה 5455. המפתח הראשי נקרא 'receipt_id', השורה בה אנו רוצים להשתמש
יש ערך של 9, והעמודה שאנו רוצים לשנות עבור הבדיקה נקראת 'אזור'. נו
החלף בין 'צפון' ל'דרום' עבור הערך של עמודה זו, וזרוק אם קריטי
השינוי אינו על שלושת העבדים תוך 5 שניות.

check_postgres_replicate_row --host=green --port=5455 --host=red,blue,yellow
--critical=5 --repinfo=receipt,receipt_id,9,zone,north,south

עבור פלט MRTG, מחזיר בשורה הראשונה את הזמן בשניות שאליו לוקח השכפול
סיים. הזמן המרבי מוגדר ל-4 דקות 30 שניות: אם לא נמשכה שכפול
במקום בזמן הארוך הזה, נזרקת שגיאה.

same_schema
("symlink: check_postgres_same_schema") מאמת ששני מסדי נתונים או יותר זהים
לגבי הסכימה שלהם (אבל לא הנתונים שבתוכו). זה שימושי במיוחד להכנה
בטוח שהעבדים שלך לא שונו או הושחתו בשום צורה בעת השימוש מאסטר לעבד
שכפול. בניגוד לרוב הפעולות האחרות, אין לזה אזהרה או קריטריונים קריטיים - ה
מסדי נתונים מסונכרנים או שלא. אם הם שונים, רשימה מפורטת של
מוצגים הבדלים.

ייתכן שתרצה לא לכלול או לסנן הבדלים מסוימים. הדרך לעשות זאת היא להוסיף
מחרוזות לאפשרות "--פילטר". כדי לא לכלול סוג של אובייקט, השתמש ב-"noname", כאשר 'שם'
הוא סוג האובייקט, למשל, "noschema". כדי להוציא אובייקטים מסוג מסוים על ידי א
ביטוי רגולרי כנגד שמם, השתמש ב-"noname=regex". ראה את הדוגמאות שלהלן עבור א
הבנה טובה יותר.

סוגי האובייקטים שניתן לסנן כוללים:

המשתמש
סכימה
שולחן
נוף
מדד
רצף
-
להפעיל
פונקציה

אפשרות הסינון "noposition" מונעת אימות של מיקום העמודות בתוך a
השולחן.

אפשרות הסינון "nofuncbody" מונעת השוואה בין גופי כל הפונקציות.

אפשרות הסינון "noperm" מונעת השוואה של הרשאות אובייקט.

כדי לספק את מסד הנתונים השני, פשוט הוסף את ההבדלים למסד הנתונים הראשון על ידי קריאה אל
טיעון החיבור המתאים. לדוגמה, כדי להשוות מסדי נתונים על מארחים אלפא ו
bravo, השתמש ב-"--dbhost=alpha,bravo". ראה גם את הדוגמאות שלהלן.

אם ניתן רק מארח בודד, ההנחה היא שאנו עושים דוח "מבוסס זמן". ה
בפעם הראשונה זה מופעל תמונת מצב של כל הפריטים במסד הנתונים נשמרת ב-local
קוֹבֶץ. כאשר אתה מפעיל אותו שוב, תמונת המצב הזו נקראת והופכת ל"מסד נתונים מס' 2" וזהו
בהשוואה למסד הנתונים הנוכחי.

כדי להחליף את הקובץ הישן המאוחסן בגרסה החדשה, השתמש בארגומנט --replace.

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

דוגמה 1: ודא ששני מסדי נתונים על כוכב וקו מארחים זהים:

check_postgres_same_schema --dbhost=star,line

דוגמה 2: זהה לקודם, אך אל תכלול טריגרים עם "סלוני" בשמם

check_postgres_same_schema --dbhost=star,line --filter="notrigger=slony"

דוגמה 3: זהה לקודם, אבל גם אל תכלול את כל האינדקסים

check_postgres_same_schema --dbhost=star,line --filter="notrigger=slony noindexes"

דוגמה 4: בדוק הבדלים עבור מסד הנתונים "battlestar" ביציאות שונות

check_postgres_same_schema --dbname=battlestar --dbport=5432,5544

דוגמה 5: צור קובץ תמונת מצב יומי ושבועי

check_postgres_same_schema --dbname=cylon --suffix=יומי
check_postgres_same_schema --dbname=cylon --suffix=weekly

דוגמה 6: הפעל השוואה היסטורית, ולאחר מכן החלף את הקובץ

check_postgres_same_schema --dbname=cylon --suffix=daily --replace

רצף
("Symlink: check_postgres_sequence") בודק כמה מקום נשאר בכל הרצפים ב-
מאגר מידע. זה נמדד כאחוז מסך הערכים האפשריים שנעשה בהם שימוש
עבור כל רצף. ה --אַזהָרָה ו --קריטי אפשרויות צריכות להתבטא כ
אחוזים. ערכי ברירת המחדל הם 85% עבור האזהרה ו 95% עבור הקריטיים. אתה יכול
השתמש ב--include ו--exclude כדי לשלוט באילו רצפים יש לבדוק. שימו לב שזה
צ'ק אכן מסביר חריגות ערך נמוך ו תוֹסֶפֶת by ערכים, אבל לא אכפת לו אם
רצף מוגדר למחזור או לא.

הפלט עבור Nagios נותן את שם הרצף, האחוז בשימוש והמספר
של 'שיחות' שנותרו, המציין כמה פעמים נוספות ניתן לקרוא ל- Nextval ברצף זה
לפני שנכנסים לערך המקסימלי.

הפלט עבור MRTG מחזיר את האחוז הגבוה ביותר בכל הרצפים בשורה הראשונה,
והשם של כל רצף עם האחוז הזה בשורה הרביעית, מופרדים בסימן "|"
(צינור) אם יש יותר מרצף אחד באחוז זה.

דוגמה 1: תן אזהרה אם רצפים כלשהם מתקרבים ל-95% מלאים.

check_postgres_sequence --dbport=5432 --warning=95%

דוגמה 2: בדוק שהרצף בשם "orders_id_seq" אינו יותר מחצי מלא.

check_postgres_sequence --dbport=5432 --critical=50% --include=orders_id_seq

settings_checksum
("Symlink: check_postgres_settings_checksum") בודק שכל ההגדרות של Postgres הן
זהה לפעם האחרונה שבדקת. זה נעשה על ידי הפקת סכום ביקורת של רשימה ממוינת
של קביעת שמות וערכיהם. שים לב שיכול להיות למשתמשים שונים באותו מסד נתונים
סכומי ביקורת שונים, עקב השימוש ב-ALTER USER, ובשל העובדה שמשתמשי-על רואים יותר
הגדרות מאשר משתמשים רגילים. או את --אַזהָרָה או --קריטי האפשרות צריכה להיות
נתון, אבל לא שניהם. הערך של כל אחד מהם הוא סכום הבדיקה, הקסדצימלי בן 32 תווים
ערך. אתה יכול לרוץ עם האפשרות המיוחדת "--critical=0" כדי לגלות קיים
סכום בדיקה.

פעולה זו דורשת את המודול Digest::MD5.

דוגמה 1: מצא את סכום הבדיקה הראשוני עבור מסד הנתונים ביציאה 5555 באמצעות משתמש ברירת המחדל
(בדרך כלל postgres)

check_postgres_settings_checksum --port=5555 --critical=0

דוגמה 2: ודא ששום הגדרות לא השתנו והזהיר אם כן, באמצעות סכום הבדיקה מ
מֵעַל.

check_postgres_settings_checksum --port=5555 --warning=cd2f3b5e129dc2b4f5c0f6d8d2e64231

עבור פלט MRTG, מחזיר 1 או 0 המצביע על הצלחה של כישלון בהתאמה של סכום הבדיקה.
יש לספק סכום ביקורת כארגומנט "--mrtg". השורה הרביעית תמיד נותנת את ה
סכום בדיקה נוכחי.

slony_status
("Symlink: check_postgres_slony_status") בודק סטטוס של אשכול סלוני על ידי
מסתכל על התוצאות של תצוגת sl_status של סלוני. זה מוחזר כמספר של
שניות של "זמן פיגור". ה --אַזהָרָה ו --קריטי אפשרויות צריכות להתבטא כזמנים.
ערכי ברירת המחדל הם 60 שניות עבור האזהרה ו 300 שניות עבור הקריטיים.

הטיעון האופציונאלי --סכֵימָה ציינה את הסכימה שמתחתיה מותקן סלוני. אם זה
לא נתון, הסכימה תקבע אוטומטית בכל פעם שבדיקה זו מופעלת.

דוגמה 1: תן אזהרה אם סלוני נמצא בפיגור של יותר מ-20 שניות

check_postgres_slony_status -- אזהרה 20

דוגמה 2: תן קריטי אם סלוני, המותקן תחת הסכימה "_slony", הוא מעל 10
דקות בפיגור

check_postgres_slony_status --schema=_slony --critical=600

סינכרון זמן
("symlink: check_postgres_timesync") משווה את זמן המערכת המקומית לשעה שדווחה
על ידי מסד נתונים אחד או יותר. ה --אַזהָרָה ו --קריטי אפשרויות מייצגות את מספר
שניות בין שתי המערכות לפני מתן התראה. אם אף אחד מהם לא מצוין, ה
נעשה שימוש בערכי ברירת מחדל, שהם '2' ו-'5'. ערך האזהרה לא יכול להיות גדול מ
הערך הקריטי. בשל האופי הלא מדויק של בדיקה זו, ערכים של '0' או '1' אינם
מומלץ.

המחרוזת שהוחזרה מציגה את הפרש הזמן וכן את הזמן שנכתב בכל צד
החוצה.

דוגמה 1: בדוק שמסדי נתונים על המארחים ankh, morpork ו-klatch אינם יותר מ-3
שניות הנחה מהזמן המקומי:

check_postgres_timesync --host=ankh,morpork,klatch --critical=3

עבור פלט MRTG, מחזיר אחד מהשורה הראשונה את מספר השניות ההפרש בין
זמן מקומי וזמן מסד הנתונים. השורה הרביעית מחזירה את שם מסד הנתונים.

txn_idle
("סמל קישור: check_postgres_txn_idle") בודק את המספר ומשך הזמן של "בטל ב
טרנזקציה" במסד נתונים אחד או יותר. אין צורך להפעיל זאת יותר מפעם אחת
על אותו אשכול מסד נתונים. ניתן לסנן מסדי נתונים באמצעות ה --לִכלוֹל ו
--לא לכלול אפשרויות. עיין בסעיף "סינון בסיסי" למטה לפרטים נוספים.

אל האני --אַזהָרָה ו --קריטי אפשרויות ניתנות כיחידות זמן, מספרים שלמים בסימן, או
מספרים שלמים עבור יחידות זמן, ויש לספק את שניהם (אין ברירות מחדל). יחידות תקפות
הם 'שניות', 'דקות', 'שעות' או 'ימים'. כל אחד יכול להיכתב ביחיד או מקוצר
רק לאות הראשונה. אם לא ניתנות יחידות והמספרים לא מסומנים, היחידות
מניחים שהם שניות.

פעולה זו דורשת Postgres 8.3 ומעלה.

דוגמה 1: תן אזהרה אם חיבור כלשהו היה פעיל בעסקה במשך יותר מ-15
שניות:

check_postgres_txn_idle --port=5432 --warning='15 שניות'

דוגמה 2: תן אזהרה אם יש 50 עסקאות או יותר

check_postgres_txn_idle --port=5432 --warning='+50'

דוגמה 3: תן קריטי אם 5 חיבורים או יותר לא היו פעילים בעסקה במשך יותר
מ-10 שניות:

check_postgres_txn_idle --port=5432 --critical='5 למשך 10 שניות'

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

txn_time
("symlink: check_postgres_txn_time") בודק את אורך העסקאות הפתוחות באחת או יותר
מסדי נתונים. אין צורך להפעיל פקודה זו יותר מפעם אחת בכל אשכול מסד נתונים.
ניתן לסנן מסדי נתונים על ידי שימוש ב- --לִכלוֹל ו --לא לכלול אפשרויות. ראה את "בסיס
סעיף סינון" לפרטים נוספים. ניתן גם לסנן את בעל העסקה, לפי
שימוש --includeuser ו --excludeuser אפשרויות. עיין בסעיף "סינון שם משתמש".
לקבלת פרטים נוספים.

הערכים או ה --אַזהָרָה ו --קריטי אפשרויות הן יחידות זמן, ויש לספק אותן
(ללא ברירת מחדל). יחידות חוקיות הן 'שניות', 'דקות', 'שעות' או 'ימים'. כל אחד יכול להיות
כתוב ביחיד או בקיצור לאות הראשונה בלבד. אם לא ניתנות יחידות, ה
ההנחה היא שהיחידות הן שניות.

פעולה זו דורשת Postgres 8.3 ומעלה.

דוגמה 1: תן קריטי אם עסקה כלשהי הייתה פתוחה במשך יותר מ-10 דקות:

check_postgres_txn_time --port=5432 --critical='10 דקות'

דוגמה 1: אזהרה אם למשתמש 'מחסן' יש עסקה פתוחה מעל 30 שניות

check_postgres_txn_time --port-5432 --warning=30s --includeuser=מחסן

עבור פלט MRTG, מחזיר את הזמן המרבי בשניות שעסקה הייתה פתוחה ב-
שורה ראשונה. השורה הרביעית נותנת את שם מסד הנתונים.

txn_wraparound
("Symlink: check_postgres_txn_wraparound") בודק כמה קרוב לעסקה המקיפה אחת
או יותר מסדי נתונים מקבלים. ה --אַזהָרָה ו --קריטי אפשרויות מציינות את המספר
של העסקאות שנעשו, וחייב להיות מספר שלם חיובי. אם אחת מהאפשרויות לא ניתנת, ה
נעשה שימוש בערכי ברירת מחדל של 1.3 ו-1.4 מיליארד. אין צורך להפעיל את הפקודה הזו יותר
מפעם אחת בכל אשכול מסד נתונים. לדיון מפורט יותר על מה המספר הזה
מייצג ומה לעשות בקשר לזה, בקר בדף
<http://www.postgresql.org/docs/current/static/routine-vacuuming.html#VACUUM-FOR-WRAPAROUND>

האזהרה והערכים הקריטיים יכולים להיות בעלי קו דגש במספר לקריאות, כמו Perl
עושה.

דוגמה 1: בדוק את ערכי ברירת המחדל עבור מסד הנתונים של localhost

check_postgres_txn_wraparound --host=localhost

דוגמה 2: בדוק את יציאה 6000 ותן ערך קריטי כאשר נפגעו 1.7 מיליארד עסקאות:

check_postgres_txn_wraparound --port=6000 --critical=1_700_000_000

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

גרסה
("Symlink: check_postgres_version") בודק שהגרסה הנדרשת של Postgres היא
רץ. ה --אַזהָרָה ו --קריטי האפשרויות (נדרש רק אחת) חייבות להיות בפורמט
שי or XYZ איפה X הוא מספר הגרסה העיקרי, Y הוא מספר הגרסה המשני, ו Z is
התיקון.

דוגמה 1: תן אזהרה אם מסד הנתונים ביציאה 5678 אינו גרסה 8.4.10:

check_postgres_version --port=5678 -w=8.4.10

דוגמה 2: תן אזהרה אם מסדי נתונים כלשהם על עמק מארח, תבואה או שמש אינם 8.3:

check_postgres_version -H valley,grain,sunshine --critical=8.3

עבור פלט MRTG, מדווח על 1 או 0 המציין הצלחה או כישלון בשורה הראשונה. ה
השורה הרביעית מציינת את הגרסה הנוכחית. יש לספק את הגרסה באמצעות "--mrtg"
אוֹפְּצִיָה.

wal_files
("Symlink: check_postgres_wal_files") בודק כמה קבצי WAL קיימים ב- pg_xlog
ספרייה, שנמצאת מחוץ שלך data_directory, לפעמים כקישור סימן לאחר
דיסק פיזי מטעמי ביצועים. פעולה זו חייבת להיות מופעלת כמשתמש-על, כדי לעשות זאת
לגשת לתוכן של pg_xlog מַדרִיך. הגרסה המינימלית לשימוש בפעולה זו היא
Postgres 8.1. ה --אַזהָרָה ו --קריטי האפשרויות הן פשוט מספר הקבצים ב-
pg_xlog מַדרִיך. לאיזה מספר להגדיר את זה ישתנה, אבל הנחיה כללית היא לשים
מספר מעט גבוה ממה שיש בדרך כלל, כדי לתפוס בעיות מוקדם.

בדרך כלל, קבצי WAL נסגרים ולאחר מכן נעשה בהם שימוש חוזר, אך עסקה פתוחה לאורך זמן, או א
פגום פקודה_ארכיון script, עלול לגרום ל-Postgres ליצור יותר מדי קבצים. בסופו של דבר,
זה יגרום לדיסק שהם נמצאים בו להיגמר מקום, ובשלב זה Postgres יעשה זאת
לכבות.

דוגמה 1: בדוק שמספר קבצי WAL הוא 20 או פחות במארח "pluto"

check_postgres_wal_files --host=pluto --critical=20

עבור פלט MRTG, מדווח על מספר קבצי WAL בשורה 1.

לבנות מחדש_קישורים סימנים
rebuild_symlinks_force
פעולה זו אינה דורשת ארגומנטים אחרים, ואינה מתחברת לשום מסדי נתונים, אלא פשוט
יוצר סימלינקים בספרייה הנוכחית עבור כל פעולה, בטופס
check_postgres_. אם הקובץ כבר קיים, הוא לא יוחלף. אם
הפעולה היא rebuild_symlinks_force, ואז סימלינקים יוחלפו. האפשרות
--symlinks היא דרך קצרה יותר לומר --action=rebuild_symlinks

בסיסי סינון

האפשרויות --לִכלוֹל ו --לא לכלול ניתן לשלב כדי להגביל אילו דברים נבדקים,
בהתאם לפעולה. ניתן לסנן את שם מסד הנתונים בעת שימוש בכתובת הבאה
פעולות: backends, database_size, locks, query_time, txn_idle ו-txn_time. השם של
ניתן לסנן קשר בעת שימוש בפעולות הבאות: bloat, index_size,
table_size, relation_size, last_vacuum, last_autovacuum, last_analyze, ו
last_autoanalyze. ניתן לסנן שם של הגדרה בעת שימוש ב- settings_checksum
פעולה. ניתן לסנן שם של מערכת קבצים בעת שימוש בפעולת disk_space.

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

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

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

דוגמאות:

בודק רק פריטים בשם pg_class:

--include=pg_class

בודק רק פריטים המכילים את האותיות 'pg_':

--include=~pg_

בדוק רק פריטים שמתחילים ב-'pg_':

--include=~^pg_

אל תכלול את הפריט בשם 'מבחן':

--exclude=מבחן

אל תכלול את כל הפריטים המכילים את האותיות 'מבחן:

--exclude=~test

אל תכלול את כל הפריטים בסכימה 'pg_catalog':

--exclude='pg_catalog.'

אל תכלול את כל הפריטים המכילים את האותיות 'ace', אך אפשר את הפריט 'faceoff':

--exclude=~ace --include=faceoff

אל תכלול את כל הפריטים שמתחילים באותיות 'pg_', המכילות את האותיות 'slon', או
אשר נקראים 'sql_settings' או 'green'. בדוק במיוחד פריטים עם האותיות
'prod' בשמותיהם, ותמיד בדוק את הפריט בשם 'pg_relname':

--exclude=~^pg_,~slon,sql_settings --exclude=green --include=~prod,pg_relname

משתמש שֵׁם סינון

האפשרויות --includeuser ו --excludeuser ניתן להשתמש בפעולות מסוימות רק כדי לבחון
אובייקטי מסד נתונים בבעלות (או לא בבעלות) משתמש אחד או יותר. א --includeuser אוֹפְּצִיָה
תמיד גובר על א --excludeuser אוֹפְּצִיָה. אתה יכול לתת לכל אפשרות יותר מפעם אחת עבור
משתמשים מרובים, או שאתה יכול לתת רשימה מופרדת בפסיקים. הפעולות שמשתמשות כרגע
האפשרויות האלה הן:

גודל_בסיס הנתונים
ניתוח_אחרון
last_autoanalyze
ואקום_אחרון
ואקום_אוטומטי אחרון
שאילתה_זמן
גודל_יחס
txn_time

דוגמאות:

בדוק רק פריטים שבבעלות המשתמש בשם greg:

--includeuser=greg

בדוק רק פריטים שבבעלות ווטסון או קריק:

--includeuser=watson,crick

בדוק רק פריטים בבעלות קריק, פרנקלין, ווטסון או וילקינס:

--includeuser=watson --includeuser=פרנקלין --includeuser=crick,wilkins

סמן את כל הפריטים מלבד אלה השייכים למשתמש סקוט:

--excludeuser=scott

מבחן MODE

כדי לעזור בהגדרת דברים, ניתן להפעיל תוכנית זו ב"מצב בדיקה" על ידי ציון ה
--מִבְחָן אוֹפְּצִיָה. זה יבצע כמה בדיקות בסיסיות כדי לוודא שבסיסי הנתונים יכולים להיות
יצירת קשר, וכי תנאים מוקדמים מסוימים לכל פעולה מתקיימים, כגון האם המשתמש כן
משתמש-על, אם הגרסה של Postgres חדשה מספיק, ואם stats_row_level מופעלת.

השתמש ב-check_postgres_table_sizep באינטרנט באמצעות שירותי onworks.net