check_postgres_pgb_pool_cl_waitingp - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

check_postgres - നാഗിയോസ്, MRTG, Cacti എന്നിവയ്‌ക്കും മറ്റുമുള്ള ഒരു പോസ്റ്റ്‌ഗ്രെസ് മോണിറ്ററിംഗ് സ്‌ക്രിപ്റ്റ്

ഈ പ്രമാണങ്ങൾ check_postgres പതിപ്പ് 2.22.0 വിവരിക്കുന്നു

സിനോപ്സിസ്

## എല്ലാ സിംലിങ്കുകളും സൃഷ്ടിക്കുക
check_postgres --symlinks

## പോസ്റ്റ്ഗ്രെസ് ഡാറ്റാബേസ് 'പ്ലൂട്ടോ'യിലേക്കുള്ള കണക്ഷൻ പരിശോധിക്കുക:
check_postgres --action=connection --db=pluto

## സമാന കാര്യങ്ങൾ, എന്നാൽ സിംലിങ്ക് ഉപയോഗിക്കുന്നു
check_postgres_connection --db=pluto

## 100 ലോക്കുകൾ ആണെങ്കിൽ മുന്നറിയിപ്പ് നൽകുക
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
പോസ്റ്റ്ഗ്രെസ് ഡാറ്റാബേസുകൾ. ഇത് psql പ്രോഗ്രാം ഉപയോഗിച്ച് വിവരങ്ങൾ ശേഖരിക്കുകയും ഔട്ട്പുട്ട് ചെയ്യുകയും ചെയ്യുന്നു
മൂന്ന് ഫോർമാറ്റുകളിലൊന്നിൽ ഫലങ്ങൾ: നാഗിയോസ്, എംആർടിജി, അല്ലെങ്കിൽ ലളിതം.

ഔട്ട്പുട്ട് മോഡുകൾ
"--ഔട്ട്പുട്ട്" ഓപ്ഷൻ ഉപയോഗിച്ച് ഔട്ട്പുട്ട് മാറ്റാവുന്നതാണ്. സ്ഥിര ഔട്ട്പുട്ട് നാഗിയോസ് ആണ്,
നിങ്ങൾക്ക് വേണമെങ്കിൽ സ്ക്രിപ്റ്റിന്റെ മുകളിൽ ഇത് മാറ്റാവുന്നതാണ്. നിലവിലെ ഓപ്ഷൻ
തിരഞ്ഞെടുപ്പുകളാണ് നാഗിയോസ്, mrtg, ഒപ്പം ലഘുവായ. ഓരോന്നിനും ഔട്ട്പുട്ട് ആർഗ്യുമെന്റ് നൽകാതിരിക്കാൻ
സമയം, --ഔട്ട്‌പുട്ട് ആർഗ്യുമെന്റ് നൽകിയിട്ടില്ലെങ്കിൽ ഔട്ട്‌പുട്ടിന്റെ തരം സ്വയമേവ സജ്ജീകരിക്കും
നിലവിലെ ഡയറക്‌ടറിക്ക് അതിന്റെ പേരിൽ ഔട്ട്‌പുട്ട് ഓപ്ഷനുകളിലൊന്ന് ഉണ്ട്. ഉദാഹരണത്തിന്, ഒരു സൃഷ്ടിക്കുന്നു
mrtg എന്ന് പേരിട്ടിരിക്കുന്ന ഡയറക്ടറി, ഇത് സിംലിങ്കുകൾ ഉപയോഗിച്ച് പോപ്പുലേറ്റ് ചെയ്യുന്നു --സിംലിങ്കുകൾ വാദം ആയിരിക്കും
ആ ഡയറക്‌ടറിയിൽ നിന്ന് പ്രവർത്തിക്കുന്ന ഏതൊരു പ്രവർത്തനവും എല്ലായ്‌പ്പോഴും "mrtg" ന്റെ ഔട്ട്‌പുട്ടിലേക്ക് ഡിഫോൾട്ട് ആയിരിക്കുമെന്ന് ഉറപ്പാക്കുക.
--output=simple എന്നതിനുള്ള കുറുക്കുവഴിയായി, നിങ്ങൾക്ക് --simple എന്ന് നൽകാം, അത് അസാധുവാക്കുന്നു.
ഡയറക്ടറി നാമകരണ തന്ത്രം.

നാഗോസ് ഔട്ട്പുട്ട്

ഡിഫോൾട്ട് ഔട്ട്‌പുട്ട് ഫോർമാറ്റ് നാഗിയോസിനുള്ളതാണ്, ഇത് വിവരങ്ങളുടെ ഒരു വരിയാണ്
നാല് നിർദ്ദിഷ്ട എക്സിറ്റ് കോഡുകൾ:

0 (ശരി)
1 (മുന്നറിയിപ്പ്)
2 (ക്രിട്ടിക്കൽ)
3 (അജ്ഞാതം)

ഔട്ട്‌പുട്ട് ലൈൻ മുകളിലെ വാക്കുകളിൽ ഒന്നാണ്, ഒരു കോളൺ, തുടർന്ന് എന്തിന്റെ ഒരു ചെറിയ വിവരണം
അളന്നു. അധിക സ്ഥിതിവിവരക്കണക്കുകൾ വിവരങ്ങളും കമാൻഡിന്റെ ആകെ സമയവും
എടുത്തു, ഔട്ട്പുട്ട് ആകാം: ആർഗ്യുമെന്റുകളിലെ ഡോക്യുമെന്റേഷൻ കാണുക --ഷോപ്പർഫ്,
--പെർഫ്ലിമിറ്റ്, ഒപ്പം --പ്രദർശന സമയം.

എംആർടിജി ഔട്ട്പുട്ട്

MRTG ഔട്ട്‌പുട്ട് നാല് വരികളാണ്, ആദ്യ വരി എപ്പോഴും ഒരൊറ്റ സംഖ്യ നൽകുന്നു
പ്രാധാന്യം. സാധ്യമാകുമ്പോൾ, ഈ സംഖ്യ ഒരു സംഖ്യ പോലുള്ള യഥാർത്ഥ മൂല്യത്തെ പ്രതിനിധീകരിക്കുന്നു
ബൈറ്റുകൾ, എന്നാൽ ഇത് "ശരി" അല്ലെങ്കിൽ "തെറ്റ്" മാത്രം നൽകുന്ന പ്രവർത്തനങ്ങൾക്ക് 1 അല്ലെങ്കിൽ 0 ആയിരിക്കാം.
check_postgres_version ആയി. രണ്ടാമത്തെ വരി ഒരു അധിക സ്ഥിതിവിവരക്കണക്ക് ആണ്, ഇതിനായി മാത്രം ഉപയോഗിക്കുന്നു
ചില പ്രവർത്തനങ്ങൾ. മൂന്നാമത്തെ വരി "അപ്‌ടൈം" സൂചിപ്പിക്കുന്നു, അത് ഉപയോഗിക്കില്ല. നാലാമത്തെ വരി എ
വിവരണം കൂടാതെ സാധാരണയായി ഡാറ്റാബേസിന്റെ പേര് ആദ്യ വരിയിൽ നിന്ന് സ്റ്റാറ്റ് സൂചിപ്പിക്കുന്നു
നിന്ന് വലിച്ചെടുത്തു, എന്നാൽ പ്രവർത്തനത്തെ ആശ്രയിച്ച് വ്യത്യസ്തമായിരിക്കാം.

ചില പ്രവർത്തനങ്ങൾ ഓപ്ഷണൽ അംഗീകരിക്കുന്നു --mrtg ഔട്ട്പുട്ട് കൂടുതൽ നിയന്ത്രിക്കാനുള്ള വാദം.

ഓരോന്നിന്റെയും കൃത്യമായ MRTG ഔട്ട്‌പുട്ടിനെക്കുറിച്ചുള്ള വിശദാംശങ്ങൾക്ക് ഓരോ പ്രവർത്തനത്തിന്റെയും ഡോക്യുമെന്റേഷൻ കാണുക.

ലഘുവായ ഔട്ട്പുട്ട്

ലളിതമായ ഔട്ട്‌പുട്ട് MRTG ഒന്നിന്റെ വെട്ടിച്ചുരുക്കിയ പതിപ്പാണ്, മാത്രമല്ല അത് തിരികെ നൽകുന്നു
ആദ്യ നമ്പർ, മറ്റൊന്നുമല്ല. നിങ്ങൾക്ക് സംസ്ഥാനം പരിശോധിക്കാൻ താൽപ്പര്യപ്പെടുമ്പോൾ ഇത് വളരെ ഉപയോഗപ്രദമാണ്
എന്തെങ്കിലും, ഏതെങ്കിലും പരിധി പരിഗണിക്കാതെ. നിങ്ങൾക്ക് സംഖ്യാ ഔട്ട്പുട്ട് രൂപാന്തരപ്പെടുത്താം
ഔട്ട്‌പുട്ട് ആർഗ്യുമെന്റിലേക്ക് KB, MB, GB, TB അല്ലെങ്കിൽ EB കൂട്ടിച്ചേർക്കുന്നു, ഉദാഹരണത്തിന്:

--output=simple,MB

കട്ടി ഔട്ട്പുട്ട്

Cacti ഔട്ട്പുട്ടിൽ ഒരേ വരിയിൽ ഒന്നോ അതിലധികമോ ഇനങ്ങൾ അടങ്ങിയിരിക്കുന്നു, ഒരു ലളിതമായ പേര്, a
കോളൻ, പിന്നെ ഒരു നമ്പർ. ഇപ്പോൾ, വ്യക്തമായ കള്ളിച്ചെടി ഔട്ട്പുട്ടുള്ള ഒരേയൊരു പ്രവർത്തനം
'dbstats', കൂടാതെ --ഔട്ട്‌പുട്ട് ഓപ്‌ഷൻ ഉപയോഗിക്കുന്നത് ഈ സാഹചര്യത്തിൽ ആവശ്യമില്ല, കാരണം കാക്റ്റി മാത്രമാണ്
ഈ പ്രവർത്തനത്തിനുള്ള ഔട്ട്പുട്ട്. മറ്റ് പല പ്രവർത്തനങ്ങൾക്കും, കള്ളിച്ചെടി ഉണ്ടാക്കാൻ --ലളിതമായത് മതിയാകും
സന്തോഷം.

ഡാറ്റബേസ് കണക്ഷൻ ഓപ്ഷനുകൾ

എല്ലാ പ്രവർത്തനങ്ങളും ഒരു പൊതു ഡാറ്റാബേസ് ഓപ്ഷനുകൾ സ്വീകരിക്കുന്നു.

-H NAME or --ഹോസ്റ്റ്=NAME
NAME സൂചിപ്പിച്ച ഹോസ്റ്റിലേക്ക് കണക്റ്റുചെയ്യുക. കോമയാൽ വേർതിരിച്ച പേരുകളുടെ പട്ടിക ആകാം.
ഒന്നിലധികം ഹോസ്റ്റ് ആർഗ്യുമെന്റുകൾ അനുവദനീയമാണ്. ഹോസ്റ്റ് നൽകിയിട്ടില്ലെങ്കിൽ, "PGHOST" ലേക്ക് ഡിഫോൾട്ട് ചെയ്യുന്നു
പരിസ്ഥിതി വേരിയബിൾ അല്ലെങ്കിൽ ഹോസ്റ്റ് ഇല്ല (ഇത് ഒരു പ്രാദേശിക Unix സോക്കറ്റ് ഉപയോഗിക്കുന്നതായി സൂചിപ്പിക്കുന്നു).
നിങ്ങൾക്ക് "--dbhost"ഉം ഉപയോഗിക്കാം.

-p പോർട്ട് or --പോർട്ട്=പോർട്ട്
നിർദ്ദിഷ്ട പോർട്ട് നമ്പർ ഉപയോഗിച്ച് കണക്‌റ്റ് ചെയ്യുന്നു. പോർട്ടിന്റെ കോമയാൽ വേർതിരിച്ച ലിസ്റ്റ് ആകാം
അക്കങ്ങളും ഒന്നിലധികം പോർട്ട് ആർഗ്യുമെന്റുകളും അനുവദനീയമാണ്. പോർട്ട് നമ്പർ നൽകിയിട്ടില്ലെങ്കിൽ, ഡിഫോൾട്ടുകൾ
"PGPORT" എൻവയോൺമെന്റ് വേരിയബിളിലേക്ക്. അത് സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ, അത് 5432-ലേക്ക് ഡിഫോൾട്ടാകും. നിങ്ങൾക്ക് ചെയ്യാം
"--dbport" എന്നതും ഉപയോഗിക്കുക

-db NAME or --dbname=NAME
ഏത് ഡാറ്റാബേസിലേക്കാണ് ബന്ധിപ്പിക്കേണ്ടതെന്ന് വ്യക്തമാക്കുന്നു. കോമയാൽ വേർതിരിച്ച പേരുകളുടെ ലിസ്റ്റ് ആകാം, കൂടാതെ
ഒന്നിലധികം dbname ആർഗ്യുമെന്റുകൾ അനുവദനീയമാണ്. dbname ഓപ്ഷൻ നൽകിയിട്ടില്ലെങ്കിൽ, ഡിഫോൾട്ടായി
"PGDATABASE" എൻവയോൺമെന്റ് വേരിയബിൾ. അത് സജ്ജീകരിച്ചിട്ടില്ലെങ്കിൽ, അത് 'പോസ്റ്റ്ഗ്രെസ്' ആയി സ്ഥിരസ്ഥിതിയാകും
psql പതിപ്പ് 8 അല്ലെങ്കിൽ അതിൽ കൂടുതലാണെങ്കിൽ, കൂടാതെ 'template1'.

-u USERNAME or --dbuser=USERNAME
ആയി ബന്ധിപ്പിക്കേണ്ട ഡാറ്റാബേസ് ഉപയോക്താവിന്റെ പേര്. കോമയാൽ വേർതിരിച്ച ലിസ്റ്റ് ആകാം
ഉപയോക്തൃനാമങ്ങളും ഒന്നിലധികം dbuser ആർഗ്യുമെന്റുകളും അനുവദനീയമാണ്. ഇത് നൽകിയിട്ടില്ലെങ്കിൽ, അത്
"PGUSER" എൻവയോൺമെന്റ് വേരിയബിളിലേക്ക് ഡിഫോൾട്ട് ചെയ്യുന്നു, അല്ലാത്തപക്ഷം അത് 'postgres' ആയി സ്ഥിരസ്ഥിതിയായി മാറുന്നു.

--dbpass=പാസ്‌വേഡ്
ഡാറ്റാബേസുമായി ബന്ധിപ്പിക്കുന്നതിനുള്ള പാസ്‌വേഡ് നൽകുന്നു. ഈ ഓപ്ഷന്റെ ഉപയോഗം വളരെ ഉയർന്നതാണ്
നിരുത്സാഹപ്പെടുത്തി. പകരം, ഒരാൾ .pgpass അല്ലെങ്കിൽ pg_service.conf ഫയൽ ഉപയോഗിക്കണം.

--dbservice=NAME
pg_service.conf ഫയലിനുള്ളിലെ ഒരു സേവനത്തിന്റെ പേര്. 9.0 പതിപ്പിന് മുമ്പ്
Postgres, ഇതൊരു ആഗോള ഫയലാണ്, സാധാരണയായി /etc/pg_service.conf-ൽ കാണപ്പെടുന്നു. നിങ്ങളാണെങ്കിൽ
Postgres-ന്റെ 9.0 അല്ലെങ്കിൽ ഉയർന്ന പതിപ്പ് ഉപയോഗിച്ച്, നിങ്ങൾക്ക് ".pg_service.conf" ഫയൽ ഉപയോഗിക്കാം
സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുന്ന ഉപയോക്താവിന്റെ ഹോം ഡയറക്ടറി, ഉദാ നാഗിയോസ്.

ഈ ഫയലിൽ കണക്ഷൻ ഓപ്ഷനുകളുടെ ഒരു ലളിതമായ ലിസ്റ്റ് അടങ്ങിയിരിക്കുന്നു. നിങ്ങൾക്ക് അധികമായി കടന്നുപോകാനും കഴിയും
ഈ ഓപ്ഷൻ ഉപയോഗിക്കുമ്പോൾ --dbservice="maindabase sslmode=require" പോലുള്ള വിവരങ്ങൾ

ഈ ഫയലിന്റെ ഡോക്യുമെന്റേഷൻ ഇവിടെ കാണാം
http://www.postgresql.org/docs/current/static/libpq-pgservice.html

ഡാറ്റാബേസ് കണക്ഷൻ ഓപ്ഷനുകൾ ഗ്രൂപ്പുചെയ്യാനാകും: --ഹോസ്റ്റ്=എ,ബി --ഹോസ്റ്റ്=സി --പോർട്ട്=1234
--പോർട്ട്=3344 a-1234, b-1234, c-3344 എന്നിവയുമായി ബന്ധിപ്പിക്കും. ഒരിക്കൽ സജ്ജീകരിച്ചാൽ, ഒരു ഓപ്ഷൻ ശ്രദ്ധിക്കുക
അത് വീണ്ടും മാറ്റുന്നതുവരെ കൊണ്ടുപോകുന്നു.

ഉദാഹരണങ്ങൾ:

--host=a,b --port=5433 --db=c
a-5433-c b-5433-c എന്നീ ഹോസ്റ്റുകളിലേക്ക് ഡാറ്റാബേസ് c ഉപയോഗിച്ച് പോർട്ട് 5433-ലേക്ക് രണ്ടുതവണ ബന്ധിപ്പിക്കുന്നു

--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
pg_service.conf ഫയലിൽ 'foo' എന്ന് പേരിട്ടിരിക്കുന്ന സേവനം ഉപയോഗിച്ച് കണക്റ്റുചെയ്യുന്നു, എന്നാൽ പോർട്ടിനെ അസാധുവാക്കുന്നു

മറ്റുള്ളവ ഓപ്ഷനുകൾ

മറ്റ് ഓപ്ഷനുകളിൽ ഇവ ഉൾപ്പെടുന്നു:

--action=NAME
ഞങ്ങൾ എന്ത് പ്രവർത്തനമാണ് നടത്തുന്നതെന്ന് പ്രസ്താവിക്കുന്നു. സിംലിങ്ക് ചെയ്‌ത ഫയൽ ഉപയോഗിക്കുന്നില്ലെങ്കിൽ അത് ആവശ്യമാണ്
ആക്ഷൻ കണ്ടുപിടിക്കാൻ ഫയലിന്റെ പേര് ഉപയോഗിക്കുന്നു.

--മുന്നറിയിപ്പ്=VAL or -w VAL
ഒരു മുന്നറിയിപ്പ് അലേർട്ട് പുറപ്പെടുവിക്കുന്ന പരിധി സജ്ജീകരിക്കുന്നു. ഇതിനുള്ള സാധുവായ ഓപ്ഷനുകൾ
ഓപ്ഷൻ ഉപയോഗിച്ച പ്രവർത്തനത്തെ ആശ്രയിച്ചിരിക്കുന്നു.

--critical=VAL or -c VAL
ഒരു നിർണ്ണായക മുന്നറിയിപ്പ് നൽകുന്നതിനുള്ള പരിധി സജ്ജീകരിക്കുന്നു. ഇതിനുള്ള സാധുവായ ഓപ്ഷനുകൾ
ഓപ്ഷൻ ഉപയോഗിച്ച പ്രവർത്തനത്തെ ആശ്രയിച്ചിരിക്കുന്നു.

-t VAL or --ടൈംഔട്ട്=VAL
നിമിഷങ്ങൾക്കുള്ളിൽ സമയപരിധി സജ്ജീകരിക്കുന്നു, അതിനുശേഷം സ്ക്രിപ്റ്റ് അത് ചെയ്യുന്നതെന്തും നിർത്തലാക്കും
ഒരു അജ്ഞാത നില തിരികെ നൽകുക. മൊത്തത്തിലുള്ളതല്ല, ഓരോ പോസ്റ്റ്‌ഗ്രേസ് ക്ലസ്റ്ററിനും സമയപരിധി
സ്ക്രിപ്റ്റ്. സ്ഥിര മൂല്യം 10 ​​ആണ്; യൂണിറ്റുകൾ എപ്പോഴും സെക്കന്റുകളിലായിരിക്കും.

--assume-standby-mod
വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, സെർവർ സ്റ്റാൻഡ്‌ബൈ മോഡിൽ പ്രവർത്തിക്കുമോ എന്ന് ആദ്യം പരിശോധിക്കുക (--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

--ssume-prod
വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, പ്രൊഡക്ഷൻ മോഡിലുള്ള സെർവർ പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുക (--datadir ആവശ്യമാണ്).
("symlink: check_postgres_checkpoint") എന്നതിന് മാത്രം ഈ ഓപ്ഷൻ പ്രസക്തമാണ്.

ഉദാഹരണം:

postgres@db$./check_postgres --action=checkpoint --datadir /var/lib/postgresql/8.3/main/ --assume-prod
POSTGRES_CHECKPOINT ശരി: അവസാന ചെക്ക് പോയിന്റ് 72 സെക്കൻഡ് മുമ്പായിരുന്നു | പ്രായം=72;;300 മോഡ്=മാസ്റ്റർ

-h or --സഹായിക്കൂ
എല്ലാ പ്രവർത്തനങ്ങളുടെയും ഓപ്‌ഷനുകളുടെയും സംഗ്രഹത്തോടുകൂടിയ ഒരു സഹായ സ്‌ക്രീൻ പ്രദർശിപ്പിക്കുന്നു.

--മനുഷ്യൻ
മുഴുവൻ മാനുവലും പ്രദർശിപ്പിക്കുന്നു.

-V or --പതിപ്പ്
നിലവിലെ പതിപ്പ് കാണിക്കുന്നു.

-v or --വാക്കുകൾ
വെർബോസിറ്റി ലെവൽ സജ്ജമാക്കുക. ലെവൽ വർദ്ധിപ്പിക്കാൻ ഒന്നിലധികം തവണ വിളിക്കാം. ഇത് സജ്ജമാക്കുന്നു
മൂന്നോ അതിലധികമോ (മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, "-v -v -v" നൽകുന്നത്) ഡീബഗ്ഗിംഗ് വിവരങ്ങൾ ഓണാക്കുന്നു
stderr-ലേക്ക് അയച്ച ഈ പ്രോഗ്രാമിനായി.

--showperf=VAL
സ്റ്റാൻഡേർഡ് നാഗിയോസ് ഫോർമാറ്റിൽ ഞങ്ങൾ അധിക പ്രകടന ഡാറ്റ ഔട്ട്പുട്ട് ചെയ്യുമോ എന്ന് നിർണ്ണയിക്കുന്നു (അവസാനം
സ്ട്രിംഗിന്റെ, പൈപ്പ് ചിഹ്നത്തിന് ശേഷം, പേര്=മൂല്യം ഉപയോഗിച്ച്). VAL 0 അല്ലെങ്കിൽ 1 ആയിരിക്കണം. ഡിഫോൾട്ട്
ആണ് 1. Nagios ഔട്ട്പുട്ട് മോഡ് ഉപയോഗിച്ചാൽ മാത്രമേ പ്രാബല്യത്തിൽ വരികയുള്ളൂ.

--perflimit=i
ഉപയോഗിക്കുമ്പോൾ താൽപ്പര്യമുള്ള എത്ര ഇനങ്ങൾ തിരികെ റിപ്പോർട്ട് ചെയ്യുമെന്നതിന്റെ പരിധി സജ്ജീകരിക്കുന്നു
ഷോപെർഫ് ഓപ്ഷൻ. ഇത് ഒരു വലിയ സംഖ്യ തിരികെ നൽകുന്ന പ്രവർത്തനങ്ങൾക്ക് മാത്രമേ ഫലമുള്ളൂ
പോലുള്ള ഇനങ്ങൾ പട്ടിക_വലിപ്പം. സ്ഥിരസ്ഥിതി 0 ആണ്, അല്ലെങ്കിൽ പരിധിയില്ല. ഇത് ഉപയോഗിക്കുമ്പോൾ ശ്രദ്ധിക്കുക
കൂടെ --ഉൾപ്പെടുന്നു or --പെടുത്തിയിട്ടില്ല ഓപ്‌ഷനുകൾ, ആ നിയന്ത്രണങ്ങൾ ചെയ്‌തിരിക്കുന്നതുപോലെ ശേഷം The
അന്വേഷണം നടത്തി, അതിനാൽ നിങ്ങളുടെ പരിധിയിൽ നിങ്ങൾ ആഗ്രഹിക്കുന്ന ഇനങ്ങൾ ഉൾപ്പെട്ടേക്കില്ല. എടുക്കുന്നു മാത്രം
Nagios ഔട്ട്‌പുട്ട് മോഡ് ഉപയോഗിക്കുകയാണെങ്കിൽ പ്രഭാവം.

--ഷോടൈം=VAL
ഓരോ ചോദ്യവും പ്രവർത്തിപ്പിക്കുന്നതിന് എടുക്കുന്ന സമയം ഔട്ട്പുട്ടിൽ കാണിച്ചിട്ടുണ്ടോ എന്ന് നിർണ്ണയിക്കുന്നു. VAL 0 ആയിരിക്കണം
അല്ലെങ്കിൽ 1. ഡിഫോൾട്ട് 1 ആണ്. അല്ലാതെ ഫലമില്ല ഷോപെർഫ് ഓണാണ്. ഉപയോഗിച്ചാൽ മാത്രമേ പ്രാബല്യത്തിൽ വരികയുള്ളൂ
നാഗിയോസ് ഔട്ട്പുട്ട് മോഡ്.

--ടെസ്റ്റ്
ടെസ്റ്റ് മോഡ് പ്രവർത്തനക്ഷമമാക്കുന്നു. ചുവടെയുള്ള "ടെസ്റ്റ് മോഡ്" വിഭാഗം കാണുക.

--PGBINDIR=പാത്ത്
psql ബൈനറികൾ എവിടെ കണ്ടെത്തണമെന്ന് സ്ക്രിപ്റ്റിനോട് പറയുന്നു. നിങ്ങൾക്ക് ഒന്നിൽ കൂടുതൽ ഉണ്ടെങ്കിൽ ഉപയോഗപ്രദമാണ്
നിങ്ങളുടെ സിസ്റ്റത്തിൽ PostgreSQL എക്സിക്യൂട്ടബിളുകളുടെ പതിപ്പ്, അല്ലെങ്കിൽ നിങ്ങളുടെ സിസ്റ്റത്തിൽ ഇല്ലെങ്കിൽ
പാത. ഈ ഓപ്‌ഷൻ എല്ലാ വലിയക്ഷരത്തിലും ഉണ്ടെന്ന് ശ്രദ്ധിക്കുക. സ്ഥിരസ്ഥിതിയായി, ഈ ഓപ്ഷൻ ആണ് അല്ല
അനുവദിച്ചു. ഇത് പ്രവർത്തനക്ഷമമാക്കാൻ, നിങ്ങൾ സ്ക്രിപ്റ്റിന്റെ മുകൾഭാഗത്തുള്ള $NO_PSQL_OPTION മാറ്റണം
0 വരെ. നിങ്ങൾക്ക് കഴിയുമെങ്കിൽ ഈ ഓപ്ഷൻ ഉപയോഗിക്കുന്നത് ഒഴിവാക്കുക, പകരം എൻവയോൺമെന്റ് വേരിയബിൾ ഉപയോഗിക്കുക
സി അല്ലെങ്കിൽ ഹാർഡ്-കോഡുചെയ്‌ത $PGBINDIR വേരിയബിൾ, സ്‌ക്രിപ്റ്റിന്റെ മുകൾഭാഗത്ത്, സജ്ജീകരിക്കാൻ
ഉപയോഗിക്കാനുള്ള PostgreSQL-ലേക്കുള്ള പാത.

--PSQL=പാത്ത്
(നിരസിച്ചു, ഈ ഓപ്ഷൻ കഴിയുക be നീക്കംചെയ്തു in a ഭാവി പ്രകാശനം!) സ്ക്രിപ്റ്റ് എവിടെയാണെന്ന് പറയുന്നു
psql പ്രോഗ്രാം കണ്ടെത്താൻ. നിങ്ങൾക്ക് psql-ന്റെ ഒന്നിലധികം പതിപ്പുകൾ ഉണ്ടെങ്കിൽ ഉപയോഗപ്രദമാണ്
നിങ്ങളുടെ സിസ്റ്റത്തിൽ എക്സിക്യൂട്ടബിൾ, അല്ലെങ്കിൽ നിങ്ങളുടെ പാതയിൽ psql പ്രോഗ്രാം ഇല്ലെങ്കിൽ. ഇത് ശ്രദ്ധിക്കുക
ഓപ്ഷൻ എല്ലാ വലിയക്ഷരത്തിലും ആണ്. സ്ഥിരസ്ഥിതിയായി, ഈ ഓപ്ഷൻ ആണ് അല്ല അനുവദിച്ചു. ഇത് പ്രവർത്തനക്ഷമമാക്കാൻ, നിങ്ങൾ
സ്ക്രിപ്റ്റിന്റെ മുകൾഭാഗത്തുള്ള $NO_PSQL_OPTION 0 ആയി മാറ്റണം. ഇത് ഉപയോഗിക്കുന്നത് ഒഴിവാക്കുക
നിങ്ങൾക്ക് കഴിയുമെങ്കിൽ ഓപ്ഷൻ, പകരം $PSQL വേരിയബിളിലേക്ക് നിങ്ങളുടെ psql ലൊക്കേഷൻ ഹാർഡ്-കോഡ് ചെയ്യുക,
സ്ക്രിപ്റ്റിന്റെ മുകൾഭാഗത്തും.

--സിംലിങ്കുകൾ
ഓരോ പ്രവർത്തനത്തിനും പ്രധാന പ്രോഗ്രാമിലേക്ക് സിംലിങ്കുകൾ സൃഷ്ടിക്കുന്നു.

--output=VAL
വിവിധ പ്രോഗ്രാമുകളിൽ ഉപയോഗിക്കുന്നതിന്, ഔട്ട്പുട്ടിന്റെ ഫോർമാറ്റ് നിർണ്ണയിക്കുന്നു. സ്ഥിരസ്ഥിതിയാണ്
'നാഗിയോസ്'. 'നാഗിയോസ്', 'എംആർടിജി', 'സിമ്പിൾ', 'കാക്റ്റി' എന്നിവയാണ് ലഭ്യമായ ഓപ്ഷനുകൾ.

--mrtg=VAL
ചില നിർദ്ദിഷ്ട പ്രവർത്തനങ്ങൾക്കായി MRTG അല്ലെങ്കിൽ ലളിതമായ ഔട്ട്പുട്ടിനായി മാത്രം ഉപയോഗിക്കുന്നു.

--debugoutput=VAL
ഡീബഗ്ഗിംഗിൽ ഉപയോഗിക്കുന്നതിന്, psql നൽകുന്ന കൃത്യമായ സ്ട്രിംഗ് ഔട്ട്പുട്ട് ചെയ്യുന്നു. മൂല്യം ഒന്ന് അല്ലെങ്കിൽ
ഔട്ട്‌പുട്ട് പ്രദർശിപ്പിച്ചിട്ടുണ്ടോ ഇല്ലയോ എന്ന് നിർണ്ണയിക്കുന്ന കൂടുതൽ അക്ഷരങ്ങൾ, ഇവിടെ 'a' = എല്ലാം, '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, linx, links. ഒന്നിന്റെ ഉപയോഗം നിർബന്ധമാക്കുന്നതിന് (അങ്ങനെ നീക്കം ചെയ്യുക
ആ പ്രവൃത്തികളിൽ ഒന്ന് വരെ മറ്റെല്ലാവരെയും പരീക്ഷിക്കുന്നതിന് മുകളിൽ), പേരുകളിലൊന്ന് ഇതായി നൽകുക
get_method എന്നതിലേക്കുള്ള വാദം. ഉദാഹരണത്തിന്, ഒരു BSD ബോക്സ് ഇനിപ്പറയുന്ന വരിയിൽ നൽകിയേക്കാം
അവരുടെ ".check_postgresrc" ഫയൽ:

get_method=എടുക്കുക

--language=VAL
എല്ലാ ഔട്ട്‌പുട്ട് സന്ദേശങ്ങൾക്കും ഉപയോഗിക്കുന്നതിന് ഭാഷ സജ്ജമാക്കുക. സാധാരണയായി, ഇത് കണ്ടുപിടിക്കുന്നത്
പരിസ്ഥിതി വേരിയബിളുകൾ LC_ALL, LC_MESSAGES, LANG എന്നിവ പരിശോധിക്കുന്നു, പക്ഷേ ഇത് ക്രമീകരിക്കുന്നു
ഓപ്‌ഷൻ അത്തരം കണ്ടെത്തലുകളെ അസാധുവാക്കും.

പ്രവർത്തനങ്ങൾ

സ്ക്രിപ്റ്റ് ഒന്നോ അതിലധികമോ പ്രവർത്തനങ്ങൾ പ്രവർത്തിപ്പിക്കുന്നു. ഇത് ഒന്നുകിൽ --action ഫ്ലാഗ് ഉപയോഗിച്ചോ അല്ലെങ്കിൽ വഴിയോ ചെയ്യാം
പ്രധാന ഫയലിലേക്ക് ഒരു സിംലിങ്ക് ഉപയോഗിക്കുന്നു, അതിൽ ഉള്ള പ്രവർത്തനത്തിന്റെ പേര് അടങ്ങിയിരിക്കുന്നു. വേണ്ടി
ഉദാഹരണത്തിന്, "ടൈംസിങ്ക്" എന്ന പ്രവർത്തനം പ്രവർത്തിപ്പിക്കുന്നതിന്, നിങ്ങൾക്ക് ഒന്നുകിൽ ഇഷ്യൂ ചെയ്യാം:

check_postgres --action=timesync

അല്ലെങ്കിൽ പേരുള്ള ഒരു പ്രോഗ്രാം ഉപയോഗിക്കുക:

check_postgres_timesync

--symlinks എന്ന ഓപ്‌ഷൻ ഉപയോഗിക്കുകയാണെങ്കിൽ, നിലവിലുള്ള ഡയറക്‌ടറിയിൽ നിങ്ങൾക്കായി എല്ലാ സിംലിങ്കുകളും സൃഷ്‌ടിക്കും

perl check_postgres --symlinks

ഫയലിന്റെ പേര് ഇതിനകം നിലവിലുണ്ടെങ്കിൽ, അത് തിരുത്തിയെഴുതപ്പെടില്ല. ഫയൽ നിലവിലുണ്ടെങ്കിൽ എ
സിംലിങ്ക്, "--action=build_symlinks_force" ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് തിരുത്തിയെഴുതാൻ നിർബന്ധിക്കാം.

മിക്ക പ്രവർത്തനങ്ങളും എ --മുന്നറിയിപ്പ് ഒരു --നിർണ്ണായകമായ ഓപ്ഷൻ, ഏത് ഘട്ടത്തിലാണ് നമ്മൾ മാറുന്നതെന്ന് സൂചിപ്പിക്കുന്നു
ശരി മുതൽ മുന്നറിയിപ്പ് വരെ, ഏത് പോയിന്റിലേക്ക് ഞങ്ങൾ ക്രിട്ടിക്കലിലേക്ക് പോകുന്നു. വിമർശനങ്ങൾ ആയതിനാൽ ശ്രദ്ധിക്കുക
എല്ലായ്‌പ്പോഴും ആദ്യം പരിശോധിക്കുക, നിർണ്ണായകത്തിന് തുല്യമായ മുന്നറിയിപ്പ് സജ്ജീകരിക്കുന്നതിനുള്ള ഫലപ്രദമായ മാർഗമാണ്
മുന്നറിയിപ്പുകൾ ഓഫാക്കി എപ്പോഴും വിമർശനം നൽകുക.

നിലവിലെ പിന്തുണയ്ക്കുന്ന പ്രവർത്തനങ്ങൾ ഇവയാണ്:

ആർക്കൈവ്_തയ്യാറാണ്
("symlink: check_postgres_archive_ready") വിപുലീകരണത്തോടുകൂടിയ എത്ര WAL ഫയലുകൾ പരിശോധിക്കുന്നു .തയ്യാറാണ്
എന്നതിൽ നിലവിലുണ്ട് pg_xlog/archive_status നിങ്ങളുടെ ഡയറക്‌ടറിയിൽ നിന്ന് കണ്ടെത്തി ഡാറ്റ_ഡയറക്‌ടറി.
എന്നതിന്റെ ഉള്ളടക്കങ്ങൾ ആക്‌സസ് ചെയ്യുന്നതിന് ഈ പ്രവർത്തനം ഒരു സൂപ്പർ യൂസറായി പ്രവർത്തിപ്പിക്കേണ്ടതാണ്
pg_xlog/archive_status ഡയറക്ടറി. ഈ പ്രവർത്തനം ഉപയോഗിക്കുന്നതിനുള്ള ഏറ്റവും കുറഞ്ഞ പതിപ്പ് Postgres 8.1 ആണ്.
ദി --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ ഓപ്‌ഷനുകളുടെ എണ്ണം മാത്രമാണ് .തയ്യാറാണ് ലെ ഫയലുകൾ
pg_xlog/archive_status ഡയറക്ടറി. സാധാരണയായി, ഈ മൂല്യങ്ങൾ കുറവായിരിക്കണം, അത് ഓണാക്കുന്നു
ആർക്കൈവ് മെക്കാനിസം, WAL ഫയലുകൾ കഴിയുന്നത്ര വേഗത്തിൽ ആർക്കൈവ് ചെയ്യാൻ ഞങ്ങൾ സാധാരണയായി ആഗ്രഹിക്കുന്നു.

ആർക്കൈവ് കമാൻഡ് പരാജയപ്പെടുകയാണെങ്കിൽ, നിങ്ങളിലെ WAL-ന്റെ എണ്ണം pg_xlog വരെ ഡയറക്ടറി വളരും
ഡിസ്കിലെ മുഴുവൻ സ്ഥലവും തീർന്ന് PostgreSQL-നെ ഉടനടി നിർത്താൻ പ്രേരിപ്പിക്കുന്നു.

ഉദാഹരണം 1: ഹോസ്റ്റ് "പ്ലൂട്ടോ" യിൽ തയ്യാറായ WAL ഫയലുകളുടെ എണ്ണം 10 അല്ലെങ്കിൽ അതിൽ കുറവാണോ എന്ന് പരിശോധിക്കുക

check_postgres_archive_ready --host=pluto --critical=10

MRTG ഔട്ട്‌പുട്ടിനായി, ലൈൻ 1-ൽ തയ്യാറായ WAL ഫയലുകളുടെ എണ്ണം റിപ്പോർട്ട് ചെയ്യുന്നു.

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 ഔട്ട്‌പുട്ടിനായി, മൊത്തത്തിലുള്ള ഏറ്റവും ഉയർന്ന ശതമാനം ആദ്യ വരിയിൽ റിപ്പോർട്ട് ചെയ്യപ്പെടുന്നു, കൂടാതെ
ഏറ്റവും ഉയർന്ന പ്രായം രണ്ടാമത്തെ വരിയിൽ രേഖപ്പെടുത്തിയിരിക്കുന്നു. ശതമാനം ഉള്ള എല്ലാ ഡാറ്റാബേസുകളും
പൈപ്പ് ചിഹ്നത്താൽ വേർതിരിക്കുന്ന നാലാമത്തെ വരിയിൽ ആദ്യ വരി റിപ്പോർട്ട് ചെയ്യുന്നു.

ബാക്കെൻഡുകൾ
("symlink: check_postgres_backends") നിലവിലുള്ള കണക്ഷനുകളുടെ എണ്ണം ഒന്നോ അല്ലെങ്കിൽ
കൂടുതൽ ഡാറ്റാബേസുകൾ, കൂടാതെ ഓപ്ഷണലായി അതിനെ അനുവദനീയമായ പരമാവധിയുമായി താരതമ്യം ചെയ്യുന്നു, അത് നിർണ്ണയിക്കുന്നത്
Postgres കോൺഫിഗറേഷൻ വേരിയബിൾ max_connections. ദി --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ ഓപ്ഷനുകൾ
മൂന്ന് രൂപങ്ങളിൽ ഒന്ന് എടുക്കാം. ആദ്യം, ഒരു ലളിതമായ സംഖ്യ നൽകാം, അത് പ്രതിനിധീകരിക്കുന്നു
അലേർട്ട് നൽകുന്ന കണക്ഷനുകളുടെ എണ്ണം. ഈ തിരഞ്ഞെടുപ്പ് ഉപയോഗിക്കുന്നില്ല
max_connections ക്രമീകരണം. രണ്ടാമതായി, ലഭ്യമായ കണക്ഷനുകളുടെ ശതമാനം നൽകാം.
മൂന്നാമതായി, അവശേഷിക്കുന്ന കണക്ഷനുകളുടെ എണ്ണത്തെ പ്രതിനിധീകരിക്കുന്ന ഒരു നെഗറ്റീവ് നമ്പർ നൽകാം
വരുവോളം max_connections എത്തിയിരിക്കുന്നു. എന്നതിനായുള്ള ഡിഫോൾട്ട് മൂല്യങ്ങൾ --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ ആകുന്നു
'90%', '95%'. ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഡാറ്റാബേസുകൾ ഫിൽട്ടർ ചെയ്യാനും കഴിയും --ഉൾപ്പെടുന്നു ഒപ്പം --പെടുത്തിയിട്ടില്ല
ഓപ്ഷനുകൾ. കൂടുതൽ വിവരങ്ങൾക്ക് "ബേസിക് ഫിൽട്ടറിംഗ്" വിഭാഗം കാണുക.

നിഷ്ക്രിയമായ പ്രക്രിയകൾ മാത്രം കാണുന്നതിന്, നിങ്ങൾക്ക് ഇത് ഉപയോഗിക്കാം --നൊയ്ഡിൽ വാദം. ഉപയോക്താവ് നിങ്ങളാണെന്ന കാര്യം ശ്രദ്ധിക്കുക
ഇത് ശരിയായി പ്രവർത്തിക്കുന്നതിന് ഒരു സൂപ്പർ യൂസർ ആയിരിക്കണം എന്നതിനാൽ ബന്ധിപ്പിക്കുന്നു.

ഉദാഹരണം 1: ഹോസ്റ്റ് ക്വിർമിലെ കണക്ഷനുകളുടെ എണ്ണം 120 ൽ എത്തുമ്പോൾ ഒരു മുന്നറിയിപ്പ് നൽകുക, കൂടാതെ a
150ൽ എത്തിയാൽ അത് നിർണായകമാണ്.

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

ഉദാഹരണം 2: ഹോസ്റ്റുകളിൽ ഞങ്ങളുടെ max_connections ക്രമീകരണത്തിന്റെ 75% എത്തുമ്പോൾ നിർണായകമായ ഒരു കാര്യം നൽകുക
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 ഔട്ട്പുട്ടിനായി, കണക്ഷനുകളുടെ എണ്ണം ആദ്യ വരിയിലും നാലാമത്തേതിലും റിപ്പോർട്ട് ചെയ്യുന്നു
ലൈൻ ഡാറ്റാബേസിന്റെ പേരും കൂടാതെ നിലവിലുള്ള പരമാവധി_കണക്ഷനുകളും നൽകുന്നു. കൂടുതലാണെങ്കിൽ
ഒരു ഡാറ്റാബേസ് അന്വേഷിച്ചു, ഏറ്റവും കൂടുതൽ കണക്ഷനുകൾ ഉള്ളത് ഔട്ട്പുട്ട് ആണ്.

വീർക്കുക
("symlink: check_postgres_bloat") പട്ടികകളിലെയും സൂചികകളിലെയും ബ്ലോട്ടിന്റെ അളവ് പരിശോധിക്കുന്നു. (വീർപ്പ്
സാധാരണയായി ഒരു പട്ടികയിലോ സൂചികയിലോ എടുത്ത ഉപയോഗിക്കാത്ത സ്ഥലത്തിന്റെ അളവാണ്. ഈ ഇടം
സാധാരണയായി VACUUM കമാൻഡ് ഉപയോഗിച്ചാണ് വീണ്ടെടുക്കുന്നത്.) ഈ പ്രവർത്തനത്തിന് സ്ഥിതിവിവരക്കണക്കുകൾ ആവശ്യമാണ്
ടാർഗെറ്റ് ഡാറ്റാബേസുകളിൽ ശേഖരണം പ്രവർത്തനക്ഷമമാക്കും, കൂടാതെ വിശകലനം പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട്
കൂടെക്കൂടെ. ദി --ഉൾപ്പെടുന്നു ഒപ്പം --പെടുത്തിയിട്ടില്ല ഏതൊക്കെ ടേബിളുകൾ ഫിൽട്ടർ ചെയ്യാൻ ഓപ്ഷനുകൾ ഉപയോഗിക്കാം
നോക്കൂ. കൂടുതൽ വിവരങ്ങൾക്ക് "ബേസിക് ഫിൽട്ടറിംഗ്" വിഭാഗം കാണുക.

ദി --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ ഓപ്‌ഷനുകൾ വലുപ്പങ്ങൾ, ശതമാനം അല്ലെങ്കിൽ രണ്ടും ആയി വ്യക്തമാക്കാം. സാധുവാണ്
വലുപ്പ യൂണിറ്റുകൾ ബൈറ്റുകൾ, കിലോബൈറ്റുകൾ, മെഗാബൈറ്റുകൾ, ജിഗാബൈറ്റുകൾ, ടെറാബൈറ്റുകൾ, എക്സാബൈറ്റുകൾ, പെറ്റാബൈറ്റുകൾ, കൂടാതെ
സെറ്റാബൈറ്റുകൾ. ആദ്യാക്ഷരം ഉള്ളവയെല്ലാം നിങ്ങൾക്ക് ചുരുക്കാം. യൂണിറ്റുകളില്ലാത്ത ഇനങ്ങളാണ്
'ബൈറ്റുകൾ' ആണെന്ന് അനുമാനിക്കുന്നു. സ്ഥിരസ്ഥിതി മൂല്യങ്ങൾ '1 GB', '5 GB' എന്നിവയാണ്. മൂല്യം പ്രതിനിധീകരിക്കുന്നു
"പാഴായ ബൈറ്റുകളുടെ" എണ്ണം, അല്ലെങ്കിൽ പട്ടിക യഥാർത്ഥത്തിൽ ഉപയോഗിക്കുന്നതും തമ്മിലുള്ള വ്യത്യാസവും
സൂചിക, അത് എന്തായിരിക്കണം എന്ന് ഞങ്ങൾ കണക്കാക്കുന്നു.

ചെറിയവയിൽ തെറ്റായ അലാറങ്ങൾ ഒഴിവാക്കാൻ ഈ പ്രവർത്തനത്തിന് രണ്ട് ഹാർഡ്-കോഡഡ് മൂല്യങ്ങളുണ്ടെന്ന കാര്യം ശ്രദ്ധിക്കുക
ബന്ധങ്ങൾ. പട്ടികകൾക്ക് കുറഞ്ഞത് 10 പേജുകളും സൂചികകൾക്ക് കുറഞ്ഞത് 15 പേജുകളും ഉണ്ടായിരിക്കണം.
ഈ ടെസ്റ്റ് പരിഗണിക്കുന്നു. നിങ്ങൾക്ക് ശരിക്കും ഈ മൂല്യങ്ങൾ ക്രമീകരിക്കണമെങ്കിൽ, നിങ്ങൾക്ക് തിരയാൻ കഴിയും
വേരിയബിളുകൾ $MINPAGES ഒപ്പം $MINIPAGES "check_bloat" സബ്റൂട്ടീന്റെ മുകളിൽ. ഇവ
ഒന്നുകിൽ മൂല്യങ്ങൾ അവഗണിക്കപ്പെടും --പെടുത്തിയിട്ടില്ല or --ഉൾപ്പെടുന്നു ഉപയോഗിക്കുന്നു.

ഏറ്റവും ഉയർന്ന 10 ബന്ധങ്ങൾ മാത്രമാണ് കാണിക്കുന്നത്. ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഈ നമ്പർ മാറ്റാം
--പെർഫ്ലിമിറ്റ് നിങ്ങളുടെ സ്വന്തം പരിധി സജ്ജീകരിക്കാനുള്ള ഓപ്ഷൻ.

'information_schema' എന്ന് പേരിട്ടിരിക്കുന്ന സ്കീമയെ ഈ ടെസ്റ്റിൽ നിന്ന് ഒഴിവാക്കിയിരിക്കുന്നു, കാരണം ഇത് പട്ടികകൾ മാത്രമാണ്.
അടങ്ങിയിരിക്കുന്നവ ചെറുതും മാറാത്തതുമാണ്.

ഈ പ്രവർത്തനത്തിലൂടെ കണക്കാക്കിയ മൂല്യങ്ങൾ കൃത്യമല്ല, അവ ഇതായി ഉപയോഗിക്കണം
ഒരു മാർഗ്ഗരേഖ മാത്രം. ഒരു മേശയുടെ ശരിയായ വലുപ്പം കണക്കാക്കാൻ വലിയ ശ്രമം നടത്തി, പക്ഷേ അതിൽ
അവസാനം അത് ഒരു ഏകദേശം മാത്രമാണ്. ശരിയായ സൂചിക വലുപ്പം എന്നതിനേക്കാൾ ഊഹക്കച്ചവടമാണ്
ശരിയായ മേശ വലിപ്പം, എന്നാൽ രണ്ടും കാര്യങ്ങൾ എത്രമാത്രം വീർക്കുന്നതാണെന്ന് ഒരു ഏകദേശ ധാരണ നൽകണം.

ഉദാഹരണം 1: പോർട്ട് 5432-ലെ ഏതെങ്കിലും ടേബിൾ 100 MB-യിൽ കൂടുതലാണെങ്കിൽ മുന്നറിയിപ്പ് നൽകുക, 200-ൽ കൂടുതൽ ആണെങ്കിൽ അത് ഗുരുതരമാണ്
MB

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

ഉദാഹരണം 2: ഹോസ്റ്റ് 'സാമി'യിലെ ടേബിൾ 'ഓർഡറുകൾ' 10 മെഗ്‌സ് ബ്ലോട്ടിൽ കൂടുതലാണെങ്കിൽ ഒരു നിർണായക രൂപം നൽകുക

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

ഉദാഹരണം 3: ഡാറ്റാബേസ് 'വിൽപന'യിലെ 'q4' ടേബിൾ 50% വീതമുള്ളതാണെങ്കിൽ ഒരു നിർണായക രൂപം നൽകുക

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

ഉദാഹരണം 4: നിർണ്ണായകമായ ഒരു പട്ടിക നൽകുക ഒപ്പം 150 MB-ൽ കൂടുതൽ ബ്ലോട്ട് ഉണ്ട്:

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

ഉദാഹരണം 5: നിർണ്ണായകമായ ഒരു പട്ടിക നൽകുക or 500 MB-ൽ കൂടുതൽ ബ്ലോട്ട് ഉണ്ട്:

check_postgres_bloat --port=5432 --warning='500 M അല്ലെങ്കിൽ 40%'

MRTG ഔട്ട്‌പുട്ടിനായി, പട്ടികകൾക്കായി ഏറ്റവും കൂടുതൽ പാഴായ ബൈറ്റുകൾ ആദ്യ വരി നൽകുന്നു,
രണ്ടാമത്തെ വരി സൂചികകൾക്കായി ഏറ്റവും കൂടുതൽ പാഴായ ബൈറ്റുകൾ നൽകുന്നു. നാലാമത്തെ
ലൈൻ ഡാറ്റാബേസിന്റെ പേര്, പട്ടികയുടെ പേര്, സൂചിക നാമ വിവരങ്ങൾ എന്നിവ നൽകുന്നു. നിങ്ങൾക്ക് വേണമെങ്കിൽ
പകരം ബ്ലോട്ട് റേഷ്യോ ഔട്ട്പുട്ട് ചെയ്യുക (എങ്ങനെയെന്നതുമായി താരതമ്യം ചെയ്യുമ്പോൾ എത്ര മടങ്ങ് വലുതാണ് ബന്ധം
അത് വലുതായിരിക്കണം), "--mrtg= അനുപാതത്തിൽ" കടന്നുപോകുക.

ചെക്ക്പോയിന്റ്
("symlink: check_postgres_checkpoint") അവസാനത്തെ ചെക്ക്‌പോയിന്റിന് എത്ര സമയമുണ്ടെന്ന് നിർണ്ണയിക്കുന്നു
ഓടിച്ചു. പരിശോധിച്ചുകൊണ്ടിരിക്കുന്ന ഡാറ്റാബേസിന്റെ അതേ സെർവറിൽ ഇത് പ്രവർത്തിക്കണം (ഉദാ
-h ഫ്ലാഗ് പ്രവർത്തിക്കില്ല). ഈ പരിശോധന ഒരു "ഊഷ്മള സ്റ്റാൻഡ്ബൈ" സെർവറിൽ പ്രവർത്തിക്കാൻ ഉദ്ദേശിച്ചുള്ളതാണ്
ഷിപ്പ് ചെയ്‌ത WAL ഫയലുകൾ സജീവമായി പ്രോസസ്സ് ചെയ്യുന്നു, നിങ്ങളുടെ ഊഷ്മള സ്റ്റാൻഡ്‌ബൈ ആണോ എന്ന് പരിശോധിക്കുന്നതിനാണ് ഇത്
ശരിക്കും 'ചൂട്'. എൻവയോൺമെന്റ് വേരിയബിൾ വഴി ഡാറ്റ ഡയറക്ടറി സജ്ജീകരിക്കണം
"PGDATA", അല്ലെങ്കിൽ "--datadir" ആർഗ്യുമെന്റ് പാസാക്കുന്നു. ഇത് മുതൽ സെക്കൻഡുകളുടെ എണ്ണം നൽകുന്നു
"pg_controldata" എന്നതിലേക്ക് കോൾ പാഴ്‌സ് ചെയ്‌ത് നിർണ്ണയിച്ച പ്രകാരം അവസാന ചെക്ക്‌പോയിന്റ് പ്രവർത്തിപ്പിച്ചു. കാരണം
ഇത്, pg_controldata എക്സിക്യൂട്ടബിൾ നിലവിലെ പാതയിൽ ലഭ്യമായിരിക്കണം. പകരമായി,
"PGBINDIR" അത് ജീവിക്കുന്ന ഡയറക്ടറിയായി നിങ്ങൾക്ക് വ്യക്തമാക്കാൻ കഴിയും. ഇത് ഉപയോഗിക്കാനും സാധ്യമാണ്
പ്രത്യേക ഓപ്ഷനുകൾ --ssume-prod or --assume-standby-mod, കണ്ടെത്തിയ മോഡ് ഇല്ലെങ്കിൽ
പ്രതീക്ഷിക്കുന്ന ഒന്ന്, ഒരു ക്രിട്ടിക്കൽ പുറപ്പെടുവിക്കുന്നു.

കുറഞ്ഞത് ഒരു മുന്നറിയിപ്പോ വിമർശനാത്മക വാദമോ സജ്ജീകരിച്ചിരിക്കണം.

ഈ പ്രവർത്തനത്തിന് തീയതി::പാഴ്സ് മൊഡ്യൂൾ ആവശ്യമാണ്.

MRTG അല്ലെങ്കിൽ ലളിതമായ ഔട്ട്പുട്ടിനായി, സെക്കൻഡുകളുടെ എണ്ണം നൽകുന്നു.

cluster_id
("symlink: check_postgres_cluster-id") ഡാറ്റാബേസ് സിസ്റ്റം ഐഡന്റിഫയർ നൽകിയിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുന്നു
by 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") എല്ലാ ഡാറ്റാബേസുകളുടെയും പ്രതിബദ്ധത അനുപാതം പരിശോധിക്കുന്നു
അവ വളരെ കുറവായിരിക്കുമ്പോൾ പരാതിപ്പെടുന്നു. ഈ കമാൻഡ് ഒന്നിൽ കൂടുതൽ തവണ പ്രവർത്തിപ്പിക്കേണ്ട ആവശ്യമില്ല
ഡാറ്റാബേസ് ക്ലസ്റ്റർ. ഉപയോഗിച്ച് ഡാറ്റാബേസുകൾ ഫിൽട്ടർ ചെയ്യാൻ കഴിയും --ഉൾപ്പെടുന്നു ഒപ്പം --പെടുത്തിയിട്ടില്ല ഓപ്ഷനുകൾ. കാണുക
കൂടുതൽ വിവരങ്ങൾക്ക് "ബേസിക് ഫിൽട്ടറിംഗ്" വിഭാഗം. ഉടമയ്ക്ക് അവ ഫിൽട്ടർ ചെയ്യാനും കഴിയും
ഉള്ള ഡാറ്റാബേസ് --ഉപയോക്താവിനെ ഉൾപ്പെടുത്തുക ഒപ്പം --ഉപയോക്താവിനെ ഒഴിവാക്കുക ഓപ്ഷനുകൾ. "USER NAME" കാണുക
കൂടുതൽ വിവരങ്ങൾക്ക് ഫിൽട്ടറിംഗ്" വിഭാഗം.

മുന്നറിയിപ്പും നിർണായക ഓപ്ഷനുകളും ശതമാനമായി വ്യക്തമാക്കണം. ഇല്ല
ഈ പ്രവർത്തനത്തിനുള്ള ഡിഫോൾട്ടുകൾ: മുന്നറിയിപ്പും നിർണായകവും വ്യക്തമാക്കിയിരിക്കണം. മുന്നറിയിപ്പ് മൂല്യം
നിർണായക മൂല്യത്തേക്കാൾ വലുതായിരിക്കരുത്. ഔട്ട്പുട്ട് അടുക്കിയ എല്ലാ ഡാറ്റാബേസുകളും നൽകുന്നു
പ്രതിബദ്ധത, ഏറ്റവും ചെറുത് ആദ്യം.

ഉദാഹരണം: ഹോസ്റ്റ് ഫ്ലാഗിലെ ഏതെങ്കിലും ഡാറ്റാബേസ് പ്രതിബദ്ധതയിലും നിർണ്ണായകത്തിലും 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") നിങ്ങൾ തിരഞ്ഞെടുക്കുന്ന ഒരു ഇഷ്‌ടാനുസൃത ചോദ്യം പ്രവർത്തിപ്പിക്കുകയും പാഴ്‌സുചെയ്യുകയും ചെയ്യുന്നു
ഫലങ്ങൾ. ചോദ്യം തന്നെ "ചോദ്യം" ആർഗ്യുമെന്റിലൂടെ കടന്നുപോകുന്നു, അതായിരിക്കണം
കഴിയുന്നത്ര ലളിതമായി സൂക്ഷിച്ചു. സാധ്യമെങ്കിൽ, അത് ഒരു കാഴ്ചയിലോ സൂക്ഷിക്കാനുള്ള ഒരു ഫംഗ്ഷനിലോ പൊതിയുക
കാര്യങ്ങൾ കൈകാര്യം ചെയ്യാൻ എളുപ്പമാണ്. ചോദ്യം ഒന്നോ രണ്ടോ കോളങ്ങൾ നൽകണം. അത് ആവശ്യമാണ്
കോളങ്ങളിൽ ഒന്നിന് "ഫലം" എന്ന് പേരിടണം, അത് നിങ്ങളുടേതിനെതിരെ പരിശോധിക്കും
മുന്നറിയിപ്പും നിർണായക മൂല്യങ്ങളും. രണ്ടാമത്തെ കോളം പ്രകടന ഡാറ്റയ്ക്കും ഏത് പേരിനുമുള്ളതാണ്
ഉപയോഗിക്കാം: ഇത് പ്രകടന ഡാറ്റ വിഭാഗത്തിനുള്ളിലെ 'മൂല്യം' ആയിരിക്കും.

കുറഞ്ഞത് ഒരു മുന്നറിയിപ്പോ വിമർശനമോ ആയ വാദമെങ്കിലും വ്യക്തമാക്കിയിരിക്കണം. ഇവ എന്തായി സജ്ജീകരിച്ചിരിക്കുന്നു എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു
നിങ്ങൾ പ്രവർത്തിപ്പിക്കുന്ന അന്വേഷണ തരത്തിൽ. നാല് തരത്തിലുള്ള കസ്റ്റം_ക്വറികളുണ്ട്
റൺ, "valtype" ആർഗ്യുമെന്റ് വ്യക്തമാക്കുന്നു. ഒന്നും വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, ഈ പ്രവർത്തനം ഡിഫോൾട്ടായിരിക്കും
'പൂർണ്ണസംഖ്യ'. നാല് തരങ്ങൾ ഇവയാണ്:

പൂർണ്ണസംഖ്യ: ഒരു ലളിതമായ പൂർണ്ണസംഖ്യ താരതമ്യം ചെയ്യുന്നു. ആദ്യ നിര ഒരു ലളിതമായ പൂർണ്ണസംഖ്യയായിരിക്കണം,
മുന്നറിയിപ്പും നിർണായക മൂല്യങ്ങളും ഒന്നുതന്നെയായിരിക്കണം.

സ്ട്രിംഗ്: മുന്നറിയിപ്പും നിർണ്ണായകവും സ്ട്രിംഗുകളാണ്, മൂല്യമാണെങ്കിൽ മാത്രമേ പ്രവർത്തനക്ഷമമാകൂ
ആദ്യ കോളം അത് കൃത്യമായി പൊരുത്തപ്പെടുന്നു. ഇത് കേസ് സെൻസിറ്റീവ് ആണ്.

കാലം: മുന്നറിയിപ്പും നിർണായകവും സമയങ്ങളാണ്, അതിന് സെക്കന്റുകൾ, മിനിറ്റ്, യൂണിറ്റുകൾ ഉണ്ടായിരിക്കാം.
മണിക്കൂറുകൾ, അല്ലെങ്കിൽ ദിവസങ്ങൾ. ഓരോന്നും ഏകവചനത്തിലോ ആദ്യാക്ഷരത്തിൽ ചുരുക്കിയോ എഴുതാം. എങ്കിൽ
യൂണിറ്റുകളൊന്നും നൽകിയിട്ടില്ല, സെക്കൻഡുകൾ അനുമാനിക്കപ്പെടുന്നു. ആദ്യ നിര ഒരു പൂർണ്ണസംഖ്യ ആയിരിക്കണം
പരിശോധിക്കേണ്ട സെക്കൻഡുകളുടെ എണ്ണത്തെ പ്രതിനിധീകരിക്കുന്നു.

വലുപ്പം: മുന്നറിയിപ്പും നിർണായകവും വലുപ്പങ്ങളാണ്, കൂടാതെ ബൈറ്റുകൾ, കിലോബൈറ്റുകൾ എന്നിവയുടെ യൂണിറ്റുകൾ ഉണ്ടായിരിക്കാം.
മെഗാബൈറ്റുകൾ, ജിഗാബൈറ്റുകൾ, ടെറാബൈറ്റുകൾ അല്ലെങ്കിൽ എക്സാബൈറ്റുകൾ. ഓരോന്നും ആദ്യ അക്ഷരത്തിലേക്ക് ചുരുക്കിയേക്കാം.
യൂണിറ്റുകളൊന്നും നൽകിയിട്ടില്ലെങ്കിൽ, ബൈറ്റുകൾ അനുമാനിക്കപ്പെടുന്നു. ആദ്യ നിര ഒരു പൂർണ്ണസംഖ്യ ആയിരിക്കണം
പരിശോധിക്കാനുള്ള ബൈറ്റുകളുടെ എണ്ണം പ്രതിനിധീകരിക്കുന്നു.

സാധാരണയായി, നൽകിയ മൂല്യങ്ങൾ ആണെങ്കിൽ ഒരു അലേർട്ട് പ്രവർത്തനക്ഷമമാകും കൂടുതൽ അധികം അല്ലെങ്കിൽ തുല്യമാണ്
ഗുരുതരമായ അല്ലെങ്കിൽ മുന്നറിയിപ്പ് മൂല്യം. എന്നിരുന്നാലും, ഒരു ഓപ്ഷൻ --വിപരീതം എങ്കിൽ അലേർട്ട് ട്രിഗർ ചെയ്യും
തിരികെ നൽകിയ മൂല്യം താഴത്തെ അധികം അല്ലെങ്കിൽ ഗുരുതരമായ അല്ലെങ്കിൽ മുന്നറിയിപ്പ് മൂല്യത്തിന് തുല്യമാണ്.

ഉദാഹരണം 1: 100 പേജിൽ കൂടുതലുള്ള ഏതെങ്കിലും ബന്ധത്തിന് "റാഡ്" എന്ന് പേരിട്ടിട്ടുണ്ടെങ്കിൽ താക്കീത് നൽകുക, പേജുകളുടെ എണ്ണം ചേർക്കുക
പ്രകടന ഡാറ്റ വിഭാഗത്തിനുള്ളിൽ.

check_postgres_custom_query --valtype=string -w "rad" --query=
"ഫലമായി പുനർനാമം തിരഞ്ഞെടുക്കുക, pg_class-ൽ നിന്നുള്ള പേജുകൾ AS ആയി പുനർനാമം തിരഞ്ഞെടുക്കുക

ഉദാഹരണം 2: "foobar" ഫംഗ്‌ഷൻ 5MB-യിൽ കൂടുതലുള്ള ഒരു സംഖ്യ നൽകുന്നുവെങ്കിൽ ഒരു നിർണായക രൂപം നൽകുക:

check_postgres_custom_query --critical='5MB'--valtype=size --query="foobar() AS ഫലം"

ഉദാഹരണം 2: "snazzo" ഫംഗ്‌ഷൻ 42-ൽ കുറവാണെങ്കിൽ മുന്നറിയിപ്പ് നൽകുക:

check_postgres_custom_query --critical=42 --query="SELECT snazzo() AS ഫലം" --reverse

നിങ്ങൾ ഒരു ഉപയോഗപ്രദമായ കസ്റ്റം_ക്വറിയുമായി വരികയാണെങ്കിൽ, ഈ പ്രോഗ്രാമിലേക്ക് ഒരു പാച്ച് അയയ്ക്കുന്നത് പരിഗണിക്കുക
മറ്റ് ആളുകൾക്ക് ഉപയോഗിക്കാൻ കഴിയുന്ന ഒരു സാധാരണ പ്രവർത്തനമാക്കി മാറ്റുക.

ഈ പ്രവർത്തനം ഇതുവരെ MRTG അല്ലെങ്കിൽ ലളിതമായ ഔട്ട്പുട്ട് പിന്തുണയ്ക്കുന്നില്ല.

ഡാറ്റാബേസ്_സൈസ്
("symlink: check_postgres_database_size") എല്ലാ ഡാറ്റാബേസുകളുടെയും വലിപ്പം പരിശോധിക്കുകയും പരാതിപ്പെടുകയും ചെയ്യുന്നു
അവ വളരെ വലുതായിരിക്കുമ്പോൾ. ഓരോ ഡാറ്റാബേസിനും ഒന്നിലധികം തവണ ഈ കമാൻഡ് പ്രവർത്തിപ്പിക്കേണ്ടതില്ല
ക്ലസ്റ്റർ. ഉപയോഗിച്ച് ഡാറ്റാബേസുകൾ ഫിൽട്ടർ ചെയ്യാൻ കഴിയും --ഉൾപ്പെടുന്നു ഒപ്പം --പെടുത്തിയിട്ടില്ല ഓപ്ഷനുകൾ. കാണുക
കൂടുതൽ വിവരങ്ങൾക്ക് "ബേസിക് ഫിൽട്ടറിംഗ്" വിഭാഗം. ഉടമയ്ക്ക് അവ ഫിൽട്ടർ ചെയ്യാനും കഴിയും
ഉള്ള ഡാറ്റാബേസ് --ഉപയോക്താവിനെ ഉൾപ്പെടുത്തുക ഒപ്പം --ഉപയോക്താവിനെ ഒഴിവാക്കുക ഓപ്ഷനുകൾ. "ഉപയോക്തൃ നാമം ഫിൽട്ടറിംഗ്" കാണുക
കൂടുതൽ വിശദാംശങ്ങൾക്ക് വിഭാഗം.

മുന്നറിയിപ്പും നിർണായക ഓപ്ഷനുകളും ബൈറ്റുകൾ, കിലോബൈറ്റുകൾ, മെഗാബൈറ്റുകൾ എന്നിങ്ങനെ വ്യക്തമാക്കാം.
ജിഗാബൈറ്റുകൾ, ടെറാബൈറ്റുകൾ അല്ലെങ്കിൽ എക്സാബൈറ്റുകൾ. ഓരോന്നും ആദ്യ അക്ഷരത്തിലും ചുരുക്കിയേക്കാം.
യൂണിറ്റ് നൽകിയിട്ടില്ലെങ്കിൽ, യൂണിറ്റുകൾ ബൈറ്റുകളായി കണക്കാക്കുന്നു. ഇതിന് സ്ഥിരസ്ഥിതികളൊന്നുമില്ല
നടപടി: മുന്നറിയിപ്പും നിർണായകവും വ്യക്തമാക്കണം. മുന്നറിയിപ്പ് മൂല്യം വലുതായിരിക്കരുത്
നിർണായക മൂല്യത്തേക്കാൾ. ഔട്ട്‌പുട്ട് ആദ്യം ഏറ്റവും വലിയ വലുപ്പമനുസരിച്ച് അടുക്കിയ എല്ലാ ഡാറ്റാബേസുകളും നൽകുന്നു,
റോ ബൈറ്റുകളും വലുപ്പത്തിന്റെ "മനോഹരമായ" പതിപ്പും കാണിക്കുന്നു.

ഉദാഹരണം 1: ഹോസ്റ്റ് ഫ്ലാഗിലെ ഏതെങ്കിലും ഡാറ്റാബേസ് 1 TB-ൽ കൂടുതൽ വലുപ്പമുള്ളതാണെങ്കിൽ മുന്നറിയിപ്പ് നൽകുക.
1.1 ടി.ബി.

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: 'ടോം' എന്ന ഉപയോക്താവിന്റെ ഉടമസ്ഥതയിലുള്ള ഹോസ്റ്റ് 'ടാർഡിസ്' ലെ ഏതെങ്കിലും ഡാറ്റാബേസ് അവസാനിച്ചാൽ മുന്നറിയിപ്പ് നൽകുക
5 ബ്രിട്ടൻ

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

MRTG ഔട്ട്‌പുട്ടിനായി, ആദ്യ വരിയിലെ ഏറ്റവും വലിയ ഡാറ്റാബേസിന്റെ ബൈറ്റുകളിൽ വലുപ്പം നൽകുന്നു, ഒപ്പം
നാലാമത്തെ വരിയിലെ ഡാറ്റാബേസിന്റെ പേര്.

dbstats
("symlink: check_postgres_dbstats") pg_stat_database കാഴ്ചയിൽ നിന്നുള്ള വിവരങ്ങൾ റിപ്പോർട്ടുചെയ്യുന്നു,
കള്ളിച്ചെടിക്ക് അനുയോജ്യമായ രീതിയിൽ അത് ഔട്ട്പുട്ട് ചെയ്യുന്നു. ഔട്ട്പുട്ട് പോലെ മറ്റൊരു ഔട്ട്പുട്ടും പിന്തുണയ്ക്കുന്നില്ല
വിവരദായകവും നാഗിയോസിനൊപ്പം ഉപയോഗിക്കുന്നത് പോലുള്ള അലേർട്ടുകൾക്ക് സ്വയം കടം കൊടുക്കുന്നില്ല. ഓപ്ഷനുകൾ ഇല്ലെങ്കിൽ
നൽകിയിരിക്കുന്നു, എല്ലാ ഡാറ്റാബേസുകളും തിരികെ നൽകുന്നു, ഓരോ വരിയിലും ഒന്ന്. നിങ്ങൾക്ക് ഒരു പ്രത്യേക ഡാറ്റാബേസ് ഉൾപ്പെടുത്താം
"--include" ഓപ്ഷൻ ഉപയോഗിച്ച്, അല്ലെങ്കിൽ നിങ്ങൾക്ക് "--dbname" ഓപ്ഷൻ ഉപയോഗിക്കാം.

ഓരോ വരിയിലും പതിനൊന്ന് ഇനങ്ങൾ മടക്കിനൽകുന്നു, നാമം: മൂല്യം, ഒറ്റത്തവണ വേർതിരിച്ചിരിക്കുന്നു
സ്ഥലം. ഇനങ്ങൾ ഇവയാണ്:

ബാക്കെൻഡുകൾ
ഈ ഡാറ്റാബേസിനായി നിലവിൽ പ്രവർത്തിക്കുന്ന ബാക്കെൻഡുകളുടെ എണ്ണം.

ചെയ്യുന്നു
ഈ ഡാറ്റാബേസ് സൃഷ്‌ടിച്ചതോ പുനഃസജ്ജമാക്കിയതോ ആയതിന് ശേഷമുള്ള കമ്മിറ്റുകളുടെ ആകെ എണ്ണം.

റോൾബാക്കുകൾ
ഈ ഡാറ്റാബേസ് സൃഷ്ടിച്ചതോ പുനഃസജ്ജമാക്കിയതോ ആയ മുതലുള്ള റോൾബാക്കുകളുടെ ആകെ എണ്ണം.

വായിക്കുക
റീഡ് ചെയ്ത ഡിസ്ക് ബ്ലോക്കുകളുടെ ആകെ എണ്ണം.

മൊത്തം ബഫർ ഹിറ്റുകളുടെ എണ്ണം അടിക്കുക.

ret തിരികെ നൽകിയ വരികളുടെ ആകെ എണ്ണം.

കൊണ്ടുവരിക
ആകെ ലഭിച്ച വരികളുടെ എണ്ണം.

ins ചേർത്ത വരികളുടെ ആകെ എണ്ണം.

upd അപ്ഡേറ്റ് ചെയ്ത വരികളുടെ ആകെ എണ്ണം.

del ഇല്ലാതാക്കിയ വരികളുടെ ആകെ എണ്ണം.

dbname
ഡാറ്റാബേസിന്റെ പേര്.

Postgres പതിപ്പ് 0 ആണെങ്കിൽ, ret, fetch, ins, upd, del ഇനങ്ങൾ എന്നിവ എപ്പോഴും 8.2 ആയിരിക്കുമെന്നത് ശ്രദ്ധിക്കുക.
അല്ലെങ്കിൽ താഴെ, ആ പതിപ്പുകളിൽ ആ സ്ഥിതിവിവരക്കണക്കുകൾ ലഭ്യമല്ലാത്തതിനാൽ.

dbname ആർഗ്യുമെന്റ് നൽകിയാൽ, ഏഴ് അധിക ഇനങ്ങൾ തിരികെ നൽകും:

idxscan
ഉപയോക്തൃ സൂചിക സ്കാനുകളുടെ ആകെ എണ്ണം.

idxtupread
തിരികെ നൽകിയ ഉപയോക്തൃ സൂചിക എൻട്രികളുടെ ആകെ എണ്ണം.

idxtupfetch
ലളിതമായ ഉപയോക്തൃ സൂചിക സ്കാനുകൾ വഴി ലഭിച്ച വരികളുടെ ആകെ എണ്ണം.

idxblksread
എല്ലാ ഉപയോക്തൃ സൂചികകൾക്കും വായിക്കുന്ന ഡിസ്ക് ബ്ലോക്കുകളുടെ ആകെ എണ്ണം.

idxblkshit
എല്ലാ ഉപയോക്തൃ സൂചികകൾക്കും ബഫർ ഹിറ്റുകളുടെ ആകെ എണ്ണം.

seqscan
എല്ലാ ഉപയോക്തൃ പട്ടികകൾക്കുമെതിരെയുള്ള തുടർച്ചയായ സ്കാനുകളുടെ ആകെ എണ്ണം.

seqtupread
എല്ലാ ഉപയോക്തൃ പട്ടികകളിൽ നിന്നും തിരികെ ലഭിച്ച ട്യൂപ്പിലുകളുടെ ആകെ എണ്ണം.

ഉദാഹരണം 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
("symlink: check_postgres_disabled_triggers") പ്രവർത്തനരഹിതമാക്കിയ ട്രിഗറുകളുടെ എണ്ണം പരിശോധിക്കുന്നു
ഡാറ്റാബേസിനുള്ളിൽ. ദി --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ അത്തരം ട്രിഗറുകളുടെ എണ്ണമാണ് ഓപ്ഷനുകൾ
കണ്ടെത്തി, രണ്ടും "1" ലേക്ക് സ്ഥിരസ്ഥിതിയായി, സാധാരണ ഉപയോഗത്തിൽ പ്രവർത്തനരഹിതമാക്കിയ ട്രിഗറുകൾ അപകടകരമാണ്
സംഭവം. പരിശോധിക്കുന്ന ഡാറ്റാബേസ് 8.3 അല്ലെങ്കിൽ അതിലും ഉയർന്നതാണെങ്കിൽ, ഇവയുടെ സംഖ്യയ്ക്കാണ് ചെക്ക്
ഒരു 'വികലാംഗ' നിലയിലുള്ള ട്രിഗറുകൾ ('എല്ലായ്പ്പോഴും' അല്ലെങ്കിൽ 'പ്രതിരൂപം' എന്നതിന് വിരുദ്ധമായി). ദി
ഔട്ട്പുട്ട് പട്ടികയുടെ പേരും ഓരോ അപ്രാപ്തമാക്കപ്പെട്ടവർക്കും വേണ്ടി ട്രിഗറിന്റെ പേരും കാണിക്കും
ട്രിഗർ.

ഉദാഹരണം 1: പ്രവർത്തനരഹിതമാക്കിയ ട്രിഗറുകൾ ഇല്ലെന്ന് ഉറപ്പാക്കുക

check_postgres_disabled_triggers

MRTG ഔട്ട്‌പുട്ടിനായി, ആദ്യ വരിയിൽ പ്രവർത്തനരഹിതമാക്കിയ ട്രിഗറുകളുടെ എണ്ണം നൽകുന്നു.

ഡിസ്ക് സ്പേസ്
("symlink: check_postgres_disk_space") ലഭ്യമായ ഫിസിക്കൽ ഡിസ്ക് സ്പേസ് പരിശോധിക്കുന്നു
പോസ്റ്റ്ഗ്രെസ്. ഈ പ്രവർത്തനത്തിന് നിങ്ങൾക്ക് എക്സിക്യൂട്ടബിൾ "/bin/df"റിപ്പോർട്ട് ചെയ്യാൻ ലഭ്യമാണ്
ഡിസ്ക് വലുപ്പങ്ങളിൽ, കൂടാതെ ഇത് ഒരു സൂപ്പർ യൂസറായി പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട്, അതിനാൽ ഇതിന് പരിശോധിക്കാൻ കഴിയും
ഡാറ്റ_ഡയറക്‌ടറി Postgres-ന്റെ ഉള്ളിൽ ക്രമീകരണം. ദി --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ ഓപ്ഷനുകൾ നൽകിയിരിക്കുന്നു
ഒന്നുകിൽ വലുപ്പത്തിലോ ശതമാനത്തിലോ അല്ലെങ്കിൽ രണ്ടിലും. വലുപ്പങ്ങൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, സാധാരണ യൂണിറ്റ് തരങ്ങളാണ്
അനുവദനീയമായത്: ബൈറ്റുകൾ, കിലോബൈറ്റുകൾ, ജിഗാബൈറ്റുകൾ, മെഗാബൈറ്റുകൾ, ജിഗാബൈറ്റുകൾ, ടെറാബൈറ്റുകൾ അല്ലെങ്കിൽ എക്സാബൈറ്റുകൾ. ഓരോന്നും
ആദ്യ അക്ഷരത്തിൽ മാത്രം ചുരുക്കാം; യൂണിറ്റുകളൊന്നും 'ബൈറ്റുകൾ' സൂചിപ്പിക്കുന്നില്ല. ദി
സ്ഥിര മൂല്യങ്ങൾ '90%', '95%' എന്നിവയാണ്.

എല്ലാ ഫിസിക്കൽ ഡിസ്കുകളും നിർണ്ണയിക്കാൻ ഈ കമാൻഡ് ഇനിപ്പറയുന്ന കാര്യങ്ങൾ പരിശോധിക്കുന്നു
Postgres ഉപയോഗിക്കുന്നു.

ഡാറ്റ_ഡയറക്‌ടറി - പ്രധാന ഡാറ്റ ഡയറക്ടറി ഓണായിരിക്കുന്ന ഡിസ്ക്.

ലോഗ് ഡയറക്ടറി - ലോഗ് ഫയലുകൾ ഉള്ള ഡിസ്ക്.

വാൾ ഫയല് ഡയറക്ടറി - റൈറ്റ്-എഹെഡ് ലോഗുകൾ ഉള്ള ഡിസ്ക് (ഉദാ. സിംലിങ്ക്ഡ് 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 ജിബിയിൽ കൂടുതൽ ഉണ്ട്

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") ഒരു ക്ലസ്റ്റർ പോസ്റ്റ്‌ഗ്രെസുമായി എത്ര അടുത്താണെന്ന് പരിശോധിക്കുന്നു
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") ഒരു ക്ലസ്റ്റർ പോസ്റ്റ്‌ഗ്രെസുമായി എത്ര അടുത്താണെന്ന് പരിശോധിക്കുന്നു
max_fsm_relations ക്രമീകരണം. ഈ പ്രവർത്തനം 8.2 അല്ലെങ്കിൽ അതിലും ഉയർന്ന ഡാറ്റാബേസുകളിൽ മാത്രമേ പ്രവർത്തിക്കൂ, കൂടാതെ
അതിന് contrib മൊഡ്യൂൾ ആവശ്യമാണ് pg_freespacemap ഇൻസ്റ്റാൾ ചെയ്യണം. ദി --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ
ഓപ്ഷനുകൾ ശതമാനമായി പ്രകടിപ്പിക്കണം. സൗജന്യമായി ഉപയോഗിച്ച ബന്ധങ്ങളുടെ എണ്ണം-
pg_freespacemap_relations കാഴ്ചയിൽ നോക്കിയാണ് സ്പേസ്-മാപ്പ് നിർണ്ണയിക്കുന്നത്. സ്ഥിരസ്ഥിതി
മൂല്യങ്ങളാണ് 85% മുന്നറിയിപ്പിനും 95% വിമർശനത്തിന്.

ഉദാഹരണം 1: ഞങ്ങളുടെ ക്ലസ്റ്റർ ഫ്രീ-സ്‌പേസ് ബന്ധങ്ങളുടെ 80% ഉപയോഗിക്കുമ്പോൾ ഒരു മുന്നറിയിപ്പ് നൽകുക,
ഡാറ്റാബേസ് dylan-ൽ pg_freespacemap ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട്

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

pg_freespacemap ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ള ഡാറ്റാബേസിന്റെ പേരിൽ നിങ്ങൾ കൈമാറേണ്ടതുണ്ട്
ഓരോ ക്ലസ്റ്ററിനും ഒരിക്കൽ മാത്രം ഈ പരിശോധന നടത്തേണ്ടതുണ്ട്. കൂടാതെ, ഈ വിവരങ്ങൾ പരിശോധിക്കുന്നത് ആവശ്യമാണ്
ഫ്രീ-സ്‌പേസ്-മാപ്പിൽ പ്രത്യേക ലോക്കുകൾ നേടുന്നു, അതിനാൽ ഇത് പ്രവർത്തിപ്പിക്കരുതെന്ന് ശുപാർശ ചെയ്യുന്നു
ചെറിയ ഇടവേളകളിൽ പരിശോധിക്കുക.

MRTG ഔട്ട്‌പുട്ടിനായി, ആദ്യ വരിയിലെ ഫ്രീ-സ്‌പേസ്-മാപ്പിന്റെ ശതമാനം നൽകുന്നു, സംഖ്യ
നിലവിൽ രണ്ടാം വരിയിൽ ഉപയോഗിക്കുന്ന ബന്ധങ്ങൾ.

ഹിറ്റ് റേഷ്യോ
("symlink: check_postgres_hitratio") എല്ലാ ഡാറ്റാബേസുകളുടെയും ഹിറ്റ് അനുപാതവും പരാതികളും പരിശോധിക്കുന്നു
അവ വളരെ കുറവായിരിക്കുമ്പോൾ. ഓരോ ഡാറ്റാബേസിനും ഒന്നിലധികം തവണ ഈ കമാൻഡ് പ്രവർത്തിപ്പിക്കേണ്ടതില്ല
ക്ലസ്റ്റർ. ഉപയോഗിച്ച് ഡാറ്റാബേസുകൾ ഫിൽട്ടർ ചെയ്യാൻ കഴിയും --ഉൾപ്പെടുന്നു ഒപ്പം --പെടുത്തിയിട്ടില്ല ഓപ്ഷനുകൾ. കാണുക
കൂടുതൽ വിവരങ്ങൾക്ക് "ബേസിക് ഫിൽട്ടറിംഗ്" വിഭാഗം. ഉടമയ്ക്ക് അവ ഫിൽട്ടർ ചെയ്യാനും കഴിയും
ഉള്ള ഡാറ്റാബേസ് --ഉപയോക്താവിനെ ഉൾപ്പെടുത്തുക ഒപ്പം --ഉപയോക്താവിനെ ഒഴിവാക്കുക ഓപ്ഷനുകൾ. "ഉപയോക്തൃ നാമം ഫിൽട്ടറിംഗ്" കാണുക
കൂടുതൽ വിശദാംശങ്ങൾക്ക് വിഭാഗം.

മുന്നറിയിപ്പും നിർണായക ഓപ്ഷനുകളും ശതമാനമായി വ്യക്തമാക്കണം. ഇല്ല
ഈ പ്രവർത്തനത്തിനുള്ള ഡിഫോൾട്ടുകൾ: മുന്നറിയിപ്പും നിർണായകവും വ്യക്തമാക്കിയിരിക്കണം. മുന്നറിയിപ്പ് മൂല്യം
നിർണായക മൂല്യത്തേക്കാൾ വലുതായിരിക്കരുത്. ഔട്ട്പുട്ട് അടുക്കിയ എല്ലാ ഡാറ്റാബേസുകളും നൽകുന്നു
ഹിറ്റ് റേഷ്യോ, ഏറ്റവും ചെറുത് ആദ്യം.

ഉദാഹരണം: ഹോസ്റ്റ് ഫ്ലാഗിലെ ഏതെങ്കിലും ഡാറ്റാബേസ് ഹിറ്റ് റേഷ്യോയിൽ 90% ൽ കുറവാണെങ്കിൽ മുന്നറിയിപ്പ് നൽകുക
80% ൽ കുറവ്.

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

MRTG ഔട്ട്‌പുട്ടിനായി, ഡാറ്റാബേസിന്റെ ഏറ്റവും ചെറിയ ഹിറ്റ്‌റേഷിയോ ഉള്ള ശതമാനം നൽകുന്നു
ആദ്യ വരി, നാലാമത്തെ വരിയിലെ ഡാറ്റാബേസിന്റെ പേര്.

hot_standby_delay
("symlink: check_hot_standby_delay") കമ്പ്യൂട്ടിംഗ് വഴി സ്ട്രീമിംഗ് റെപ്ലിക്കേഷൻ ലാഗ് പരിശോധിക്കുന്നു
ഒരു മാസ്റ്റർ സെർവറിന്റെ നിലവിലെ xlog സ്ഥാനത്തിനും a-യുടെ റീപ്ലേ ലൊക്കേഷനും ഇടയിലുള്ള ഡെൽറ്റ
അടിമ അതുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. സ്ലേവ് സെർവർ hot_standby (ഉദാ: വായിക്കാൻ മാത്രം) മോഡിൽ ആയിരിക്കണം,
അതിനാൽ ഈ പ്രവർത്തനം ഉപയോഗിക്കുന്നതിനുള്ള ഏറ്റവും കുറഞ്ഞ പതിപ്പ് Postgres 9.0 ആണ്. ദി --മുന്നറിയിപ്പ് ഒപ്പം
--നിർണ്ണായകമായ xlog ലൊക്കേഷനുകൾക്കിടയിലുള്ള ഡെൽറ്റയാണ് ഓപ്ഷനുകൾ. ഈ മൂല്യങ്ങൾ ബൈറ്റ് ആയതിനാൽ
WAL-ലെ ഓഫ്‌സെറ്റുകൾ നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ പ്രതീക്ഷിക്കുന്ന ഇടപാടിന്റെ അളവുമായി പൊരുത്തപ്പെടണം
തെറ്റായ പോസിറ്റീവ് അല്ലെങ്കിൽ നെഗറ്റീവ് തടയാൻ.

ആദ്യത്തെ "--dbname", "--host", "--port" തുടങ്ങിയ ഓപ്ഷനുകൾ മാസ്റ്ററായി കണക്കാക്കുന്നു; ദി
രണ്ടാമത്തേത് അടിമയുടേതാണ്.

സ്ട്രീമിംഗ് നടത്തുന്നതിന് ആവശ്യമായ ഇടപാടുകളുടെ അളവിനെ അടിസ്ഥാനമാക്കിയായിരിക്കണം ബൈറ്റ് മൂല്യങ്ങൾ
പോസ്റ്റ്‌ഗ്രേസ് നിർണ്ണയിച്ച, വളരെയധികം കാലതാമസം കാരണം മാസ്റ്ററിൽ നിന്ന് റെപ്ലിക്കേഷൻ വിച്ഛേദിക്കുന്നു
കോൺഫിഗറേഷൻ വേരിയബിൾ വാൾ_കീപ്പ്_സെഗ്‌മെന്റുകൾ. സമയ യൂണിറ്റുകൾക്ക്, സാധുതയുള്ള യൂണിറ്റുകൾ 'സെക്കൻഡ്' ആണ്,
'മിനിറ്റുകൾ', 'മണിക്കൂറുകൾ' അല്ലെങ്കിൽ 'ദിവസങ്ങൾ'. ഓരോന്നിനും ഏകവചനമോ ചുരുക്കമോ എഴുതാം
ആദ്യ അക്ഷരം. രണ്ടും വ്യക്തമാക്കുമ്പോൾ, ഫോമിൽ 'ബൈറ്റുകൾ ഒപ്പം കാലം', രണ്ട് വ്യവസ്ഥകളും ആയിരിക്കണം
ത്രെഷോൾഡ് എത്തുന്നതിന് സത്യമാണ്.

കോമ വേർതിരിച്ച് നൽകിക്കൊണ്ട് ഡാറ്റാബേസുകളിൽ എങ്ങനെ എത്തിച്ചേരാം എന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ നിങ്ങൾ നൽകണം
"--dbport=5432,5543" പോലെയുള്ള --dbhost, --dbport പാരാമീറ്ററുകളിലേക്ക് ലിസ്റ്റ് ചെയ്യുക. നൽകിയില്ലെങ്കിൽ,
പ്രവർത്തനം പരാജയപ്പെടുന്നു.

ഉദാഹരണം 1: പോർട്ട് 5433-ലെ ഒരു പ്രാദേശിക പകർപ്പുള്ള ഒരു ഡാറ്റാബേസ് ഏതൊരു xlog റീപ്ലേയിലും പിന്നിലാണെന്ന് മുന്നറിയിപ്പ് നൽകുക
എല്ലാം

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

ഉദാഹരണം 2: അവസാന ഇടപാട് replica1 സ്വീകരിച്ചത് 10-ൽ കൂടുതലാണെങ്കിൽ ഒരു നിർണായക രൂപം നൽകുക
മിനിറ്റ് മുമ്പ്

check_hot_standby_delay --dbhost=master,replica1 --critical='10 min'

ഉദാഹരണം 3: മാസ്റ്റർ തൽക്ഷണം കാണുന്നുണ്ടെങ്കിൽ, replica1 1 WAL സെഗ്‌മെന്റ് പിന്നിലാകാൻ അനുവദിക്കുക
സ്ട്രീമിംഗ് റെപ്ലിക്കേഷൻ കണക്ഷന് കൈകാര്യം ചെയ്യാൻ കഴിയുന്നതിനേക്കാൾ കൂടുതൽ പ്രവർത്തനം അല്ലെങ്കിൽ 10 മിനിറ്റ് പിന്നിൽ,
മാസ്റ്റർ വളരെ കുറച്ച് പ്രവർത്തനം കാണുകയും ഇടപാടുകളൊന്നും പ്രോസസ്സ് ചെയ്യുന്നില്ലെങ്കിൽ, പക്ഷേ അങ്ങനെയല്ല
രണ്ടും, ഇത് റെപ്ലിക്കേഷൻ കണക്ഷനിലെ ശാശ്വത പ്രശ്നത്തെ സൂചിപ്പിക്കുന്നു.

check_hot_standby_delay --dbhost=master,replica1 --warning='1048576, 2 മിനിറ്റ്' --critical='16777216, 10 മിനിറ്റ്'

സൂചിക_വലിപ്പം
പട്ടിക_വലിപ്പം
റിലേഷൻ_സൈസ്
(സിംലിങ്കുകൾ: "check_postgres_index_size", "check_postgres_table_size", കൂടാതെ
"check_postgres_relation_size") പ്രവർത്തനങ്ങൾ പട്ടിക_വലിപ്പം ഒപ്പം സൂചിക_വലിപ്പം ലളിതമായി
യുടെ വ്യതിയാനങ്ങൾ റിലേഷൻ_സൈസ് പ്രവർത്തനം, വളർന്നുവന്ന ഒരു ബന്ധത്തെ പരിശോധിക്കുന്നു
വലിയ. ബന്ധങ്ങൾ (മറ്റൊരു രീതിയിൽ പറഞ്ഞാൽ, പട്ടികകളും സൂചികകളും) ഉപയോഗിച്ച് ഫിൽട്ടർ ചെയ്യാവുന്നതാണ് --ഉൾപ്പെടുന്നു
ഒപ്പം --പെടുത്തിയിട്ടില്ല ഓപ്ഷനുകൾ. കൂടുതൽ വിവരങ്ങൾക്ക് "ബേസിക് ഫിൽട്ടറിംഗ്" വിഭാഗം കാണുക. ബന്ധങ്ങൾക്ക് കഴിയും
ഉപയോഗിക്കുന്നതിലൂടെ അവയുടെ ഉടമസ്ഥതയിലുള്ള ഉപയോക്താവും ഫിൽട്ടർ ചെയ്യപ്പെടും --ഉപയോക്താവിനെ ഉൾപ്പെടുത്തുക ഒപ്പം --ഉപയോക്താവിനെ ഒഴിവാക്കുക
ഓപ്ഷനുകൾ. കൂടുതൽ വിവരങ്ങൾക്ക് "USER NAME FILTERING" വിഭാഗം കാണുക.

എന്നതിനായുള്ള മൂല്യങ്ങൾ --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ ഓപ്ഷനുകൾ ഫയൽ വലുപ്പങ്ങളാണ്, കൂടാതെ യൂണിറ്റുകൾ ഉണ്ടായിരിക്കാം
ബൈറ്റുകൾ, കിലോബൈറ്റുകൾ, മെഗാബൈറ്റുകൾ, ജിഗാബൈറ്റുകൾ, ടെറാബൈറ്റുകൾ, അല്ലെങ്കിൽ എക്സാബൈറ്റുകൾ. ഓരോന്നും ചുരുക്കാം
ആദ്യ അക്ഷരത്തിലേക്ക്. യൂണിറ്റുകളൊന്നും നൽകിയിട്ടില്ലെങ്കിൽ, ബൈറ്റുകൾ അനുമാനിക്കപ്പെടുന്നു. സ്ഥിരസ്ഥിതികളൊന്നുമില്ല
മൂല്യങ്ങൾ: മുന്നറിയിപ്പും നിർണായക ഓപ്ഷനും നൽകണം. റിട്ടേൺ ടെക്സ്റ്റ് കാണിക്കുന്നു
കണ്ടെത്തിയ ഏറ്റവും വലിയ ബന്ധത്തിന്റെ വലിപ്പം.

എങ്കില് --ഷോപ്പർഫ് ഓപ്ഷൻ പ്രവർത്തനക്ഷമമാക്കി, എല്ലാം അവയുടെ വലുപ്പങ്ങളുമായുള്ള ബന്ധങ്ങൾ നൽകും.
ഇത് തടയുന്നതിന്, നിങ്ങൾ സജ്ജമാക്കാൻ ശുപാർശ ചെയ്യുന്നു --പെർഫ്ലിമിറ്റ് ഓപ്ഷൻ, അത് കാരണമാകും
"ഓർഡർ ബൈ സൈസ് ഡെസ്‌ക് ലിമിറ്റ് (പെർഫ്ലിമിറ്റ്)" ചെയ്യാനുള്ള അന്വേഷണം.

ഉദാഹരണം 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 ഔട്ട്‌പുട്ടിനായി, ഏറ്റവും വലിയ ബന്ധത്തിന്റെ ബൈറ്റുകളിൽ വലുപ്പവും അതിന്റെ പേരും നൽകുന്നു
നാലാമത്തെ വരിയായി ഡാറ്റാബേസും ബന്ധവും.

അവസാന_വിശകലനം
അവസാന_വാക്വം
അവസാന_സ്വയം വിശകലനം
അവസാന_ഓട്ടോവാക്വം
(സിംലിങ്കുകൾ: "check_postgres_last_analyze", "check_postgres_last_vacuum",
"check_postgres_last_autoanalyze", "check_postgres_last_autovacuum") എത്ര സമയം പരിശോധിക്കുന്നു
ഒന്നോ അതിലധികമോ ഡാറ്റാബേസുകളിൽ ഓരോ ടേബിളിലും അവസാനമായി വാക്വം (അല്ലെങ്കിൽ വിശകലനം) പ്രവർത്തിപ്പിച്ചത് മുതൽ ഇത് സംഭവിച്ചു.
ഈ പ്രവർത്തനങ്ങളുടെ ഉപയോഗത്തിന്, ടാർഗെറ്റ് ഡാറ്റാബേസ് പതിപ്പ് 8.3 അല്ലെങ്കിൽ അതിലും ഉയർന്നത് ആവശ്യമാണ്
പതിപ്പ് 8.2 ആണ്, കോൺഫിഗറേഷൻ വേരിയബിളും സ്ഥിതിവിവരക്കണക്ക്_റോ_ലെവൽ പ്രവർത്തനക്ഷമമാക്കിയിരിക്കുന്നു. പട്ടികകൾ
ഉപയോഗിച്ച് ഫിൽട്ടർ ചെയ്യാം --ഉൾപ്പെടുന്നു ഒപ്പം --പെടുത്തിയിട്ടില്ല ഓപ്ഷനുകൾ. "അടിസ്ഥാന ഫിൽട്ടറിംഗ്" കാണുക
കൂടുതൽ വിവരങ്ങൾക്ക് വിഭാഗം. ടേബിളുകൾ ഉപയോഗിച്ച് അവയുടെ ഉടമയ്ക്ക് ഫിൽട്ടർ ചെയ്യാനും കഴിയും
--ഉപയോക്താവിനെ ഉൾപ്പെടുത്തുക ഒപ്പം --ഉപയോക്താവിനെ ഒഴിവാക്കുക ഓപ്ഷനുകൾ. കൂടുതൽ കാര്യങ്ങൾക്കായി "USER NAME FILTERING" വിഭാഗം കാണുക
വിശദാംശങ്ങൾ.

വേണ്ടിയുള്ള യൂണിറ്റുകൾ --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ സമയങ്ങളായി വ്യക്തമാക്കിയിരിക്കുന്നു. സാധുവായ യൂണിറ്റുകൾ സെക്കന്റുകൾ ആണ്,
മിനിറ്റുകൾ, മണിക്കൂറുകൾ, ദിവസങ്ങൾ; എല്ലാം ആദ്യ അക്ഷരത്തിലേക്ക് ചുരുക്കാം. യൂണിറ്റുകൾ ഇല്ലെങ്കിൽ
നൽകിയിരിക്കുന്നു, 'സെക്കൻഡുകൾ' അനുമാനിക്കപ്പെടുന്നു. സ്ഥിരസ്ഥിതി മൂല്യങ്ങൾ '1 ദിവസം', '2 ദിവസം' എന്നിവയാണ്. ദയവായി ശ്രദ്ധിക്കുക
ഈ ഫീൽഡ് സ്വയമേവ പോപ്പുലേഷൻ ആകാത്ത സാഹചര്യങ്ങളുണ്ടെന്ന്. ഉറപ്പാണെങ്കിൽ
പട്ടികകൾ നിങ്ങൾക്ക് പ്രശ്‌നങ്ങൾ നൽകുന്നു, അവയ്‌ക്ക് വാക്വം ചെയ്യാനുള്ള നിർജ്ജീവ വരികൾ ഉണ്ടെന്ന് ഉറപ്പാക്കുക, അല്ലെങ്കിൽ വെറുതെ
അവരെ പരീക്ഷയിൽ നിന്ന് ഒഴിവാക്കുക.

'information_schema' എന്ന് പേരിട്ടിരിക്കുന്ന സ്കീമയെ ഈ ടെസ്റ്റിൽ നിന്ന് ഒഴിവാക്കിയിരിക്കുന്നു, കാരണം ഇത് പട്ടികകൾ മാത്രമാണ്.
അടങ്ങിയിരിക്കുന്നവ ചെറുതും മാറാത്തതുമാണ്.

നോൺ-'ഓട്ടോ' പതിപ്പുകൾ ഓട്ടോ പതിപ്പുകളിലും പരിശോധിക്കുമെന്നത് ശ്രദ്ധിക്കുക. മറ്റുള്ളവയിൽ
വാക്കുകൾ, last_vacuum ഉപയോഗിച്ച് അവസാന വാക്വം റിപ്പോർട്ട് ചെയ്യും, അത് ഒരു സാധാരണ വാക്വം ആയിരുന്നോ,
അല്ലെങ്കിൽ ഓട്ടോവാക്വം ഡെമൺ പ്രവർത്തിപ്പിക്കുന്ന ഒന്ന്.

ഉദാഹരണം 1: ഏതെങ്കിലും ടേബിൾ 3 ദിവസത്തിനുള്ളിൽ വാക്വം ചെയ്തിട്ടില്ലെങ്കിൽ മുന്നറിയിപ്പ് നൽകുക, കൂടാതെ ഒരു ക്രിട്ടിക്കൽ നൽകുക
ആഴ്ചയിൽ, ആതിഥേയ കാഞ്ഞിരത്തിന്

check_postgres_last_vacuum --host=wormwood --warning='3d' --critical='7d'

ഉദാഹരണം 2: മുകളിൽ പറഞ്ഞതുപോലെ തന്നെ, എന്നാൽ 'eve' അല്ലെങ്കിൽ 'mallory' ഉപയോക്താക്കളുടെ പട്ടികകൾ ഒഴിവാക്കുക

check_postgres_last_vacuum --host=wormwood --warning='3d' --critical='7d' --excludeusers=eve,mallory

MRTG ഔട്ട്‌പുട്ടിനായി, a മുതൽ സെക്കൻഡുകൾക്കുള്ളിൽ ഏറ്റവും കുറഞ്ഞ സമയം (ആദ്യ വരിയിൽ) നൽകുന്നു
പട്ടിക അവസാനമായി ശൂന്യമാക്കുകയോ വിശകലനം ചെയ്യുകയോ ചെയ്തു. നാലാമത്തെ വരി ഡാറ്റാബേസിന്റെ പേര് നൽകുന്നു
പട്ടികയുടെ പേര്.

ശ്രോതാവ്
("symlink: check_postgres_listener") ആരെങ്കിലും ഒന്നോ അതിലധികമോ കാര്യങ്ങൾ ശ്രദ്ധിക്കുന്നുണ്ടെന്ന് സ്ഥിരീകരിക്കുക
pg_listener ടേബിളിൽ നോക്കി പ്രത്യേക സ്ട്രിംഗുകൾ (LISTEN/NOTIFY സിസ്റ്റം ഉപയോഗിച്ച്).
മുന്നറിയിപ്പ് അല്ലെങ്കിൽ നിർണായകമായ ഒന്ന് മാത്രമേ ആവശ്യമുള്ളൂ. ഫോർമാറ്റ് പ്രതിനിധീകരിക്കുന്ന ഒരു ലളിതമായ സ്ട്രിംഗാണ്
ശ്രവിക്കുക ടാർഗെറ്റ്, അല്ലെങ്കിൽ ഒരു ടിൽഡ് പ്രതീകം തുടർന്ന് ഒരു പതിവ് എക്സ്പ്രഷൻ പരിശോധനയ്ക്കായി ഒരു സ്ട്രിംഗ്.
ഈ പരിശോധന Postgres 9.0 അല്ലെങ്കിൽ ഉയർന്ന പതിപ്പുകളിൽ പ്രവർത്തിക്കില്ല എന്നത് ശ്രദ്ധിക്കുക.

ഉദാഹരണം 1: പോർട്ടുകളിൽ bucardo_mcp_ping എന്ന സ്ട്രിംഗ് ആരും ശ്രദ്ധിക്കുന്നില്ലെങ്കിൽ മുന്നറിയിപ്പ് നൽകുക
5555, 5556

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

ഉദാഹരണം 2: '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: ഹോസ്റ്റ് ആർട്ടിമസിൽ, 200-ഓ അതിലധികമോ ലോക്കുകൾ നിലവിലുണ്ടെങ്കിൽ മുന്നറിയിപ്പ് നൽകുക
മൊത്തം 250-ലധികം ലോക്കുകൾ നിലവിലുണ്ട്, അല്ലെങ്കിൽ 20-ലധികം എക്സ്ക്ലൂസീവ് ലോക്കുകൾ നിലവിലുണ്ടെങ്കിൽ, അല്ലെങ്കിൽ 5-ലധികം കണക്ഷനുകൾ ഉണ്ടെങ്കിൽ
ഒരു ലോക്കിനായി കാത്തിരിക്കുന്നു.

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

MRTG ഔട്ട്‌പുട്ടിനായി, ആദ്യ വരിയിലെ ലോക്കുകളുടെ എണ്ണവും അതിന്റെ പേരും നൽകുന്നു
നാലാമത്തെ വരിയിലെ ഡാറ്റാബേസ്.

ലോഗ് ഫയൽ
("symlink: check_postgres_logfile") ലോഗ്‌ഫൈൽ പ്രതീക്ഷിച്ച സ്ഥലത്താണെന്ന് ഉറപ്പാക്കുന്നു
എന്നതിലേക്ക് ലോഗിൻ ചെയ്തുകൊണ്ടിരിക്കുന്നു. ഈ പ്രവർത്തനം ഓരോന്നിനും ഒരു പിശക് എറിയുന്ന ഒരു കമാൻഡ് നൽകുന്നു
ഡാറ്റാബേസ് അത് പരിശോധിക്കുന്നു, ലോഗുകളിൽ സന്ദേശം കാണിക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു. ഇത് സ്കാൻ ചെയ്യുന്നു
ലോഗുകൾ എവിടെയായിരിക്കണമെന്ന് കണ്ടുപിടിക്കാൻ Postgres-ന്റെ ഉള്ളിലെ വിവിധ log_* ക്രമീകരണങ്ങൾ. നിങ്ങൾ എങ്കിൽ
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
("symlink: check_postgres_new_version_bc") Bucardo-യുടെ പുതിയ പതിപ്പാണോ എന്ന് പരിശോധിക്കുന്നു
പ്രോഗ്രാം ലഭ്യമാണ്. "bucardo_ctl --version" പ്രവർത്തിപ്പിക്കുന്നതിലൂടെയാണ് നിലവിലെ പതിപ്പ് ലഭിക്കുന്നത്.
ഒരു പ്രധാന അപ്‌ഗ്രേഡ് ലഭ്യമാണെങ്കിൽ, ഒരു മുന്നറിയിപ്പ് തിരികെ നൽകും. ഒരു റിവിഷൻ അപ്ഗ്രേഡ് ആണെങ്കിൽ
ലഭ്യം, ഒരു നിർണായകം തിരികെ ലഭിച്ചു. (ബുക്കാർഡോ അടിമയുടെ യജമാനനാണ്, യജമാനനാകാൻ യജമാനനാണ്
Postgres-നുള്ള റെപ്ലിക്കേഷൻ സിസ്റ്റം: കാണുക http://bucardo.org കൂടുതൽ വിവരങ്ങൾക്ക്). ഇതും കാണുക
"--get_method" ഓപ്ഷനിലെ വിവരങ്ങൾ.

new_version_box
("symlink: check_postgres_new_version_box") boxinfo-യുടെ പുതിയ പതിപ്പാണോ എന്ന് പരിശോധിക്കുന്നു
പ്രോഗ്രാം ലഭ്യമാണ്. "boxinfo.pl --version" പ്രവർത്തിപ്പിക്കുന്നതിലൂടെയാണ് നിലവിലെ പതിപ്പ് ലഭിക്കുന്നത്.
ഒരു പ്രധാന അപ്‌ഗ്രേഡ് ലഭ്യമാണെങ്കിൽ, ഒരു മുന്നറിയിപ്പ് തിരികെ നൽകും. ഒരു റിവിഷൻ അപ്ഗ്രേഡ് ആണെങ്കിൽ
ലഭ്യം, ഒരു നിർണായകം തിരികെ ലഭിച്ചു. (ബോക്‌സ്‌ഇൻഫോ പ്രധാനപ്പെട്ടത് പിടിക്കാനുള്ള ഒരു പ്രോഗ്രാമാണ്
ഒരു സെർവറിൽ നിന്നുള്ള വിവരങ്ങൾ ഒരു HTML ഫോർമാറ്റിൽ ഇടുന്നു: കാണുക
http://bucardo.org/wiki/boxinfo കൂടുതൽ വിവരങ്ങൾക്ക്). എന്നതിലെ വിവരങ്ങളും കാണുക
"--get_method" ഓപ്ഷൻ.

new_version_cp
("symlink: check_postgres_new_version_cp") ഈ പ്രോഗ്രാമിന്റെ പുതിയ പതിപ്പാണോ എന്ന് പരിശോധിക്കുന്നു
(check_postgres) ഒരു ചെറിയ ടെക്‌സ്‌റ്റ് ഫയലിൽ നിന്ന് പതിപ്പ് പിടിച്ചെടുക്കുന്നതിലൂടെ ലഭ്യമാണ്
പ്രോജക്റ്റിനായുള്ള ഹോം പേജിന്റെ പേജ്. നൽകിയ പതിപ്പ് നൽകിയില്ലെങ്കിൽ മുന്നറിയിപ്പ് നൽകുന്നു
നിങ്ങൾ പ്രവർത്തിപ്പിക്കുന്നതുമായി പൊരുത്തപ്പെടുക. പരിശോധിക്കുന്നതിനുള്ള ശുപാർശിത ഇടവേള ദിവസത്തിൽ ഒരിക്കൽ. ഇതും കാണുക
"--get_method" ഓപ്ഷനിലെ വിവരങ്ങൾ.

new_version_pg
("symlink: check_postgres_new_version_pg") Postgres-ന്റെ ഒരു പുതിയ പുനരവലോകനം നിലവിലുണ്ടോയെന്ന് പരിശോധിക്കുന്നു
കണക്റ്റുചെയ്തിരിക്കുന്ന ഓരോ ഡാറ്റാബേസിനും. ഇത് പുനരവലോകനത്തിനായി മാത്രമേ പരിശോധിക്കൂ, ഉദാ
8.3.6 മുതൽ 8.3.7 വരെ. പുനരവലോകനങ്ങൾ എല്ലായ്‌പ്പോഴും 100% ബൈനറിക്ക് അനുയോജ്യമാണ്, കൂടാതെ ഡംപ് കൂടാതെ ഉൾപ്പെടുന്നു
നവീകരിക്കാൻ പുനഃസ്ഥാപിക്കുക. ബഗുകൾ പരിഹരിക്കുന്നതിനാണ് പുനരവലോകനങ്ങൾ നടത്തുന്നത്, അതിനാൽ കഴിയുന്നതും വേഗം നവീകരിക്കുന്നു
എപ്പോഴും ശുപാർശ ചെയ്യുന്നു. നിങ്ങൾക്ക് ഏറ്റവും പുതിയ പുനരവലോകനം ഇല്ലെങ്കിൽ ഒരു മുന്നറിയിപ്പ് നൽകുന്നു. അത്
ഈ പരിശോധന ദിവസത്തിൽ ഒരിക്കലെങ്കിലും നടത്താൻ ശുപാർശ ചെയ്യുന്നു. എന്നതിലെ വിവരങ്ങളും കാണുക
"--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_" എന്നിവയും. നിലവിൽ ലിങ്ക് ചെയ്തിട്ടുള്ള കണക്ഷനുകളാണ് സജീവ ക്ലയന്റ് കണക്ഷനുകൾ
സജീവമായ ഒരു സെർവർ കണക്ഷനോടൊപ്പം. ക്ലയന്റ് കണക്ഷനുകളും "കാത്തിരിപ്പ്" ആയിരിക്കാം, അതായത് അവ
ഇതുവരെ സെർവർ കണക്ഷൻ അനുവദിച്ചിട്ടില്ല. സെർവർ കണക്ഷനുകൾ "സജീവമാണ്" (ലിങ്ക് ചെയ്‌തിരിക്കുന്നു
ഒരു ക്ലയന്റിലേക്ക്), "നിഷ്ക്രിയം" (ലിങ്ക് ചെയ്യാനുള്ള ഒരു ക്ലയന്റ് കണക്ഷനായി നിൽക്കുന്നു), "ഉപയോഗിച്ചത്" (വെറും
ഒരു ക്ലയന്റിൽ നിന്ന് അൺലിങ്ക് ചെയ്‌തിരിക്കുന്നു, ഇതുവരെ നിഷ്‌ക്രിയ പൂളിലേക്ക് മടങ്ങിയിട്ടില്ല), "പരീക്ഷിച്ചു" (നിലവിൽ നിലവിലുണ്ട്
പരീക്ഷിച്ചു) കൂടാതെ "ലോഗിൻ" (ലോഗിൻ ചെയ്യുന്ന പ്രക്രിയയിൽ). മാക്‌സ്‌വെയ്‌റ്റ് മൂല്യം എത്ര സമയം ഉണ്ടെന്ന് കാണിക്കുന്നു
ഏറ്റവും പഴയ ക്ലയന്റ് കണക്ഷൻ കാത്തിരിക്കുന്ന നിമിഷങ്ങൾ.

pgbouncer_backends
("symlink: check_postgres_pgbouncer_backends") നിലവിലെ കണക്ഷനുകളുടെ എണ്ണം പരിശോധിക്കുന്നു
pgbouncer വഴിയുള്ള ഒന്നോ അതിലധികമോ ഡാറ്റാബേസുകൾക്കായി, ഓപ്ഷണലായി അതിനെ പരമാവധി താരതമ്യം ചെയ്യുന്നു
അനുവദനീയമാണ്, ഇത് pgbouncer കോൺഫിഗറേഷൻ വേരിയബിൾ നിർണ്ണയിക്കുന്നു max_client_conn. ദി
--മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ ഓപ്ഷനുകൾക്ക് മൂന്ന് ഫോമുകളിൽ ഒന്ന് എടുക്കാം. ആദ്യം, ഒരു ലളിതമായ സംഖ്യയ്ക്ക് കഴിയും
നൽകണം, ഇത് അലേർട്ട് നൽകുന്ന കണക്ഷനുകളുടെ എണ്ണത്തെ പ്രതിനിധീകരിക്കുന്നു.
ഈ തിരഞ്ഞെടുപ്പ് ഉപയോഗിക്കുന്നില്ല max_connections ക്രമീകരണം. രണ്ടാമതായി, ലഭ്യമായതിന്റെ ശതമാനം
കണക്ഷനുകൾ നൽകാം. മൂന്നാമതായി, പ്രതിനിധീകരിക്കുന്ന ഒരു നെഗറ്റീവ് നമ്പർ നൽകാം
വരെ ശേഷിക്കുന്ന കണക്ഷനുകളുടെ എണ്ണം max_connections എത്തിയിരിക്കുന്നു. എന്നതിനായുള്ള ഡിഫോൾട്ട് മൂല്യങ്ങൾ
--മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ '90%', '95%' എന്നിവയാണ്. ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഡാറ്റാബേസുകൾ ഫിൽട്ടർ ചെയ്യാനും കഴിയും
The --ഉൾപ്പെടുന്നു ഒപ്പം --പെടുത്തിയിട്ടില്ല ഓപ്ഷനുകൾ. കൂടുതൽ വിവരങ്ങൾക്ക് "ബേസിക് ഫിൽട്ടറിംഗ്" വിഭാഗം കാണുക.

നിഷ്ക്രിയമായ പ്രക്രിയകൾ മാത്രം കാണുന്നതിന്, നിങ്ങൾക്ക് ഇത് ഉപയോഗിക്കാം --നൊയ്ഡിൽ വാദം. ഉപയോക്താവ് നിങ്ങളാണെന്ന കാര്യം ശ്രദ്ധിക്കുക
ഇത് ശരിയായി പ്രവർത്തിക്കുന്നതിന് ഒരു സൂപ്പർ യൂസർ ആയിരിക്കണം എന്നതിനാൽ ബന്ധിപ്പിക്കുന്നു.

ഉദാഹരണം 1: ഹോസ്റ്റ് ക്വിർമിലെ കണക്ഷനുകളുടെ എണ്ണം 120 ൽ എത്തുമ്പോൾ ഒരു മുന്നറിയിപ്പ് നൽകുക, കൂടാതെ a
150ൽ എത്തിയാൽ അത് നിർണായകമാണ്.

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

ഉദാഹരണം 2: ഹോസ്റ്റുകളിൽ ഞങ്ങളുടെ max_connections ക്രമീകരണത്തിന്റെ 75% എത്തുമ്പോൾ നിർണായകമായ ഒരു കാര്യം നൽകുക
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 ഔട്ട്പുട്ടിനായി, കണക്ഷനുകളുടെ എണ്ണം ആദ്യ വരിയിലും നാലാമത്തേതിലും റിപ്പോർട്ട് ചെയ്യുന്നു
ലൈൻ ഡാറ്റാബേസിന്റെ പേര് നൽകുന്നു, കൂടാതെ നിലവിലെ max_client_conn. ഒന്നിൽ കൂടുതൽ ആണെങ്കിൽ
ഡാറ്റാബേസ് അന്വേഷിച്ചു, ഏറ്റവും കൂടുതൽ കണക്ഷനുകൾ ഉള്ളത് ഔട്ട്പുട്ട് ആണ്.

pgbouncer_checksum
("symlink: check_postgres_pgbouncer_checksum") എല്ലാ pgBouncer ക്രമീകരണങ്ങളും പരിശോധിക്കുന്നു
നിങ്ങൾ കഴിഞ്ഞ തവണ പരിശോധിച്ചതിന് സമാനമാണ്. ക്രമീകരിച്ച പട്ടികയുടെ ഒരു ചെക്ക്സം സൃഷ്ടിച്ചാണ് ഇത് ചെയ്യുന്നത്
പേരുകളും അവയുടെ മൂല്യങ്ങളും ക്രമീകരിക്കുന്നതിന്. നിങ്ങൾ ഡാറ്റാബേസിന്റെ പേര് വ്യക്തമാക്കേണ്ടതില്ല എന്നത് ശ്രദ്ധിക്കുക
pgbouncer-ലേക്ക് സ്വയമേവ സ്ഥിരസ്ഥിതിയാകും. ഒന്നുകിൽ --മുന്നറിയിപ്പ് അഥവാ --നിർണ്ണായകമായ ഓപ്ഷൻ
കൊടുക്കണം, രണ്ടും അല്ല. ഓരോന്നിന്റെയും മൂല്യം ചെക്ക്സം ആണ്, 32 പ്രതീകങ്ങൾ
ഹെക്സാഡെസിമൽ മൂല്യം. ഒരു കണ്ടെത്താൻ നിങ്ങൾക്ക് പ്രത്യേക "--critical=0" ഓപ്ഷൻ ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കാം
നിലവിലുള്ള ചെക്ക്സം.

ഈ പ്രവർത്തനത്തിന് Digest ::MD5 മൊഡ്യൂൾ ആവശ്യമാണ്.

ഉദാഹരണം 1: പോർട്ട് 6432-ൽ pgbouncer കോൺഫിഗറേഷനായി പ്രാരംഭ ചെക്ക്സം കണ്ടെത്തുക
സ്ഥിര ഉപയോക്താവ് (സാധാരണയായി പോസ്റ്റ്ഗ്രെസ്)

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

തയ്യാറായ_txns
("symlink: check_postgres_prepared_txns") നിലവിലുള്ള ഏതെങ്കിലും തയ്യാറാക്കിയവയുടെ പ്രായം പരിശോധിക്കുക
ഇടപാടുകൾ. മിക്ക ആളുകളും തയ്യാറാക്കിയ ഇടപാടുകൾ ഉപയോഗിക്കില്ല, കാരണം അവ ഭാഗമാണ്
രണ്ട് ഭാഗങ്ങളുള്ള പ്രതിബദ്ധതയുള്ളതും പരിപാലിക്കാൻ സങ്കീർണ്ണവുമാണ്. അവരും ആശയക്കുഴപ്പത്തിലാകരുത്
തയ്യാറാക്കിയ പ്രസ്താവനകൾ, തയ്യാർ എന്ന് കേൾക്കുമ്പോൾ മിക്ക ആളുകളും ചിന്തിക്കുന്നത് ഇതാണ്. ദി
ഒരു മുന്നറിയിപ്പിനുള്ള ഡിഫോൾട്ട് മൂല്യം 1 സെക്കൻഡാണ്, തയ്യാറാക്കിയ ഇടപാടുകളുടെ ഏതെങ്കിലും ഉപയോഗം കണ്ടെത്തുന്നതിന്
മിക്ക സിസ്റ്റങ്ങളിലെയും ഒരു തെറ്റായിരിക്കാം. മുന്നറിയിപ്പും നിർണായകവുമാണ് സെക്കൻഡുകളുടെ എണ്ണം a
ഒരു അലർട്ട് നൽകുന്നതിന് മുമ്പ് തയ്യാറാക്കിയ ഇടപാട് തുറന്നിട്ടുണ്ട്.

ഉദാഹരണം 1: തയ്യാറാക്കിയ ഏതെങ്കിലും ഇടപാടുകൾ കണ്ടെത്തുമ്പോൾ മുന്നറിയിപ്പ് നൽകുക:

check_postgres_prepared_txns -w 0

ഉദാഹരണം 2: തയ്യാറാക്കിയ ഏതെങ്കിലും ഇടപാട് 10-ൽ കൂടുതൽ സമയം തുറന്നിട്ടുണ്ടെങ്കിൽ ഒരു നിർണായക രൂപം നൽകുക
സെക്കൻഡുകൾ, എന്നാൽ ഡാറ്റാബേസ് 'ഷ്‌റൈക്ക്' 360 സെക്കൻഡ് വരെ അനുവദിക്കുക:

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: "സ്പീഡ് ടെസ്റ്റ്" എന്ന് പേരിട്ടിരിക്കുന്ന ഫംഗ്‌ഷൻ 10 സെക്കൻഡിനുള്ളിൽ പ്രവർത്തിക്കുന്നതിൽ പരാജയപ്പെടുകയാണെങ്കിൽ അല്ലെങ്കിൽ ഒരു നിർണായകം നൽകുക
കുറവ്.

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

MRTG ഔട്ട്‌പുട്ടിനായി, ആദ്യ വരിയിൽ അന്വേഷണം പൂർത്തിയാക്കുന്നതിനുള്ള സമയം നിമിഷങ്ങൾക്കുള്ളിൽ റിപ്പോർട്ട് ചെയ്യുന്നു.
നാലാമത്തെ വരി ഡാറ്റാബേസ് പട്ടികപ്പെടുത്തുന്നു.

ചോദ്യം_സമയം
("symlink: check_postgres_query_time") ഒന്നോ അതിലധികമോ അന്വേഷണങ്ങളുടെ ദൈർഘ്യം പരിശോധിക്കുന്നു
ഡാറ്റാബേസുകൾ. ഒരേ ഡാറ്റാബേസ് ക്ലസ്റ്ററിൽ ഇത് ഒന്നിലധികം തവണ പ്രവർത്തിപ്പിക്കേണ്ടതില്ല. കുറിപ്പ്
"ഇടപാടിൽ നിഷ്‌ക്രിയമായ" അന്വേഷണങ്ങളെ ഇത് ഇതിനകം ഒഴിവാക്കിയിരിക്കുന്നു. ഡാറ്റാബേസുകൾ ആകാം
ഉപയോഗിച്ച് ഫിൽട്ടർ ചെയ്യുന്നു --ഉൾപ്പെടുന്നു ഒപ്പം --പെടുത്തിയിട്ടില്ല ഓപ്ഷനുകൾ. "ബേസിക് ഫിൽട്ടറിംഗ്" വിഭാഗം കാണുക
കൂടുതൽ വിവരങ്ങൾക്ക്. എന്നതിനൊപ്പം ചോദ്യം പ്രവർത്തിപ്പിക്കുന്ന ഉപയോക്താവിനെ നിങ്ങൾക്ക് ഫിൽട്ടർ ചെയ്യാനും കഴിയും --ഉപയോക്താവിനെ ഉൾപ്പെടുത്തുക
ഒപ്പം --ഉപയോക്താവിനെ ഒഴിവാക്കുക ഓപ്ഷനുകൾ. കൂടുതൽ വിവരങ്ങൾക്ക് "USER NAME FILTERING" വിഭാഗം കാണുക.

എന്നതിനായുള്ള മൂല്യങ്ങൾ --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ ഓപ്‌ഷനുകൾ സമയത്തിന്റെ അളവാണ്, കൂടാതെ '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: ഉപയോക്താവിന് 'ഡോൺ' എന്നതിന് 20 സെക്കൻഡിൽ കൂടുതൽ ദൈർഘ്യമുള്ള ചോദ്യമുണ്ടെങ്കിൽ മുന്നറിയിപ്പ് നൽകുക

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

MRTG ഔട്ട്‌പുട്ടിനായി, ആദ്യത്തേതിൽ ഏറ്റവും ദൈർഘ്യമേറിയ ചോദ്യത്തിന്റെ ദൈർഘ്യം സെക്കൻഡിൽ നൽകുന്നു
ലൈൻ. നാലാമത്തെ വരി ഡാറ്റാബേസിന്റെ പേര് നൽകുന്നു.

replicate_row
("symlink: check_postgres_replicate_row") മാസ്റ്റർ-സ്ലേവ് റെപ്ലിക്കേഷൻ പ്രവർത്തിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുന്നു
ഒന്നോ അതിലധികമോ അടിമകൾക്ക്.

ആദ്യത്തെ "--dbname", "--host", "--port" തുടങ്ങിയ ഓപ്ഷനുകൾ മാസ്റ്ററായി കണക്കാക്കുന്നു;
തുടർന്നുള്ള ഉപയോഗങ്ങൾ അടിമകളാണ്. മൂല്യങ്ങൾ അല്ലെങ്കിൽ --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ ഓപ്ഷനുകൾ
സമയത്തിന്റെ യൂണിറ്റുകൾ, കുറഞ്ഞത് ഒരെണ്ണമെങ്കിലും നൽകണം (സ്ഥിരസ്ഥിതികളൊന്നുമില്ല). സാധുവായ യൂണിറ്റുകൾ 'സെക്കൻഡ്' ആണ്,
'മിനിറ്റുകൾ', 'മണിക്കൂറുകൾ' അല്ലെങ്കിൽ 'ദിവസങ്ങൾ'. ഓരോന്നിനും ഏകവചനമോ ചുരുക്കമോ എഴുതാം
ആദ്യ അക്ഷരം. യൂണിറ്റുകളൊന്നും നൽകിയിട്ടില്ലെങ്കിൽ, യൂണിറ്റുകൾ സെക്കന്റുകളായി കണക്കാക്കുന്നു.

ഈ പരിശോധന മാസ്റ്ററിലെ ഒരൊറ്റ വരി അപ്‌ഡേറ്റ് ചെയ്യുന്നു, തുടർന്ന് അത് എത്ര സമയമെടുക്കുമെന്ന് അളക്കുന്നു
അടിമകൾക്ക് പ്രയോഗിച്ചു. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ ആവർത്തിക്കുന്ന ഒരു പട്ടിക തിരഞ്ഞെടുക്കേണ്ടതുണ്ട്
മാറ്റാൻ കഴിയുന്ന ഒരു വരി കണ്ടെത്തുക, മറ്റേതെങ്കിലും പ്രക്രിയയാൽ മാറ്റാൻ പോകുന്നില്ല. എ
ഈ വരിയുടെ നിർദ്ദിഷ്ട കോളം ഒരു മൂല്യത്തിൽ നിന്ന് മറ്റൊന്നിലേക്ക് മാറ്റും. ഇതിനെല്ലാം ഭക്ഷണം നൽകുന്നു
"repinfo" ഓപ്‌ഷനിലേക്ക്, കൂടാതെ കോമകളാൽ വേർതിരിച്ച ഇനിപ്പറയുന്ന ഓപ്ഷനുകൾ അടങ്ങിയിരിക്കണം:
പട്ടികയുടെ പേര്, പ്രാഥമിക കീ, കീ ഐഡി, കോളം, ആദ്യ മൂല്യം, രണ്ടാമത്തെ മൂല്യം.

ഉദാഹരണം 1: ഹോസ്റ്റ് 'ആൽഫ' മുതൽ ഹോസ്റ്റ് 'ബീറ്റ' വരെ 'ഓർഡറുകൾ' എന്ന പേരിലുള്ള പട്ടിക സ്ലോണി ആവർത്തിക്കുന്നു,
ഡാറ്റാബേസിൽ 'വിൽപ്പന'. പട്ടികയുടെ പ്രാഥമിക കീക്ക് ഐഡി എന്ന് പേരിട്ടിരിക്കുന്നു, ഞങ്ങൾ പോകുകയാണ്
3 എന്ന ഐഡി ഉപയോഗിച്ച് വരി പരീക്ഷിക്കുക (ഇത് ചരിത്രപരവും ഒരിക്കലും മാറാത്തതുമാണ്). ഒരു കോളം ഉണ്ട്
'slon' എന്നതിന്റെ മൂല്യത്തിൽ നിന്ന് 'nols' എന്നതിലേക്ക് മാറാൻ പോകുന്ന 'salesrep' എന്ന് നാമകരണം ചെയ്‌തിരിക്കുന്നു.
പകർപ്പ്. 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=ചുവപ്പ്, നീല, മഞ്ഞ
--critical=5 --repinfo=രസീത്, receipt_id,9,zone,North,South

MRTG ഔട്ട്‌പുട്ടിനായി, ആദ്യ വരിയിൽ തന്നെ റെപ്ലിക്കേഷൻ എടുക്കുന്ന നിമിഷങ്ങൾക്കുള്ള സമയം നൽകുന്നു
പൂർത്തിയാക്കുക. പരമാവധി സമയം 4 മിനിറ്റ് 30 സെക്കൻഡ് ആയി സജ്ജീകരിച്ചിരിക്കുന്നു: ഒരു പകർപ്പും എടുത്തിട്ടില്ലെങ്കിൽ
വളരെക്കാലമായി, ഒരു പിശക് സംഭവിക്കുന്നു.

അതേ_സ്കീമ
("symlink: check_postgres_same_schema") രണ്ടോ അതിലധികമോ ഡാറ്റാബേസുകൾ സമാനമാണെന്ന് സ്ഥിരീകരിക്കുന്നു
അവരുടെ സ്കീമ വരെ (പക്ഷേ ഉള്ളിലെ ഡാറ്റയല്ല). ഇത് നിർമ്മിക്കാൻ പ്രത്യേകിച്ച് സൗകര്യപ്രദമാണ്
യജമാനനെ അടിമയായി ഉപയോഗിക്കുമ്പോൾ നിങ്ങളുടെ അടിമകൾ ഏതെങ്കിലും വിധത്തിൽ പരിഷ്‌ക്കരിക്കുകയോ കേടുവരുത്തുകയോ ചെയ്‌തിട്ടില്ലെന്ന് ഉറപ്പാണ്
അനുകരണം. മറ്റ് പ്രവർത്തനങ്ങളിൽ നിന്ന് വ്യത്യസ്തമായി, ഇതിന് മുന്നറിയിപ്പോ നിർണായക മാനദണ്ഡമോ ഇല്ല - ദി
ഡാറ്റാബേസുകൾ ഒന്നുകിൽ സമന്വയത്തിലാണ്, അല്ലെങ്കിൽ അല്ല. അവ വ്യത്യസ്തമാണെങ്കിൽ, വിശദമായ ഒരു ലിസ്റ്റ്
വ്യത്യാസങ്ങൾ അവതരിപ്പിക്കുന്നു.

ചില വ്യത്യാസങ്ങൾ ഒഴിവാക്കാനോ ഫിൽട്ടർ ചെയ്യാനോ നിങ്ങൾ ആഗ്രഹിച്ചേക്കാം. ഇതിനുള്ള വഴി കൂട്ടിച്ചേർക്കുക എന്നതാണ്
"--ഫിൽട്ടർ" ഓപ്ഷനിലേക്കുള്ള സ്ട്രിംഗുകൾ. ഒരു തരം ഒബ്‌ജക്‌റ്റ് ഒഴിവാക്കാൻ, "noname" ഉപയോഗിക്കുക, ഇവിടെ 'name'
വസ്തുവിന്റെ തരം, ഉദാഹരണത്തിന്, "noschema". ഒരു പ്രത്യേക തരത്തിലുള്ള ഒബ്ജക്റ്റുകളെ ഒഴിവാക്കുന്നതിന് a
അവരുടെ പേരിനെതിരായ പതിവ് പദപ്രയോഗം, "noname=regex" ഉപയോഗിക്കുക. a എന്നതിന് താഴെയുള്ള ഉദാഹരണങ്ങൾ കാണുക
മെച്ചപ്പെട്ട ധാരണ.

ഫിൽട്ടർ ചെയ്യാൻ കഴിയുന്ന ഒബ്‌ജക്റ്റുകളുടെ തരങ്ങളിൽ ഇവ ഉൾപ്പെടുന്നു:

ഉപയോക്താവ്
പദ്ധതി
മേശ
കാഴ്ച
സൂചിക
ക്രമം
നിയന്ത്രണം
തോക്കിന്റെ കാഞ്ചി
ഫംഗ്ഷൻ

"noposition" എന്ന ഫിൽട്ടർ ഓപ്ഷൻ a ഉള്ളിലെ നിരകളുടെ സ്ഥാനം പരിശോധിക്കുന്നത് തടയുന്നു
മേശ.

"nofuncbody" എന്ന ഫിൽട്ടർ ഓപ്ഷൻ എല്ലാ പ്രവർത്തനങ്ങളുടെയും ബോഡികളുടെ താരതമ്യം തടയുന്നു.

"noperm" എന്ന ഫിൽട്ടർ ഓപ്ഷൻ ഒബ്ജക്റ്റ് അനുമതികളുടെ താരതമ്യം തടയുന്നു.

രണ്ടാമത്തെ ഡാറ്റാബേസ് നൽകാൻ, ആദ്യത്തേതിലേക്ക് ഒരു കോളിലൂടെ വ്യത്യാസങ്ങൾ ചേർക്കുക
ഉചിതമായ കണക്ഷൻ വാദം. ഉദാഹരണത്തിന്, ഹോസ്റ്റുകളുടെ ആൽഫയിലെ ഡാറ്റാബേസുകൾ താരതമ്യം ചെയ്യാൻ
ബ്രാവോ, "--dbhost=alpha,bravo" ഉപയോഗിക്കുക. ചുവടെയുള്ള ഉദാഹരണങ്ങളും കാണുക.

ഒരൊറ്റ ഹോസ്റ്റ് മാത്രമേ നൽകിയിട്ടുള്ളൂവെങ്കിൽ, ഞങ്ങൾ "സമയത്തെ അടിസ്ഥാനമാക്കിയുള്ള" റിപ്പോർട്ട് ചെയ്യുന്നതായി കരുതപ്പെടുന്നു. ദി
ആദ്യമായി ഇത് പ്രവർത്തിപ്പിക്കുമ്പോൾ ഡാറ്റാബേസിലെ എല്ലാ ഇനങ്ങളുടെയും ഒരു സ്നാപ്പ്ഷോട്ട് ഒരു ലോക്കലിൽ സംരക്ഷിക്കപ്പെടുന്നു
ഫയൽ. നിങ്ങൾ ഇത് വീണ്ടും പ്രവർത്തിപ്പിക്കുമ്പോൾ, ആ സ്നാപ്പ്ഷോട്ട് വായിക്കുകയും "ഡാറ്റാബേസ് #2" ആയി മാറുകയും ചെയ്യുന്നു
നിലവിലെ ഡാറ്റാബേസുമായി താരതമ്യം ചെയ്യുമ്പോൾ.

പഴയ സംഭരിച്ച ഫയൽ പുതിയ പതിപ്പ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാൻ, --replace ആർഗ്യുമെന്റ് ഉപയോഗിക്കുക.

വിവിധ സമയങ്ങളിൽ സ്നാപ്പ്ഷോട്ടുകൾ പ്രവർത്തനക്ഷമമാക്കുന്നതിന്, നിങ്ങൾക്ക് "--സഫിക്സ്" ആർഗ്യുമെന്റ് ഉണ്ടാക്കാൻ ഉപയോഗിക്കാം
ഓരോ റണ്ണിനും തനതായ ഫയൽനാമങ്ങൾ. ചുവടെയുള്ള ഉദാഹരണങ്ങൾ കാണുക.

ഉദാഹരണം 1: ഹോസ്റ്റ് സ്റ്റാറിലും ലൈനിലുമുള്ള രണ്ട് ഡാറ്റാബേസുകൾ ഒന്നുതന്നെയാണെന്ന് പരിശോധിക്കുക:

check_postgres_same_schema --dbhost=നക്ഷത്രം, ലൈൻ

ഉദാഹരണം 2: മുമ്പത്തെ പോലെ തന്നെ, എന്നാൽ അവരുടെ പേരിൽ "സ്ലോണി" ഉള്ള ഏതെങ്കിലും ട്രിഗറുകൾ ഒഴിവാക്കുക

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

ഉദാഹരണം 3: മുമ്പത്തെ പോലെ തന്നെ, എന്നാൽ എല്ലാ സൂചികകളും ഒഴിവാക്കുക

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

ഉദാഹരണം 4: വ്യത്യസ്ത പോർട്ടുകളിലെ "ബാറ്റിൽസ്റ്റാർ" എന്ന ഡാറ്റാബേസിന്റെ വ്യത്യാസങ്ങൾ പരിശോധിക്കുക

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

ഉദാഹരണം 5: പ്രതിദിന, പ്രതിവാര സ്‌നാപ്പ്‌ഷോട്ട് ഫയൽ സൃഷ്‌ടിക്കുക

check_postgres_same_schema --dbname=cylon --suffix=പ്രതിദിനം
check_postgres_same_schema --dbname=cylon --suffix=പ്രതിവാരം

ഉദാഹരണം 6: ഒരു ചരിത്രപരമായ താരതമ്യം പ്രവർത്തിപ്പിക്കുക, തുടർന്ന് ഫയൽ മാറ്റിസ്ഥാപിക്കുക

check_postgres_same_schema --dbname=cylon --suffix=പ്രതിദിനം --replace

ക്രമം
("symlink: check_postgres_sequence") എല്ലാ സീക്വൻസുകളിലും എത്ര റൂം ശേഷിക്കുന്നു എന്ന് പരിശോധിക്കുന്നു
ഡാറ്റാബേസ്. ഉപയോഗിച്ച മൊത്തം സാധ്യമായ മൂല്യങ്ങളുടെ ശതമാനമായാണ് ഇത് അളക്കുന്നത്
ഓരോ ക്രമത്തിനും. ദി --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ ഓപ്ഷനുകൾ ഇങ്ങനെ പ്രകടിപ്പിക്കണം
ശതമാനം. സ്ഥിര മൂല്യങ്ങൾ എന്നിവയാണ് 85% മുന്നറിയിപ്പിനും 95% വിമർശനത്തിന്. ഒരുപക്ഷേ നിങ്ങൾ
ഏതൊക്കെ സീക്വൻസുകളാണ് പരിശോധിക്കേണ്ടതെന്ന് നിയന്ത്രിക്കാൻ --ഉൾപ്പെടുത്തുക, --ഒഴിവാക്കുക എന്നിവ ഉപയോഗിക്കുക. ഇത് ശ്രദ്ധിക്കുക
പരിശോധന അസാധാരണമായി കണക്കാക്കുന്നു കുറഞ്ഞ മൂല്യം ഒപ്പം ഇൻക്രിമെന്റും by മൂല്യങ്ങൾ, എന്നാൽ അത് കാര്യമാക്കുന്നില്ല
ക്രമം സൈക്കിളാണോ അല്ലയോ എന്ന് സജ്ജീകരിച്ചിരിക്കുന്നു.

നാഗിയോസിന്റെ ഔട്ട്‌പുട്ട് ക്രമത്തിന്റെ പേരും ഉപയോഗിച്ച ശതമാനവും സംഖ്യയും നൽകുന്നു
'കോളുകൾ' അവശേഷിക്കുന്നു, ആ ക്രമത്തിൽ അടുത്തത് എത്ര തവണ കൂടി വിളിക്കാം എന്ന് സൂചിപ്പിക്കുന്നു
പരമാവധി മൂല്യത്തിലേക്ക് ഓടുന്നതിന് മുമ്പ്.

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" ആർഗ്യുമെന്റായി ഒരു ചെക്ക്സം നൽകണം. നാലാമത്തെ വരി എപ്പോഴും നൽകുന്നു
നിലവിലെ ചെക്ക്സം.

സ്ലോണി_സ്റ്റാറ്റസ്
("symlink: check_postgres_slony_status") ഒരു സ്ലോണി ക്ലസ്റ്ററിന്റെ നില പരിശോധിക്കുന്നു
സ്ലോണിയുടെ sl_status കാഴ്‌ചയുടെ ഫലങ്ങൾ നോക്കുന്നു. ഇത് സംഖ്യയായി നൽകുന്നു
"ലാഗ് ടൈം" എന്നതിന്റെ സെക്കന്റുകൾ. ദി --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ ഓപ്ഷനുകൾ സമയത്തിനനുസരിച്ച് പ്രകടിപ്പിക്കണം.
സ്ഥിര മൂല്യങ്ങൾ എന്നിവയാണ് 60 നിമിഷങ്ങൾ മുന്നറിയിപ്പിനും 300 നിമിഷങ്ങൾ വിമർശനത്തിന്.

ഐച്ഛിക വാദം --സ്കീമ സ്ലോണി ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ള സ്കീമ സൂചിപ്പിച്ചു. എങ്കിൽ
നൽകിയിട്ടില്ല, ഓരോ തവണയും ഈ ചെക്ക് പ്രവർത്തിപ്പിക്കുമ്പോൾ സ്കീമ സ്വയമേവ നിർണ്ണയിക്കപ്പെടും.

ഉദാഹരണം 1: ഏതെങ്കിലും സ്ലോണി 20 സെക്കൻഡിൽ കൂടുതൽ പിന്നിലാണെങ്കിൽ ഒരു മുന്നറിയിപ്പ് നൽകുക

check_postgres_slony_status --മുന്നറിയിപ്പ് 20

ഉദാഹരണം 2: "_slony" എന്ന സ്കീമയ്ക്ക് കീഴിൽ ഇൻസ്റ്റാൾ ചെയ്ത 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
("symlink: check_postgres_txn_idle") "idle in" എന്നതിന്റെ നമ്പറും ദൈർഘ്യവും പരിശോധിക്കുന്നു
ഇടപാട്" ഒന്നോ അതിലധികമോ ഡാറ്റാബേസുകളിലെ അന്വേഷണങ്ങൾ. ഇത് ഒന്നിലധികം തവണ പ്രവർത്തിപ്പിക്കേണ്ട ആവശ്യമില്ല
അതേ ഡാറ്റാബേസ് ക്ലസ്റ്ററിൽ. ഉപയോഗിച്ച് ഡാറ്റാബേസുകൾ ഫിൽട്ടർ ചെയ്യാം --ഉൾപ്പെടുന്നു ഒപ്പം
--പെടുത്തിയിട്ടില്ല ഓപ്ഷനുകൾ. കൂടുതൽ വിശദാംശങ്ങൾക്ക് താഴെയുള്ള "ബേസിക് ഫിൽട്ടറിംഗ്" വിഭാഗം കാണുക.

ദി --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ സമയത്തിന്റെ യൂണിറ്റുകൾ, ഒപ്പിട്ട പൂർണ്ണസംഖ്യകൾ, അല്ലെങ്കിൽ
സമയ യൂണിറ്റുകൾക്കുള്ള പൂർണ്ണസംഖ്യകൾ, രണ്ടും നൽകണം (സ്ഥിരസ്ഥിതികളൊന്നുമില്ല). സാധുവായ യൂണിറ്റുകൾ
'സെക്കൻഡ്', 'മിനിറ്റുകൾ', 'മണിക്കൂറുകൾ' അല്ലെങ്കിൽ 'ദിവസങ്ങൾ' എന്നിവയാണ്. ഓരോന്നിനും ഏകവചനമോ ചുരുക്കമോ എഴുതാം
ആദ്യ അക്ഷരത്തിലേക്ക്. യൂണിറ്റുകളൊന്നും നൽകാതിരിക്കുകയും നമ്പറുകൾ ഒപ്പിടാതിരിക്കുകയും ചെയ്താൽ, യൂണിറ്റുകൾ
സെക്കന്റുകൾ എന്ന് അനുമാനിക്കപ്പെടുന്നു.

ഈ പ്രവർത്തനത്തിന് Postgres 8.3 അല്ലെങ്കിൽ അതിലും മികച്ചത് ആവശ്യമാണ്.

ഉദാഹരണം 1: 15-ൽ കൂടുതൽ ഇടപാടുകളിൽ ഏതെങ്കിലും കണക്ഷൻ നിഷ്‌ക്രിയമായിരുന്നെങ്കിൽ മുന്നറിയിപ്പ് നൽകുക
സെക്കന്റുകൾ:

check_postgres_txn_idle --port=5432 --warning='15 seconds'

ഉദാഹരണം 2: 50 അല്ലെങ്കിൽ അതിൽ കൂടുതൽ ഇടപാടുകൾ ഉണ്ടെങ്കിൽ മുന്നറിയിപ്പ് നൽകുക

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

ഉദാഹരണം 3: അഞ്ചോ അതിലധികമോ കണക്ഷനുകൾ കൂടുതൽ ഇടപാടുകളിൽ നിഷ്‌ക്രിയമായിരുന്നെങ്കിൽ ഒരു നിർണായക രൂപം നൽകുക
10 സെക്കൻഡിൽ കൂടുതൽ:

check_postgres_txn_idle --port=5432 --critical='5 10 സെക്കൻഡ്'

MRTG ഔട്ട്‌പുട്ടിനായി, ഏറ്റവും ദൈർഘ്യമേറിയ നിഷ്‌ക്രിയ ഇടപാട് നിമിഷങ്ങൾക്കുള്ളിൽ നൽകുന്നു
പ്രവർത്തിക്കുന്ന. നാലാമത്തെ വരി ഡാറ്റാബേസിന്റെ പേരും മറ്റ് വിവരങ്ങളും നൽകുന്നു
ഏറ്റവും ദൈർഘ്യമേറിയ ഇടപാട്.

txn_time
("symlink: check_postgres_txn_time") ഒന്നോ അതിലധികമോ ഇടപാടുകളുടെ ദൈർഘ്യം പരിശോധിക്കുന്നു
ഡാറ്റാബേസുകൾ. ഓരോ ഡാറ്റാബേസ് ക്ലസ്റ്ററിനും ഒന്നിലധികം തവണ ഈ കമാൻഡ് പ്രവർത്തിപ്പിക്കേണ്ടതില്ല.
ഉപയോഗിച്ച് ഡാറ്റാബേസുകൾ ഫിൽട്ടർ ചെയ്യാൻ കഴിയും --ഉൾപ്പെടുന്നു ഒപ്പം --പെടുത്തിയിട്ടില്ല ഓപ്ഷനുകൾ. "ബേസിക്" കാണുക
കൂടുതൽ വിശദാംശങ്ങൾക്കായി ഫിൽട്ടറിംഗ്" വിഭാഗം. ഇടപാടിന്റെ ഉടമയും ഫിൽട്ടർ ചെയ്യാവുന്നതാണ്
ഉപയോഗം --ഉപയോക്താവിനെ ഉൾപ്പെടുത്തുക ഒപ്പം --ഉപയോക്താവിനെ ഒഴിവാക്കുക ഓപ്ഷനുകൾ. "USER NAME FILTERING" വിഭാഗം കാണുക
കൂടുതൽ വിവരങ്ങൾക്ക്.

മൂല്യങ്ങൾ അല്ലെങ്കിൽ --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ ഓപ്ഷനുകൾ സമയത്തിന്റെ യൂണിറ്റുകളാണ്, അവ നൽകണം
(സ്ഥിരസ്ഥിതി ഇല്ല). 'സെക്കൻഡ്', 'മിനിറ്റുകൾ', 'മണിക്കൂറുകൾ' അല്ലെങ്കിൽ 'ദിവസങ്ങൾ' എന്നിവയാണ് സാധുതയുള്ള യൂണിറ്റുകൾ. ഓരോന്നും ആകാം
ആദ്യ അക്ഷരത്തിന് മാത്രമായി ഏകവചനമോ ചുരുക്കമോ എഴുതിയിരിക്കുന്നു. യൂണിറ്റുകളൊന്നും നൽകിയിട്ടില്ലെങ്കിൽ,
യൂണിറ്റുകൾ സെക്കന്റുകൾ ആയി കണക്കാക്കുന്നു.

ഈ പ്രവർത്തനത്തിന് Postgres 8.3 അല്ലെങ്കിൽ അതിലും മികച്ചത് ആവശ്യമാണ്.

ഉദാഹരണം 1: ഏതെങ്കിലും ഇടപാട് 10 മിനിറ്റിൽ കൂടുതൽ തുറന്നിട്ടുണ്ടെങ്കിൽ ഒരു നിർണായക രൂപം നൽകുക:

check_postgres_txn_time --port=5432 --critical='10 മിനിറ്റ്'

ഉദാഹരണം 1: ഉപയോക്തൃ 'വെയർഹൗസ്' 30 സെക്കൻഡിൽ കൂടുതൽ ഇടപാട് തുറന്നിട്ടുണ്ടെങ്കിൽ മുന്നറിയിപ്പ് നൽകുക

check_postgres_txn_time --port-5432 --warning=30s --includeuser=warehouse

MRTG ഔട്ട്‌പുട്ടിനായി, ഒരു ഇടപാട് തുറന്നിരിക്കുന്ന നിമിഷങ്ങൾക്കുള്ളിൽ പരമാവധി സമയം നൽകുന്നു
ആദ്യ വരി. നാലാമത്തെ വരി ഡാറ്റാബേസിന്റെ പേര് നൽകുന്നു.

txn_wraparound
("symlink: check_postgres_txn_wraparound") ഇടപാട് റാപ്പറൗണ്ട് ഒന്നിന് എത്ര അടുത്ത് എന്ന് പരിശോധിക്കുന്നു
അല്ലെങ്കിൽ കൂടുതൽ ഡാറ്റാബേസുകൾ ലഭിക്കുന്നു. ദി --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ ഓപ്ഷനുകൾ നമ്പർ സൂചിപ്പിക്കുന്നു
നടത്തിയ ഇടപാടുകളുടെ ഒരു പോസിറ്റീവ് പൂർണ്ണസംഖ്യയായിരിക്കണം. ഏതെങ്കിലും ഓപ്ഷൻ നൽകിയിട്ടില്ലെങ്കിൽ,
1.3, 1.4 ബില്യൺ എന്നിവയുടെ സ്ഥിര മൂല്യങ്ങൾ ഉപയോഗിക്കുന്നു. ഈ കമാൻഡ് കൂടുതൽ പ്രവർത്തിപ്പിക്കേണ്ട ആവശ്യമില്ല
ഒരു ഡാറ്റാബേസ് ക്ലസ്റ്ററിന് ഒന്നിൽ കൂടുതൽ. ഈ നമ്പർ എന്താണെന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിശദമായ ചർച്ചയ്ക്ക്
പ്രതിനിധീകരിക്കുന്നു, അതിനെക്കുറിച്ച് എന്തുചെയ്യണം, ദയവായി പേജ് സന്ദർശിക്കുക
<http://www.postgresql.org/docs/current/static/routine-vacuuming.html#വാക്വം-ഫോർ-റാപ്പറൗണ്ട്>

മുന്നറിയിപ്പിനും നിർണായക മൂല്യങ്ങൾക്കും വ്യക്തതയ്‌ക്കായി സംഖ്യയിൽ അടിവരയിടാം, പേൾ പോലെ
ചെയ്യും.

ഉദാഹരണം 1: ലോക്കൽ ഹോസ്റ്റ് ഡാറ്റാബേസിനായി ഡിഫോൾട്ട് മൂല്യങ്ങൾ പരിശോധിക്കുക

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-ന്റെ ആവശ്യമായ പതിപ്പാണോ എന്ന് പരിശോധിക്കുന്നു
പ്രവർത്തിക്കുന്ന. ദി --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ ഓപ്ഷനുകൾ (ഒരെണ്ണം മാത്രം ആവശ്യമാണ്) ഫോർമാറ്റിലുള്ളതായിരിക്കണം
XY 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 വാലി, ധാന്യം, സൂര്യപ്രകാശം --ക്രിട്ടിക്കൽ=8.3

MRTG ഔട്ട്പുട്ടിനായി, ആദ്യ വരിയിൽ വിജയമോ പരാജയമോ സൂചിപ്പിക്കുന്ന 1 അല്ലെങ്കിൽ 0 റിപ്പോർട്ട് ചെയ്യുന്നു. ദി
നാലാമത്തെ വരി നിലവിലെ പതിപ്പിനെ സൂചിപ്പിക്കുന്നു. പതിപ്പ് "--mrtg" വഴി നൽകണം
ഓപ്ഷൻ.

wal_files
("symlink: check_postgres_wal_files") എത്ര WAL ഫയലുകൾ ഉണ്ടെന്ന് പരിശോധിക്കുന്നു pg_xlog
നിങ്ങളുടെ ഡയറക്‌ടറിയിൽ നിന്ന് കണ്ടെത്തി ഡാറ്റ_ഡയറക്‌ടറി, ചിലപ്പോൾ മറ്റൊന്നിലേക്കുള്ള സിംലിങ്കായി
പ്രകടന കാരണങ്ങളാൽ ഫിസിക്കൽ ഡിസ്ക്. ഈ പ്രവർത്തനം ഒരു സൂപ്പർ യൂസറായി പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട്
യുടെ ഉള്ളടക്കങ്ങൾ ആക്സസ് ചെയ്യുക pg_xlog ഡയറക്ടറി. ഈ പ്രവർത്തനം ഉപയോഗിക്കുന്നതിനുള്ള ഏറ്റവും കുറഞ്ഞ പതിപ്പ് ഇതാണ്
പോസ്റ്റ്ഗ്രെസ് 8.1. ദി --മുന്നറിയിപ്പ് ഒപ്പം --നിർണ്ണായകമായ എന്നതിലെ ഫയലുകളുടെ എണ്ണം മാത്രമാണ് ഓപ്ഷനുകൾ
pg_xlog ഡയറക്ടറി. ഇത് ഏത് നമ്പറായി സജ്ജീകരിക്കണം എന്നത് വ്യത്യസ്തമായിരിക്കും, എന്നാൽ ഒരു പൊതു മാർഗ്ഗനിർദ്ദേശം നൽകണം
പ്രശ്‌നങ്ങൾ നേരത്തേ കണ്ടുപിടിക്കാൻ സാധാരണ ഉള്ളതിനേക്കാൾ അല്പം കൂടുതലുള്ള ഒരു സംഖ്യ.

സാധാരണയായി, WAL ഫയലുകൾ അടയ്ക്കുകയും പിന്നീട് വീണ്ടും ഉപയോഗിക്കുകയും ചെയ്യും, എന്നാൽ ദീർഘകാല ഓപ്പൺ ഇടപാട്, അല്ലെങ്കിൽ ഒരു
തെറ്റ് ആർക്കൈവ്_കമാൻഡ് സ്ക്രിപ്റ്റ്, പോസ്റ്റ്ഗ്രെസിന് നിരവധി ഫയലുകൾ സൃഷ്ടിക്കാൻ കാരണമായേക്കാം. ആത്യന്തികമായി,
ഇത് അവർ ഉപയോഗിക്കുന്ന ഡിസ്കിന്റെ ഇടം തീർന്നുപോകാൻ ഇടയാക്കും, ആ സമയത്ത് Postgres ചെയ്യും
ഷട്ട് ഡൌണ്.

ഉദാഹരണം 1: ഹോസ്റ്റ് "പ്ലൂട്ടോ" യിൽ WAL ഫയലുകളുടെ എണ്ണം 20 അല്ലെങ്കിൽ അതിൽ കുറവാണോ എന്ന് പരിശോധിക്കുക

check_postgres_wal_files --host=pluto --critical=20

MRTG ഔട്ട്‌പുട്ടിനായി, ലൈൻ 1-ലെ WAL ഫയലുകളുടെ എണ്ണം റിപ്പോർട്ട് ചെയ്യുന്നു.

rebuild_symlinks
rebuild_symlinks_force
ഈ പ്രവർത്തനത്തിന് മറ്റ് ആർഗ്യുമെന്റുകളൊന്നും ആവശ്യമില്ല, കൂടാതെ ഒരു ഡാറ്റാബേസുകളിലേക്കും കണക്റ്റുചെയ്യുന്നില്ല, പക്ഷേ ലളിതമായി
ഫോമിൽ ഓരോ പ്രവർത്തനത്തിനും നിലവിലെ ഡയറക്‌ടറിയിൽ സിംലിങ്കുകൾ സൃഷ്‌ടിക്കുന്നു
ചെക്ക്_പോസ്റ്റ്ഗ്രെസ്_. ഫയൽ നിലവിലുണ്ടെങ്കിൽ, അത് തിരുത്തിയെഴുതപ്പെടില്ല. എങ്കിൽ
പ്രവർത്തനം rebuild_symlinks_force ആണ്, തുടർന്ന് സിംലിങ്കുകൾ തിരുത്തിയെഴുതപ്പെടും. ഓപ്ഷൻ
--action=rebuild_symlinks എന്ന് പറയുന്നതിനുള്ള ഒരു ചെറിയ മാർഗമാണ് --symlinks

ബേസിക് ഫിൽട്ടറിംഗ്

ഓപ്ഷനുകൾ --ഉൾപ്പെടുന്നു ഒപ്പം --പെടുത്തിയിട്ടില്ല പരിശോധിക്കുന്ന കാര്യങ്ങൾ പരിമിതപ്പെടുത്താൻ സംയോജിപ്പിക്കാം,
പ്രവർത്തനത്തെ ആശ്രയിച്ച്. ഇനിപ്പറയുന്നവ ഉപയോഗിക്കുമ്പോൾ ഡാറ്റാബേസിന്റെ പേര് ഫിൽട്ടർ ചെയ്യാൻ കഴിയും
പ്രവർത്തനങ്ങൾ: backends, database_size, locks, query_time, txn_idle, txn_time. പേര്
ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുമ്പോൾ ഒരു ബന്ധം ഫിൽട്ടർ ചെയ്യാൻ കഴിയും: bloat, index_size,
പട്ടിക_വലിപ്പം, റിലേഷൻ_സൈസ്, ലാസ്റ്റ്_വാക്വം, ലാസ്റ്റ്_ഓട്ടോവാക്വം, ലാസ്റ്റ്_അനലൈസ്, കൂടാതെ
അവസാന_സ്വയം വിശകലനം. settings_checksum ഉപയോഗിക്കുമ്പോൾ ഒരു ക്രമീകരണത്തിന്റെ പേര് ഫിൽട്ടർ ചെയ്യാവുന്നതാണ്
നടപടി. disk_space പ്രവർത്തനം ഉപയോഗിക്കുമ്പോൾ ഒരു ഫയൽ സിസ്റ്റത്തിന്റെ പേര് ഫിൽട്ടർ ചെയ്യാവുന്നതാണ്.

ഉൾപ്പെടുത്തൽ ഓപ്‌ഷൻ മാത്രമേ നൽകിയിട്ടുള്ളൂവെങ്കിൽ, പൊരുത്തപ്പെടുന്ന എൻട്രികൾ മാത്രമേ പരിശോധിക്കൂ.
എന്നിരുന്നാലും, ഒഴിവാക്കലും ഉൾപ്പെടുത്തലും നൽകിയാൽ, ഒഴിവാക്കലും ഉൾപ്പെടുത്തലും ആദ്യം ചെയ്യും
ശേഷം, ഒഴിവാക്കിയേക്കാവുന്ന കാര്യങ്ങൾ പുനഃസ്ഥാപിക്കാൻ. രണ്ടും --ഉൾപ്പെടുന്നു ഒപ്പം --പെടുത്തിയിട്ടില്ല കഴിയും
ഒന്നിലധികം തവണ നൽകണം, കൂടാതെ/അല്ലെങ്കിൽ കോമയാൽ വേർതിരിച്ച ലിസ്റ്റുകളായി. ഒരു മുൻനിര ടിൽഡുമായി പൊരുത്തപ്പെടും
ഒരു പതിവ് പദപ്രയോഗമായി പദത്തെ പിന്തുടരുന്നു.

ഒരു സ്കീമ പൊരുത്തപ്പെടുത്തുന്നതിന്, ഒരു കാലയളവ് കൊണ്ട് തിരയൽ പദം അവസാനിപ്പിക്കുക. ലീഡിംഗ് ടിൽഡുകൾ ഉപയോഗിക്കാം
സ്കീമുകൾക്കും.

ഫിൽട്ടറിംഗ് ഉപയോഗിക്കുമ്പോൾ ശ്രദ്ധിക്കുക: ബാക്കെൻഡുകളിൽ ഒരു ഉൾപ്പെടുത്തൽ നിയമം, ഉദാഹരണത്തിന്, മെയ്
പൊരുത്തപ്പെടുന്ന ഡാറ്റാബേസിന് ബാക്കെൻഡുകളില്ലാത്തതിനാൽ മാത്രമല്ല, നിങ്ങൾ കാരണം പ്രശ്‌നങ്ങളൊന്നും റിപ്പോർട്ട് ചെയ്യരുത്
ഡാറ്റാബേസിന്റെ പേര് തെറ്റായി എഴുതിയിരിക്കുന്നു!

ഉദാഹരണങ്ങൾ:

pg_class എന്ന് പേരുള്ള ഇനങ്ങൾ മാത്രം പരിശോധിക്കുന്നു:

--include=pg_class

'pg_' എന്ന അക്ഷരങ്ങൾ അടങ്ങിയ ഇനങ്ങൾ മാത്രം പരിശോധിക്കുന്നു:

--ഉൾപ്പെടുത്തുക=~pg_

'pg_' ൽ തുടങ്ങുന്ന ഇനങ്ങൾ മാത്രം പരിശോധിക്കുക:

--ഉൾപ്പെടുത്തുക=~^pg_

'ടെസ്റ്റ്' എന്ന് പേരിട്ടിരിക്കുന്ന ഇനം ഒഴിവാക്കുക:

--ഒഴിവാക്കുക=ടെസ്റ്റ്

'ടെസ്റ്റ്' എന്ന അക്ഷരങ്ങൾ അടങ്ങിയ എല്ലാ ഇനങ്ങളും ഒഴിവാക്കുക:

--ഒഴിവാക്കുക=~ടെസ്റ്റ്

'pg_catalog' സ്കീമയിലെ എല്ലാ ഇനങ്ങളും ഒഴിവാക്കുക:

--exclude='pg_catalog.'

'ace' എന്ന അക്ഷരങ്ങൾ അടങ്ങിയ എല്ലാ ഇനങ്ങളും ഒഴിവാക്കുക, എന്നാൽ 'faceoff' എന്ന ഇനം അനുവദിക്കുക:

--ഒഴിവാക്കുക=~ace --include=faceoff

'pg_' എന്ന അക്ഷരങ്ങളിൽ ആരംഭിക്കുന്ന എല്ലാ ഇനങ്ങളും ഒഴിവാക്കുക, അതിൽ 'slon' എന്ന അക്ഷരങ്ങൾ അടങ്ങിയിരിക്കുന്നു, അല്ലെങ്കിൽ
അവയ്ക്ക് 'sql_settings' അല്ലെങ്കിൽ 'green' എന്ന് പേരിട്ടിരിക്കുന്നു. അക്ഷരങ്ങളുള്ള ഇനങ്ങൾ പ്രത്യേകം പരിശോധിക്കുക
അവരുടെ പേരുകളിൽ 'prod', 'pg_relname' എന്ന് പേരുള്ള ഇനം എപ്പോഴും പരിശോധിക്കുക:

--ഒഴിവാക്കുക=~^pg_,~slon,sql_settings --exclude=green --include=~prod,pg_relname

USER NAME ഫിൽട്ടറിംഗ്

ഓപ്ഷനുകൾ --ഉപയോക്താവിനെ ഉൾപ്പെടുത്തുക ഒപ്പം --ഉപയോക്താവിനെ ഒഴിവാക്കുക പരിശോധിക്കാൻ മാത്രം ചില പ്രവർത്തനങ്ങളിൽ ഉപയോഗിക്കാം
ഒന്നോ അതിലധികമോ ഉപയോക്താക്കളുടെ ഉടമസ്ഥതയിലുള്ള (അല്ലെങ്കിൽ അവരുടെ ഉടമസ്ഥതയിലുള്ളതല്ല) ഡാറ്റാബേസ് വസ്തുക്കൾ. എ --ഉപയോക്താവിനെ ഉൾപ്പെടുത്തുക ഓപ്ഷൻ
എപ്പോഴും ട്രംപ് ഒരു --ഉപയോക്താവിനെ ഒഴിവാക്കുക ഓപ്ഷൻ. നിങ്ങൾക്ക് ഓരോ ഓപ്ഷനും ഒന്നിലധികം തവണ നൽകാം
ഒന്നിലധികം ഉപയോക്താക്കൾ, അല്ലെങ്കിൽ നിങ്ങൾക്ക് കോമയാൽ വേർതിരിച്ച ലിസ്റ്റ് നൽകാം. നിലവിൽ ഉപയോഗിക്കുന്ന പ്രവർത്തനങ്ങൾ
ഈ ഓപ്ഷനുകൾ ഇവയാണ്:

ഡാറ്റാബേസ്_സൈസ്
അവസാന_വിശകലനം
അവസാന_സ്വയം വിശകലനം
അവസാന_വാക്വം
അവസാന_ഓട്ടോവാക്വം
ചോദ്യം_സമയം
റിലേഷൻ_സൈസ്
txn_time

ഉദാഹരണങ്ങൾ:

greg എന്ന ഉപയോക്താവിന്റെ ഉടമസ്ഥതയിലുള്ള ഇനങ്ങൾ മാത്രം പരിശോധിക്കുക:

--includeuser=greg

വാട്സന്റെയോ ക്രിക്കിന്റെയോ ഉടമസ്ഥതയിലുള്ള ഇനങ്ങൾ മാത്രം പരിശോധിക്കുക:

--includeuser=watson,crick

ക്രിക്ക്, ഫ്രാങ്ക്ലിൻ, വാട്സൺ അല്ലെങ്കിൽ വിൽകിൻസ് എന്നിവരുടെ ഉടമസ്ഥതയിലുള്ള ഇനങ്ങൾ മാത്രം പരിശോധിക്കുക:

--includeuser=watson --includeuser=franklin --includeuser=crick,vilkins

ഉപയോക്തൃ സ്കോട്ടിന്റേത് ഒഴികെയുള്ള എല്ലാ ഇനങ്ങളും പരിശോധിക്കുക:

--excludeuser=scott

ടെസ്റ്റ് MODE

കാര്യങ്ങൾ സജ്ജീകരിക്കാൻ സഹായിക്കുന്നതിന്, ഈ പ്രോഗ്രാം "ടെസ്റ്റ് മോഡിൽ" വ്യക്തമാക്കുന്നതിലൂടെ പ്രവർത്തിപ്പിക്കാം
--ടെസ്റ്റ് ഓപ്ഷൻ. ഡാറ്റാബേസുകൾ സാധ്യമാണോ എന്ന് ഉറപ്പാക്കാൻ ഇത് ചില അടിസ്ഥാന പരിശോധനകൾ നടത്തും
ബന്ധപ്പെടുകയും, ഉപയോക്താവാണോ എന്നതുപോലുള്ള ചില പെർ-ആക്ഷൻ മുൻവ്യവസ്ഥകൾ പാലിക്കുകയും ചെയ്യുന്നു
ഒരു സൂപ്പർ യൂസർ, Postgres-ന്റെ പതിപ്പ് പുതിയതാണെങ്കിൽ, stats_row_level പ്രവർത്തനക്ഷമമാക്കിയിട്ടുണ്ടെങ്കിൽ.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് ഓൺലൈനായി check_postgres_pgb_pool_cl_waitingp ഉപയോഗിക്കുക