[0-9]+(?:\.[0-9]+)*) # release segment
+ (?P # pre-release
+ [-_\.]?
+ (?P(a|b|c|rc|alpha|beta|pre|preview))
+ [-_\.]?
+ (?P[0-9]+)?
+ )?
+ (?P # post release
+ (?:-(?P[0-9]+))
+ |
+ (?:
+ [-_\.]?
+ (?Ppost|rev|r)
+ [-_\.]?
+ (?P[0-9]+)?
+ )
+ )?
+ (?P # dev release
+ [-_\.]?
+ (?Pdev)
+ [-_\.]?
+ (?P[0-9]+)?
+ )?
+ )
+ (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))? # local version
+"""
+
+
+class Version(_BaseVersion):
+
+ _regex = re.compile(
+ r"^\s*" + VERSION_PATTERN + r"\s*$",
+ re.VERBOSE | re.IGNORECASE,
+ )
+
+ def __init__(self, version):
+ # Validate the version and parse it into pieces
+ match = self._regex.search(version)
+ if not match:
+ raise InvalidVersion("Invalid version: '{0}'".format(version))
+
+ # Store the parsed out pieces of the version
+ self._version = _Version(
+ epoch=int(match.group("epoch")) if match.group("epoch") else 0,
+ release=tuple(int(i) for i in match.group("release").split(".")),
+ pre=_parse_letter_version(
+ match.group("pre_l"),
+ match.group("pre_n"),
+ ),
+ post=_parse_letter_version(
+ match.group("post_l"),
+ match.group("post_n1") or match.group("post_n2"),
+ ),
+ dev=_parse_letter_version(
+ match.group("dev_l"),
+ match.group("dev_n"),
+ ),
+ local=_parse_local_version(match.group("local")),
+ )
+
+ # Generate a key which will be used for sorting
+ self._key = _cmpkey(
+ self._version.epoch,
+ self._version.release,
+ self._version.pre,
+ self._version.post,
+ self._version.dev,
+ self._version.local,
+ )
+
+ def __repr__(self):
+ return "".format(repr(str(self)))
+
+ def __str__(self):
+ parts = []
+
+ # Epoch
+ if self._version.epoch != 0:
+ parts.append("{0}!".format(self._version.epoch))
+
+ # Release segment
+ parts.append(".".join(str(x) for x in self._version.release))
+
+ # Pre-release
+ if self._version.pre is not None:
+ parts.append("".join(str(x) for x in self._version.pre))
+
+ # Post-release
+ if self._version.post is not None:
+ parts.append(".post{0}".format(self._version.post[1]))
+
+ # Development release
+ if self._version.dev is not None:
+ parts.append(".dev{0}".format(self._version.dev[1]))
+
+ # Local version segment
+ if self._version.local is not None:
+ parts.append(
+ "+{0}".format(".".join(str(x) for x in self._version.local))
+ )
+
+ return "".join(parts)
+
+ @property
+ def public(self):
+ return str(self).split("+", 1)[0]
+
+ @property
+ def base_version(self):
+ parts = []
+
+ # Epoch
+ if self._version.epoch != 0:
+ parts.append("{0}!".format(self._version.epoch))
+
+ # Release segment
+ parts.append(".".join(str(x) for x in self._version.release))
+
+ return "".join(parts)
+
+ @property
+ def local(self):
+ version_string = str(self)
+ if "+" in version_string:
+ return version_string.split("+", 1)[1]
+
+ @property
+ def is_prerelease(self):
+ return bool(self._version.dev or self._version.pre)
+
+ @property
+ def is_postrelease(self):
+ return bool(self._version.post)
+
+
+def _parse_letter_version(letter, number):
+ if letter:
+ # We consider there to be an implicit 0 in a pre-release if there is
+ # not a numeral associated with it.
+ if number is None:
+ number = 0
+
+ # We normalize any letters to their lower case form
+ letter = letter.lower()
+
+ # We consider some words to be alternate spellings of other words and
+ # in those cases we want to normalize the spellings to our preferred
+ # spelling.
+ if letter == "alpha":
+ letter = "a"
+ elif letter == "beta":
+ letter = "b"
+ elif letter in ["c", "pre", "preview"]:
+ letter = "rc"
+ elif letter in ["rev", "r"]:
+ letter = "post"
+
+ return letter, int(number)
+ if not letter and number:
+ # We assume if we are given a number, but we are not given a letter
+ # then this is using the implicit post release syntax (e.g. 1.0-1)
+ letter = "post"
+
+ return letter, int(number)
+
+
+_local_version_seperators = re.compile(r"[\._-]")
+
+
+def _parse_local_version(local):
+ """
+ Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
+ """
+ if local is not None:
+ return tuple(
+ part.lower() if not part.isdigit() else int(part)
+ for part in _local_version_seperators.split(local)
+ )
+
+
+def _cmpkey(epoch, release, pre, post, dev, local):
+ # When we compare a release version, we want to compare it with all of the
+ # trailing zeros removed. So we'll use a reverse the list, drop all the now
+ # leading zeros until we come to something non zero, then take the rest
+ # re-reverse it back into the correct order and make it a tuple and use
+ # that for our sorting key.
+ release = tuple(
+ reversed(list(
+ itertools.dropwhile(
+ lambda x: x == 0,
+ reversed(release),
+ )
+ ))
+ )
+
+ # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
+ # We'll do this by abusing the pre segment, but we _only_ want to do this
+ # if there is not a pre or a post segment. If we have one of those then
+ # the normal sorting rules will handle this case correctly.
+ if pre is None and post is None and dev is not None:
+ pre = -Infinity
+ # Versions without a pre-release (except as noted above) should sort after
+ # those with one.
+ elif pre is None:
+ pre = Infinity
+
+ # Versions without a post segment should sort before those with one.
+ if post is None:
+ post = -Infinity
+
+ # Versions without a development segment should sort after those with one.
+ if dev is None:
+ dev = Infinity
+
+ if local is None:
+ # Versions without a local segment should sort before those with one.
+ local = -Infinity
+ else:
+ # Versions with a local segment need that segment parsed to implement
+ # the sorting rules in PEP440.
+ # - Alpha numeric segments sort before numeric segments
+ # - Alpha numeric segments sort lexicographically
+ # - Numeric segments sort numerically
+ # - Shorter versions sort before longer versions when the prefixes
+ # match exactly
+ local = tuple(
+ (i, "") if isinstance(i, int) else (-Infinity, i)
+ for i in local
+ )
+
+ return epoch, release, pre, post, dev, local
diff --git a/mamonsu/lib/zbx_template.py b/mamonsu/lib/zbx_template.py
index bceb9e33..4b6fe260 100644
--- a/mamonsu/lib/zbx_template.py
+++ b/mamonsu/lib/zbx_template.py
@@ -1,5 +1,6 @@
# -*- coding: utf-8 -*-
import re
+
import mamonsu.lib.platform as platform
from mamonsu.lib.const import Template
from mamonsu.lib.plugin import Plugin
@@ -32,8 +33,8 @@ class ZbxTemplate(object):
{items}
{discovery_rules}
- {screens}
{macros}
+ {screens}
{triggers}
@@ -172,15 +173,14 @@ def xml(self, plg_type, plugins=None):
self.plg_type = plg_type
# create template
template_data = {'template': self.Template, 'application': self.Application}
- if Plugin.Type == 'agent':
- template_data['macros'] = self._macro()
- else:
- template_data['macros'] = ""
- template_data['triggers'] = self._get_all('triggers', plugins)
template_data['items'] = self._get_all('items', plugins)
- template_data['graphs'] = self._get_all('graphs', plugins)
template_data['discovery_rules'] = self._get_all('discovery_rules', plugins)
+ template_data['macros'] = self._get_all('macros', plugins)
+ if Plugin.Type == 'agent':
+ template_data['macros'] += self.agent_macro()
template_data['screens'] = self.screen(plugins)
+ template_data['triggers'] = self._get_all('triggers', plugins)
+ template_data['graphs'] = self._get_all('graphs', plugins)
output_xml = self.mainTemplate.format(**template_data)
if Plugin.Type == 'agent':
output_xml = ZbxTemplate.turn_agent_type(self, output_xml)
@@ -300,14 +300,21 @@ def screen(self, plugins=None, xml_key='screen'):
xml_key)
return result
- def _macro(self, xml_key='macro'):
+ def agent_macro(self, xml_key='macro'):
result = ''
- value = {'value': '-qAt -p 5433 -U postgres ', 'macro': "{$PG_CONNINFO}"}
+ value = {'value': '-qAt -p 5432 -U postgres ', 'macro': "{$PG_CONNINFO}"}
result += '<{1}>{0}'.format(self._format_args(self.macro_defaults, value), xml_key)
- value = {'value': '/opt/pgpro/std-10/bin/psql', 'macro': "{$PG_PATH}"}
+ value = {'value': '/usr/bin/psql', 'macro': "{$PG_PATH}"}
result += '<{1}>{0}'.format(self._format_args(self.macro_defaults, value), xml_key)
return result
+ def mamonsu_macro(self, args=None, xml_key='macro', defaults=None):
+ if args is None:
+ args = {}
+ if defaults is None:
+ defaults = self.macro_defaults
+ return '<{1}>{0}'.format(self._format_args(defaults, args), xml_key)
+
def item(self, args=None, xml_key='item', prototype=False):
if args is None:
args = {}
diff --git a/mamonsu/plugins/common/health.py b/mamonsu/plugins/common/health.py
index 2013ed2f..abd4f7d6 100644
--- a/mamonsu/plugins/common/health.py
+++ b/mamonsu/plugins/common/health.py
@@ -9,8 +9,9 @@ class Health(Plugin):
AgentPluginType = "sys"
- DEFAULT_CONFIG = {
- "max_memory_usage": str(40 * 1024 * 1024)
+ # key: (macro, value)
+ plugin_macros = {
+ "mamonsu_max_memory_usage": [("macro", "{$MAMONSU_MAX_MEMORY_USAGE}"), ("value", 40 * 1024 * 1024)]
}
counter = 0
@@ -52,24 +53,32 @@ def items(self, template, dashboard=False):
else:
return []
+ def macros(self, template, dashboard=False):
+ result = ""
+ for macro in self.plugin_macros.keys():
+ result += template.mamonsu_macro(defaults=self.plugin_macros[macro])
+ if not dashboard:
+ return result
+ else:
+ return []
+
def triggers(self, template, dashboard=False):
if self.Type == "mamonsu":
result = template.trigger({
- "name": "Mamonsu plugin errors on {HOSTNAME}. {ITEM.LASTVALUE}",
+ "name": "Mamonsu health: plugin errors on {HOSTNAME}. {ITEM.LASTVALUE}",
"expression": "{#TEMPLATE:mamonsu.plugin.errors[].strlen()}>1"
}) + template.trigger({
- "name": "Mamonsu nodata from {HOSTNAME}",
+ "name": "Mamonsu health: nodata from {HOSTNAME}",
"expression": "{#TEMPLATE:" + self.right_type("mamonsu.plugin.keepalive{0}") + ".nodata(180)}=1"
})
if platform.LINUX:
result += template.trigger({
- "name": "Mamonsu agent memory usage alert on {HOSTNAME}: {ITEM.LASTVALUE} bytes",
- "expression": "{#TEMPLATE:mamonsu.memory.rss[max].last()}>" + self.plugin_config(
- "max_memory_usage")
+ "name": "Mamonsu health: agent memory usage alert on {HOSTNAME}: {ITEM.LASTVALUE} bytes",
+ "expression": "{#TEMPLATE:mamonsu.memory.rss[max].last()}>" + self.plugin_macros["mamonsu_max_memory_usage"][0][1]
})
else:
result = template.trigger({
- "name": "Mamonsu nodata from {HOSTNAME}",
+ "name": "Mamonsu health: nodata from {HOSTNAME}",
"expression": "{#TEMPLATE:" + self.right_type("mamonsu.plugin.keepalive{0}") + ".nodata(180)}=1"
})
return result
diff --git a/mamonsu/plugins/pgsql/__init__.py b/mamonsu/plugins/pgsql/__init__.py
index 6612b09d..ab3f71e6 100644
--- a/mamonsu/plugins/pgsql/__init__.py
+++ b/mamonsu/plugins/pgsql/__init__.py
@@ -6,6 +6,7 @@
__all__ += ['checkpoint', 'oldest', 'pg_locks']
__all__ += ['cfs']
__all__ += ['archive_command']
+__all__ += ['autovacuum']
__all__ += ['prepared_transaction']
__all__ += ['relations_size']
diff --git a/mamonsu/plugins/pgsql/archive_command.py b/mamonsu/plugins/pgsql/archive_command.py
index 8c897c4c..50009daa 100644
--- a/mamonsu/plugins/pgsql/archive_command.py
+++ b/mamonsu/plugins/pgsql/archive_command.py
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
from mamonsu.plugins.pgsql.plugin import PgsqlPlugin as Plugin
-from distutils.version import LooseVersion
from .pool import Pooler
from mamonsu.lib.zbx_template import ZbxTemplate
import re
@@ -9,11 +8,13 @@
class ArchiveCommand(Plugin):
AgentPluginType = "pg"
- DEFAULT_CONFIG = {
- "max_count_files": str(2)
- }
Interval = 60
+ # key: (macro, value)
+ plugin_macros = {
+ "archive_queue_files": [("macro", "{$ARCHIVE_QUEUE_FILES}"), ("value", 2)]
+ }
+
# if streaming replication is on, archive queue length and size will always be 0 for replicas
query_agent_count_files = """
WITH values AS (
@@ -44,7 +45,7 @@ class ArchiveCommand(Plugin):
('x' || substring(pg_{1}_name(pg_current_{0}()) from 17 for 8))::bit(32)::int END AS current_wal_mod
FROM pg_settings, pg_stat_archiver
WHERE pg_settings.name = 'wal_segment_size')
- greatest(coalesce(((segment_parts_count - last_wal_mod) + ((current_wal_div - last_wal_div - 1) * segment_parts_count) + current_wal_mod - 1) * segment_size, 0), 0)::bigint AS size_files
+ SELECT greatest(coalesce(((segment_parts_count - last_wal_mod) + ((current_wal_div - last_wal_div - 1) * segment_parts_count) + current_wal_mod - 1) * segment_size, 0), 0)::bigint AS size_files
FROM values;
"""
@@ -57,10 +58,12 @@ class ArchiveCommand(Plugin):
key = "pgsql.archive_command{0}"
Items = [
# key, desc, color, side, graph, delta, units
- ("count_files_to_archive", "Files in archive_status Need to Archive Count", "006AAE", 0, 1, Plugin.DELTA.as_is, Plugin.UNITS.none),
+ ("count_files_to_archive", "Files in archive_status Need to Archive Count", "006AAE", 0, 1, Plugin.DELTA.as_is,
+ Plugin.UNITS.none),
("size_files_to_archive", "Files Need to Archive Size", "793F5D", 0, 0, Plugin.DELTA.as_is, Plugin.UNITS.bytes),
("archived_files", "Archived Files Count", "00CC00", 0, 1, Plugin.DELTA.simple_change, Plugin.UNITS.none),
- ("failed_trying_to_archive", "Attempts to Archive Files Count", "FF5656", 0, 1, Plugin.DELTA.simple_change, Plugin.UNITS.none),
+ ("failed_trying_to_archive", "Attempts to Archive Files Count", "FF5656", 0, 1, Plugin.DELTA.simple_change,
+ Plugin.UNITS.none),
]
old_archived_count = None
old_failed_count = None
@@ -177,30 +180,40 @@ def graphs(self, template, dashboard=False):
"position": 1}
}]
+ def macros(self, template, dashboard=False):
+ result = ""
+ for macro in self.plugin_macros.keys():
+ result += template.mamonsu_macro(defaults=self.plugin_macros[macro])
+ if not dashboard:
+ return result
+ else:
+ return []
+
def triggers(self, template, dashboard=False):
return template.trigger({
"name": "PostgreSQL Archiver: count files need to archive on {HOSTNAME} more than 2",
"expression": "{#TEMPLATE:" + self.right_type(self.key,
- self.Items[0][0]) + ".last()}>" + self.plugin_config(
- "max_count_files")
+ self.Items[0][0]) + ".last()}>" +
+ self.plugin_macros["archive_queue_files"][0][1]
})
def keys_and_queries(self, template_zabbix):
result = []
- if LooseVersion(self.VersionPG) >= LooseVersion("10"):
+ if Pooler.server_version_greater("10"):
result.append("{0}[*],$2 $1 -c \"{1}\"".format(self.key.format("." + self.Items[0][0]),
- self.query_agent_count_files.format("wal_lsn", "walfile")))
+ self.query_agent_count_files.format("wal_lsn",
+ "walfile")))
result.append("{0}[*],$2 $1 -c \"{1}\"".format(self.key.format("." + self.Items[1][0]),
- self.query_agent_size_files.format("wal_lsn", "walfile")))
+ self.query_agent_size_files.format("wal_lsn", "walfile")))
else:
result.append("{0}[*],$2 $1 -c \"{1}\"".format(self.key.format("." + self.Items[0][0]),
- self.query_agent_count_files.format("xlog_location",
- "xlogfile")))
+ self.query_agent_count_files.format("xlog_location",
+ "xlogfile")))
result.append("{0}[*],$2 $1 -c \"{1}\"".format(self.key.format("." + self.Items[1][0]),
- self.query_agent_size_files.format("xlog_location",
- "xlogfile")))
+ self.query_agent_size_files.format("xlog_location",
+ "xlogfile")))
result.append("{0}[*],$2 $1 -c \"{1}\"".format(self.key.format("." + self.Items[2][0]),
- self.query_agent_archived_count))
+ self.query_agent_archived_count))
result.append("{0}[*],$2 $1 -c \"{1}\"".format(self.key.format("." + self.Items[3][0]),
- self.query_agent_failed_count))
+ self.query_agent_failed_count))
return template_zabbix.key_and_query(result)
diff --git a/mamonsu/plugins/pgsql/autovacuum.py b/mamonsu/plugins/pgsql/autovacuum.py
new file mode 100644
index 00000000..01266ac7
--- /dev/null
+++ b/mamonsu/plugins/pgsql/autovacuum.py
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+from mamonsu.plugins.pgsql.plugin import PgsqlPlugin as Plugin
+from .pool import Pooler
+from mamonsu.lib.zbx_template import ZbxTemplate
+
+
+class Autovacuum(Plugin):
+ AgentPluginType = "pg"
+ # TODO: unify keys and remove its direct mentioning in zbx.send() functions
+ key_count = "pgsql.autovacuum.count{0}"
+ key_utilization = "pgsql.autovacuum.utilization{0}"
+ key_utilization_avg5 = "pgsql.autovacuum.utilization.avg5{0}"
+ key_utilization_avg15 = "pgsql.autovacuum.utilization.avg15{0}"
+ key_utilization_avg30 = "pgsql.autovacuum.utilization.avg30{0}"
+
+ DEFAULT_CONFIG = {
+ "interval": str(60)
+ }
+
+ def run(self, zbx):
+ if Pooler.server_version_greater("10.0"):
+ result_count = Pooler.run_sql_type("count_autovacuum", args=["backend_type = 'autovacuum worker'"])
+ result_utilization = Pooler.run_sql_type("autovacuum_utilization",
+ args=["backend_type = 'autovacuum worker'"])
+ else:
+ result_count = Pooler.run_sql_type("count_autovacuum", args=[
+ "query LIKE '%%autovacuum%%' AND state <> 'idle' AND pid <> pg_catalog.pg_backend_pid()"])
+ result_utilization = Pooler.run_sql_type("autovacuum_utilization", args=[
+ "query LIKE '%%autovacuum%%' AND state <> 'idle' AND pid <> pg_catalog.pg_backend_pid()"])
+ zbx.send("pgsql.autovacuum.count[]", int(result_count[0][0]))
+ zbx.send("pgsql.autovacuum.utilization[]", int(result_utilization[0][0]))
+
+ def items(self, template, dashboard=False):
+ result = ""
+ if not dashboard:
+ result += (template.item({
+ "name": "PostgreSQL Autovacuum: Count of Autovacuum Workers",
+ "key": self.right_type(self.key_count),
+ "delay": self.plugin_config("interval")
+ }))
+ result += (template.item({
+ "name": "PostgreSQL Autovacuum: Utilization per {0} seconds".format(self.plugin_config("interval")),
+ "key": self.right_type(self.key_utilization),
+ "value_type": Plugin.VALUE_TYPE.numeric_float,
+ "units": Plugin.UNITS.percent,
+ "delay": self.plugin_config("interval")
+ }))
+ result += (template.item({
+ "name": "PostgreSQL Autovacuum: Average Utilization per 5 minutes",
+ "key": self.right_type(self.key_utilization_avg5),
+ "value_type": Plugin.VALUE_TYPE.numeric_float,
+ "units": Plugin.UNITS.percent,
+ "type": Plugin.TYPE.CALCULATED,
+ "params": "avg(//{item}, 5m)".format(item=self.right_type(self.key_utilization)),
+ "delay": self.plugin_config("interval")
+ }))
+ result += (template.item({
+ "name": "PostgreSQL Autovacuum: Average Utilization per 15 minutes",
+ "key": self.right_type(self.key_utilization_avg15),
+ "value_type": Plugin.VALUE_TYPE.numeric_float,
+ "units": Plugin.UNITS.percent,
+ "type": Plugin.TYPE.CALCULATED,
+ "params": "avg(//{item}, 15m)".format(item=self.right_type(self.key_utilization)),
+ "delay": self.plugin_config("interval")
+ }))
+ result += (template.item({
+ "name": "PostgreSQL Autovacuum: Average Utilization per 30 minutes",
+ "key": self.right_type(self.key_utilization_avg30),
+ "value_type": Plugin.VALUE_TYPE.numeric_float,
+ "units": Plugin.UNITS.percent,
+ "type": Plugin.TYPE.CALCULATED,
+ "params": "avg(//{item}, 30m)".format(item=self.right_type(self.key_utilization)),
+ "delay": self.plugin_config("interval")
+ }))
+ return result
+ else:
+ return []
+
+ def graphs(self, template, dashboard=False):
+ result = template.graph({
+ "name": "PostgreSQL Autovacuum: Count of Autovacuum Workers",
+ "items": [{
+ "key": self.right_type(self.key_count),
+ "color": "87C2B9",
+ "drawtype": 2
+ }]
+ })
+ if not dashboard:
+ return result
+ else:
+ return [{
+ "dashboard": {"name": "PostgreSQL Autovacuum: Count of Autovacuum Workers",
+ "page": ZbxTemplate.dashboard_page_overview["name"],
+ "size": ZbxTemplate.dashboard_widget_size_medium,
+ "position": 5}
+ }]
+
+ def keys_and_queries(self, template_zabbix):
+ result = []
+ if Pooler.server_version_greater("10"):
+ # TODO: define another metric key because it duplicates native zabbix agents keys
+ # result.append("{0},$2 $1 -c \"{1}\"".format(self.key_count.format("[*]"),
+ # Pooler.SQL["count_autovacuum"][0].format(
+ # "backend_type = 'autovacuum worker'")))
+ result.append("{0},$2 $1 -c \"{1}\"".format(self.key_utilization.format("[*]"),
+ Pooler.SQL["autovacuum_utilization"][0].format(
+ "backend_type = 'autovacuum worker'")))
+ else:
+ # TODO: define another metric key because it duplicates native zabbix agents keys
+ # result.append("{0},$2 $1 -c \"{1}\"".format(self.key_count.format("[*]"),
+ # Pooler.SQL["count_autovacuum"][0].format(
+ # "query LIKE '%%autovacuum%%' AND state <> 'idle' AND pid <> pg_catalog.pg_backend_pid()")))
+ result.append("{0},$2 $1 -c \"{1}\"".format(self.key_utilization.format("[*]"),
+ Pooler.SQL["autovacuum_utilization"][0].format(
+ "query LIKE '%%autovacuum%%' AND state <> 'idle' AND pid <> pg_catalog.pg_backend_pid()")))
+ return template_zabbix.key_and_query(result)
diff --git a/mamonsu/plugins/pgsql/bgwriter.py b/mamonsu/plugins/pgsql/bgwriter.py
index d24ffaae..9615b705 100644
--- a/mamonsu/plugins/pgsql/bgwriter.py
+++ b/mamonsu/plugins/pgsql/bgwriter.py
@@ -12,43 +12,68 @@ class BgWriter(Plugin):
SELECT {0}
FROM pg_catalog.pg_stat_bgwriter;
"""
- Items = [
- # key, zbx_key, description,
- # ('graph name', color, side), units, delta
-
- ("buffers_checkpoint", "bgwriter[buffers_checkpoint]",
- "Buffers Written During Checkpoints",
- ("PostgreSQL bgwriter", "006AAE", 1),
- Plugin.DELTA.simple_change),
-
- ("buffers_clean", "bgwriter[buffers_clean]",
- "Buffers Written",
- ("PostgreSQL bgwriter", "00CC00", 1),
- Plugin.DELTA.simple_change),
-
- ("maxwritten_clean", "bgwriter[maxwritten_clean]",
- "Number of bgwriter Stopped by Max Write Count",
- ("PostgreSQL bgwriter", "FF5656", 0),
- Plugin.DELTA.simple_change),
-
- ("buffers_backend", "bgwriter[buffers_backend]",
- "Buffers Written Directly by a Backend",
- ("PostgreSQL bgwriter", "9C8A4E", 1),
- Plugin.DELTA.simple_change),
-
- ("buffers_backend_fsync", "bgwriter[buffers_backend_fsync]",
- "Times a Backend Execute Its Own Fsync",
- ("PostgreSQL bgwriter", "00CC00", 0),
- Plugin.DELTA.simple_change),
-
- ("buffers_alloc", "bgwriter[buffers_alloc]",
- "Buffers Allocated",
- ("PostgreSQL bgwriter", "FF5656", 1),
- Plugin.DELTA.simple_change)
- ]
graph_name_buffers = "PostgreSQL bgwriter: Buffers"
- graph_name_ws = "PostgreSQL bgwriter: Events"
+ graph_name_ws = "PostgreSQL bgwriter: Write/Sync"
+
+ def __init__(self, config):
+ super(BgWriter, self).__init__(config)
+ if self.is_enabled():
+ if Pooler.server_version_less("17"):
+ self.Items = [
+ # key, zbx_key, description,
+ # ('graph name', color, side), units, delta
+
+ ("buffers_checkpoint", "bgwriter[buffers_checkpoint]",
+ "Buffers Written During Checkpoints",
+ ("PostgreSQL bgwriter", "006AAE", 1),
+ Plugin.DELTA.simple_change),
+
+ ("buffers_clean", "bgwriter[buffers_clean]",
+ "Buffers Written",
+ ("PostgreSQL bgwriter", "00CC00", 1),
+ Plugin.DELTA.simple_change),
+
+ ("maxwritten_clean", "bgwriter[maxwritten_clean]",
+ "Number of bgwriter Stopped by Max Write Count",
+ ("PostgreSQL bgwriter", "FF5656", 0),
+ Plugin.DELTA.simple_change),
+
+ ("buffers_backend", "bgwriter[buffers_backend]",
+ "Buffers Written Directly by a Backend",
+ ("PostgreSQL bgwriter", "9C8A4E", 1),
+ Plugin.DELTA.simple_change),
+
+ ("buffers_backend_fsync", "bgwriter[buffers_backend_fsync]",
+ "Times a Backend Execute Its Own Fsync",
+ ("PostgreSQL bgwriter", "00CC00", 0),
+ Plugin.DELTA.simple_change),
+
+ ("buffers_alloc", "bgwriter[buffers_alloc]",
+ "Buffers Allocated",
+ ("PostgreSQL bgwriter", "FF5656", 1),
+ Plugin.DELTA.simple_change)
+ ]
+ else:
+ self.Items = [
+ # key, zbx_key, description,
+ # ('graph name', color, side), units, delta
+
+ ("buffers_clean", "bgwriter[buffers_clean]",
+ "Buffers Written",
+ ("PostgreSQL bgwriter", "00CC00", 1),
+ Plugin.DELTA.simple_change),
+
+ ("maxwritten_clean", "bgwriter[maxwritten_clean]",
+ "Number of bgwriter Stopped by Max Write Count",
+ ("PostgreSQL bgwriter", "FF5656", 0),
+ Plugin.DELTA.simple_change),
+
+ ("buffers_alloc", "bgwriter[buffers_alloc]",
+ "Buffers Allocated",
+ ("PostgreSQL bgwriter", "FF5656", 1),
+ Plugin.DELTA.simple_change)
+ ]
def run(self, zbx):
columns = [x[0] for x in self.Items]
@@ -119,5 +144,6 @@ def keys_and_queries(self, template_zabbix):
result = []
for item in self.Items:
# delete from key '[' and ']' in Item for zabbix agent
- result.append("{0}[*],$2 $1 -c \"{1}\"".format(self.key.format("." + item[0]), self.query.format(item[0])))
+ result.append(
+ "{0}[*],$2 $1 -c \"{1}\"".format(self.key.format("." + item[0]), self.query.format(item[0])))
return template_zabbix.key_and_query(result)
diff --git a/mamonsu/plugins/pgsql/checkpoint.py b/mamonsu/plugins/pgsql/checkpoint.py
index 78a0e1c9..c1ca9acc 100644
--- a/mamonsu/plugins/pgsql/checkpoint.py
+++ b/mamonsu/plugins/pgsql/checkpoint.py
@@ -9,48 +9,84 @@ class Checkpoint(Plugin):
AgentPluginType = "pg"
Interval = 60 * 5
- query = """
- SELECT {0}
- FROM pg_catalog.pg_stat_bgwriter;
- """ # for mamonsu and agent
- query_interval = """
- SELECT {0}*3600
- FROM pg_catalog.pg_stat_bgwriter;
- """ # for mamonsu and agent checkpoints in hour
key = "pgsql.checkpoint{0}"
- DEFAULT_CONFIG = {
- "max_checkpoint_by_wal_in_hour": str(12)
+ # key: (macro, value)
+ plugin_macros = {
+ "max_checkpoint_by_wal_in_hour": [("macro", "{$MAX_CHECKPOINT_BY_WAL_IN_HOUR}"), ("value", 12)]
}
- Items = [
- # key, zbx_key, description,
- # ('graph name', color, side), units, delta, factor
-
- ("checkpoints_timed", "count_timed",
- "by Timeout (in hour)",
- ("PostgreSQL Checkpoints: Count (in hour)", "00CC00", 0),
- Plugin.UNITS.none, Plugin.DELTA.speed_per_second, 60 * 60),
-
- ("checkpoints_req", "count_wal",
- "by WAL (in hour)",
- ("PostgreSQL Checkpoints: Count (in hour)", "FF5656", 0),
- Plugin.UNITS.none, Plugin.DELTA.speed_per_second, 60 * 60),
-
- ("checkpoint_write_time", "write_time",
- "Write Time",
- ("PostgreSQL Checkpoints: Write/Sync", "00CC00", 1),
- Plugin.UNITS.ms, Plugin.DELTA.speed_per_second, 1),
-
- ("checkpoint_sync_time", "checkpoint_sync_time",
- "Sync Time",
- ("PostgreSQL Checkpoints: Write/Sync", "FF5656", 1),
- Plugin.UNITS.ms, Plugin.DELTA.speed_per_second, 1)
- ]
-
graph_name_count = "PostgreSQL Checkpoints: Count (in hour)"
graph_name_ws = "PostgreSQL Checkpoints: Write/Sync"
+ def __init__(self, config):
+ super(Checkpoint, self).__init__(config)
+ if self.is_enabled():
+ if Pooler.server_version_less("17"):
+ self.query = """
+ SELECT {0}
+ FROM pg_catalog.pg_stat_bgwriter;
+ """ # for mamonsu and agent
+ self.query_interval = """
+ SELECT {0}*3600
+ FROM pg_catalog.pg_stat_bgwriter;
+ """ # for mamonsu and agent checkpoints in hour
+ self.Items = [
+ # key, zbx_key, description,
+ # ('graph name', color, side), units, delta, factor
+ ("checkpoints_timed", "count_timed",
+ "by Timeout (in hour)",
+ ("PostgreSQL Checkpoints: Count (in hour)", "00CC00", 0),
+ Plugin.UNITS.none, Plugin.DELTA.speed_per_second, 60 * 60),
+
+ ("checkpoints_req", "count_wal",
+ "by WAL (in hour)",
+ ("PostgreSQL Checkpoints: Count (in hour)", "FF5656", 0),
+ Plugin.UNITS.none, Plugin.DELTA.speed_per_second, 60 * 60),
+
+ ("checkpoint_write_time", "write_time",
+ "Write Time",
+ ("PostgreSQL Checkpoints: Write/Sync", "00CC00", 1),
+ Plugin.UNITS.ms, Plugin.DELTA.speed_per_second, 1),
+
+ ("checkpoint_sync_time", "checkpoint_sync_time",
+ "Sync Time",
+ ("PostgreSQL Checkpoints: Write/Sync", "FF5656", 1),
+ Plugin.UNITS.ms, Plugin.DELTA.speed_per_second, 1)
+ ]
+ else:
+ self.query = """
+ SELECT {0}
+ FROM pg_catalog.pg_stat_checkpointer;
+ """ # for mamonsu and agent
+ self.query_interval = """
+ SELECT {0}*3600
+ FROM pg_catalog.pg_stat_checkpointer;
+ """ # for mamonsu and agent checkpoints in hour
+ self.Items = [
+ # key, zbx_key, description,
+ # ('graph name', color, side), units, delta, factor
+ ("num_timed", "count_timed",
+ "by Timeout (in hour)",
+ ("PostgreSQL Checkpoints: Count (in hour)", "00CC00", 0),
+ Plugin.UNITS.none, Plugin.DELTA.speed_per_second, 60 * 60),
+
+ ("num_requested", "count_wal",
+ "by WAL (in hour)",
+ ("PostgreSQL Checkpoints: Count (in hour)", "FF5656", 0),
+ Plugin.UNITS.none, Plugin.DELTA.speed_per_second, 60 * 60),
+
+ ("write_time", "write_time",
+ "Write Time",
+ ("PostgreSQL Checkpoints: Write/Sync", "00CC00", 1),
+ Plugin.UNITS.ms, Plugin.DELTA.speed_per_second, 1),
+
+ ("sync_time", "checkpoint_sync_time",
+ "Sync Time",
+ ("PostgreSQL Checkpoints: Write/Sync", "FF5656", 1),
+ Plugin.UNITS.ms, Plugin.DELTA.speed_per_second, 1)
+ ]
+
def run(self, zbx):
columns = [x[0] for x in self.Items]
result = Pooler.query(self.query.format(", ".join(columns)))
@@ -100,8 +136,8 @@ def graphs(self, template, dashboard=False):
"name": self.graph_name_count,
"items": items_checkpoints
}) + template.graph({
- "name": self.graph_name_ws,
- "items": items_checkpoints_write_sync
+ "name": self.graph_name_ws,
+ "items": items_checkpoints_write_sync
})
if not dashboard:
return result
@@ -119,12 +155,21 @@ def graphs(self, template, dashboard=False):
"position": 10}
}]
+ def macros(self, template, dashboard=False):
+ result = ""
+ for macro in self.plugin_macros.keys():
+ result += template.mamonsu_macro(defaults=self.plugin_macros[macro])
+ if not dashboard:
+ return result
+ else:
+ return []
+
def triggers(self, template, dashboard=False):
return template.trigger({
"name": "PostgreSQL Checkpoints: required checkpoints occurs too frequently on {HOSTNAME}",
"expression": "{#TEMPLATE:" + self.right_type(self.key,
- self.Items[1][1]) + ".last()}>" + self.plugin_config(
- "max_checkpoint_by_wal_in_hour")
+ self.Items[1][1]) + ".last()}>" +
+ self.plugin_macros["max_checkpoint_by_wal_in_hour"][0][1]
})
def keys_and_queries(self, template_zabbix):
diff --git a/mamonsu/plugins/pgsql/connections.py b/mamonsu/plugins/pgsql/connections.py
index 8d277e2f..6a214da3 100644
--- a/mamonsu/plugins/pgsql/connections.py
+++ b/mamonsu/plugins/pgsql/connections.py
@@ -1,16 +1,15 @@
# -*- coding: utf-8 -*-
from mamonsu.plugins.pgsql.plugin import PgsqlPlugin as Plugin
-from distutils.version import LooseVersion
from .pool import Pooler
from mamonsu.lib.zbx_template import ZbxTemplate
class Connections(Plugin):
AgentPluginType = "pg"
- # (state, key, name, graph)
- DEFAULT_CONFIG = {
- "percent_connections_tr": str(90)
+ # key: (macro, value)
+ plugin_macros = {
+ "connections_percent": [("macro", "{$CONNECTIONS_PERCENT}"), ("value", 90)]
}
# (state, key, name, graph item color)
Items = [
@@ -38,8 +37,6 @@ class Connections(Plugin):
WHERE (backend_type NOT IN ('{0}'));
""".format("', '".join(default_backend_types))
- Max_connections = None
-
query_agent = """
SELECT count(*)
FROM pg_catalog.pg_stat_activity
@@ -126,14 +123,13 @@ def run(self, zbx):
"(backend_type = 'client backend' OR backend_type = 'parallel worker')" if Pooler.server_version_greater(
"10.0") else "state IS NOT NULL"))
zbx.send("pgsql.connections[waiting]", int(result[0][0]))
- if self.Max_connections is None:
- result = Pooler.query("""
- SELECT setting
- FROM pg_settings
- WHERE name = 'max_connections';
- """)
- self.Max_connections = result[0][0]
- zbx.send("pgsql.connections[max_connections]", int(self.Max_connections))
+
+ result = Pooler.query("""
+ SELECT setting
+ FROM pg_settings
+ WHERE name = 'max_connections';
+ """)
+ zbx.send("pgsql.connections[max_connections]", int(result[0][0]))
if Pooler.server_version_greater("10.0"):
result = Pooler.query(self.query_other_connections)
@@ -217,43 +213,45 @@ def graphs(self, template, dashboard=False):
"position": 1}
}]
+ def macros(self, template, dashboard=False):
+ result = ""
+ for macro in self.plugin_macros.keys():
+ result += template.mamonsu_macro(defaults=self.plugin_macros[macro])
+ if not dashboard:
+ return result
+ else:
+ return []
+
def triggers(self, template, dashboard=False):
return template.trigger({
- "name": "PostgreSQL Connections: too many connections on {HOSTNAME} (total connections more than " + self.plugin_config(
- "percent_connections_tr") + "% of max_connections)",
+ "name": "PostgreSQL Connections: too many connections on {HOSTNAME} (total connections more than " +
+ self.plugin_macros["connections_percent"][0][1] + "% of max_connections)",
"expression": " {#TEMPLATE:" + self.right_type(self.key,
"total") + ".last()}/{#TEMPLATE:" + self.right_type(self.key,
- "max_connections") + ".last()}*100 >" + self.plugin_config(
- "percent_connections_tr")
+ "max_connections") + ".last()}*100 >" +
+ self.plugin_macros["connections_percent"][0][1]
})
def keys_and_queries(self, template_zabbix):
result = []
for item in self.Items:
result.append("{0}[*],$2 $1 -c \"{1}\"".format(self.key.format("." + item[1]),
- self.query_agent.format(item[1],
- "AND (backend_type = 'client backend' OR backend_type = 'parallel worker')" if LooseVersion(
- self.VersionPG) >= LooseVersion(
- "10") else "")))
+ self.query_agent.format(item[1],
+ "AND (backend_type = 'client backend' OR backend_type = 'parallel worker')" if Pooler.server_version_greater("10") else "")))
result.append("{0}[*],$2 $1 -c \"{1}\"".format(self.key.format(".total"), self.query_agent_total.format(
- "(backend_type = 'client backend' OR backend_type = 'parallel worker')" if LooseVersion(
- self.VersionPG) >= LooseVersion(
- "10") else "state IS NOT NULL")))
- if LooseVersion(self.VersionPG) < LooseVersion("9.6"):
+ "(backend_type = 'client backend' OR backend_type = 'parallel worker')" if Pooler.server_version_greater("10") else "state IS NOT NULL")))
+ if Pooler.server_version_less("9.5"):
result.append(
"{0}[*],$2 $1 -c \"{1}\"".format(self.key.format(".waiting"), self.query_agent_waiting_old_v.format(
- "(backend_type = 'client backend' OR backend_type = 'parallel worker')" if LooseVersion(
- self.VersionPG) >= LooseVersion(
- "10") else "state IS NOT NULL")))
+ "(backend_type = 'client backend' OR backend_type = 'parallel worker')" if Pooler.server_version_greater("10") else "state IS NOT NULL")))
else:
result.append(
"{0}[*],$2 $1 -c \"{1}\"".format(self.key.format(".waiting"), self.query_agent_waiting_new_v.format(
- "(backend_type = 'client backend' OR backend_type = 'parallel worker')" if LooseVersion(
- self.VersionPG) >= LooseVersion(
- "10") else "state IS NOT NULL")))
- if LooseVersion(self.VersionPG) >= LooseVersion("10"):
+ "(backend_type = 'client backend' OR backend_type = 'parallel worker')" if Pooler.server_version_greater("10") else "state IS NOT NULL")))
+ if Pooler.server_version_greater("10"):
result.append("{0}[*],$2 $1 -c \"{1}\"".format(self.key.format(".other"),
- self.query_other_connections.format(
- "', '".join(self.default_backend_types))))
- result.append("{0}[*],$2 $1 -c \"{1}\"".format(self.key.format(".max_connections"), self.query_agent_max_conn))
+ self.query_other_connections.format(
+ "', '".join(self.default_backend_types))))
+ result.append(
+ "{0}[*],$2 $1 -c \"{1}\"".format(self.key.format(".max_connections"), self.query_agent_max_conn))
return template_zabbix.key_and_query(result)
diff --git a/mamonsu/plugins/pgsql/databases.py b/mamonsu/plugins/pgsql/databases.py
index 3659c7bb..15db1c3c 100644
--- a/mamonsu/plugins/pgsql/databases.py
+++ b/mamonsu/plugins/pgsql/databases.py
@@ -1,9 +1,8 @@
# -*- coding: utf-8 -*-
-from distutils.version import LooseVersion
from mamonsu.plugins.pgsql.plugin import PgsqlPlugin as Plugin
from .pool import Pooler
-from mamonsu.lib.zbx_template import ZbxTemplate
+from mamonsu.plugins.pgsql.autovacuum import Autovacuum
class Databases(Plugin):
@@ -50,7 +49,6 @@ class Databases(Plugin):
key_db_size = "pgsql.database.size{0}"
key_db_age = "pgsql.database.max_age{0}"
key_db_bloating_tables = "pgsql.database.bloating_tables{0}"
- key_autovacumm = "pgsql.autovacumm.count{0}"
key_invalid_indexes = "pgsql.database.invalid_indexes{0}"
DEFAULT_CONFIG = {
@@ -81,42 +79,6 @@ def run(self, zbx):
zbx.send("pgsql.database.discovery[]", zbx.json({"data": dbs}))
del dbs, bloat_count, invalid_indexes_count
- if Pooler.server_version_greater("10.0"):
- result = Pooler.run_sql_type("count_autovacuum", args=["backend_type = 'autovacuum worker'"])
- else:
- result = Pooler.run_sql_type("count_autovacuum", args=[
- "query LIKE '%%autovacuum%%' AND state <> 'idle' AND pid <> pg_catalog.pg_backend_pid()"])
- zbx.send("pgsql.autovacumm.count[]", int(result[0][0]))
-
- def items(self, template, dashboard=False):
- if not dashboard:
- return template.item({
- "name": "PostgreSQL Autovacuum: Count of Autovacuum Workers",
- "key": self.right_type(self.key_autovacumm),
- "delay": self.plugin_config("interval")
- })
- else:
- return []
-
- def graphs(self, template, dashboard=False):
- result = template.graph({
- "name": "PostgreSQL Autovacuum: Count of Autovacuum Workers",
- "items": [{
- "key": self.right_type(self.key_autovacumm),
- "color": "87C2B9",
- "drawtype": 2
- }]
- })
- if not dashboard:
- return result
- else:
- return [{
- "dashboard": {"name": "PostgreSQL Autovacuum: Count of Autovacuum Workers",
- "page": ZbxTemplate.dashboard_page_overview["name"],
- "size": ZbxTemplate.dashboard_widget_size_medium,
- "position": 5}
- }]
-
def discovery_rules(self, template, dashboard=False):
rule = {
"name": "PostgreSQL Databases Discovery",
@@ -137,7 +99,7 @@ def discovery_rules(self, template, dashboard=False):
}]
items = [
{"key": self.right_type(self.key_db_size, var_discovery="{#DATABASE},"),
- "name": "PostgreSQL Databases {#DATABASE}: size",
+ "name": "PostgreSQL Databases: {#DATABASE} size",
"units": Plugin.UNITS.bytes,
"value_type": Plugin.VALUE_TYPE.numeric_unsigned,
"delay": self.plugin_config("interval")},
@@ -166,7 +128,7 @@ def discovery_rules(self, template, dashboard=False):
"key": self.right_type(self.key_db_bloating_tables, var_discovery="{#DATABASE},"),
"drawtype": 2},
{"color": "793F5D",
- "key": self.right_type(self.key_autovacumm),
+ "key": self.right_type(Autovacuum.key_count),
"yaxisside": 1,
"drawtype": 2}]
},
@@ -177,13 +139,13 @@ def discovery_rules(self, template, dashboard=False):
"key": self.right_type(self.key_db_age, var_discovery="{#DATABASE},"),
"drawtype": 2},
{"color": "793F5D",
- "key": self.right_type(self.key_autovacumm),
+ "key": self.right_type(Autovacuum.key_count),
"yaxisside": 1,
"drawtype": 2}]
}]
triggers = [{
"name": "PostgreSQL Databases: invalid indexes in {#DATABASE} (hostname={HOSTNAME} value={ITEM.LASTVALUE})",
- "expression": "{#TEMPLATE:pgsql.database.invalid_indexes[{#DATABASE}].last()}>0"}
+ "expression": "{#TEMPLATE:" + items[3]['key'] + ".last()}>0"}
]
return template.discovery_rule(rule=rule, conditions=conditions, items=items, graphs=graphs, triggers=triggers)
@@ -192,17 +154,9 @@ def keys_and_queries(self, template_zabbix):
"{0},echo \"{1}\" | $3 $2 -v p1=\"$1\"".format(self.key_db_size.format("[*]"), self.query_size),
"{0},echo \"{1}\" | $3 $2 -v p1=\"$1\"".format(self.key_db_age.format("[*]"), self.query_age),
"{0},$3 $2 -d \"$1\" -c \"{1}\"".format(self.key_db_bloating_tables.format("[*]"),
- self.query_bloating_tables.format(
- self.plugin_config("bloat_scale"),
- self.plugin_config("min_rows"))),
+ self.query_bloating_tables.format(
+ self.plugin_config("bloat_scale"),
+ self.plugin_config("min_rows"))),
"{0},$3 $2 -d \"$1\" -c \"{1}\"".format(self.key_invalid_indexes.format("[*]"),
- self.query_invalid_indexes)]
- if LooseVersion(self.VersionPG) >= LooseVersion("10"):
- result.append("{0},$2 $1 -c \"{1}\"".format(self.key_autovacumm.format("[*]"),
- Pooler.SQL["count_autovacuum"][0].format(
- "backend_type = 'autovacuum worker'")))
- else:
- result.append("{0},$2 $1 -c \"{1}\"".format(self.key_autovacumm.format("[*]"),
- Pooler.SQL["count_autovacuum"][0].format(
- "query LIKE '%%autovacuum%%' AND state <> 'idle' AND pid <> pg_catalog.pg_backend_pid()")))
+ self.query_invalid_indexes)]
return template_zabbix.key_and_query(result)
diff --git a/mamonsu/plugins/pgsql/driver/pg8000/core.py b/mamonsu/plugins/pgsql/driver/pg8000/core.py
index d29c627d..b050af67 100755
--- a/mamonsu/plugins/pgsql/driver/pg8000/core.py
+++ b/mamonsu/plugins/pgsql/driver/pg8000/core.py
@@ -2,12 +2,12 @@
from collections import defaultdict, deque
from datetime import datetime as Datetime
from decimal import Decimal
-from distutils.version import LooseVersion
from hashlib import md5
from itertools import count, islice
from struct import Struct
from warnings import warn
+import mamonsu.lib.version as version
from mamonsu.plugins.pgsql.driver.pg8000 import converters
from .exceptions import (
ArrayContentNotSupportedError, DatabaseError, Error, IntegrityError,
@@ -1416,11 +1416,16 @@ def handle_PARAMETER_STATUS(self, data, ps):
pass
elif key == b"server_version":
- self._server_version = LooseVersion(value.decode('ascii'))
- if self._server_version < LooseVersion('8.2.0'):
+ # LooseVersion() from distutils was able to handle non-relevant strings
+ # in version (like "16.2 (Ubuntu 16.2-1.pgdg20.04+1)")
+ # since distutils became deprecated we need this hack hoping that
+ # postgres package maintainers won't come up with something more exotic
+ string_version = value.decode('ascii').split(' ')[0]
+ self._server_version = version.parse(string_version)
+ if self._server_version < version.parse('8.2.0'):
self._commands_with_count = (
b"INSERT", b"DELETE", b"UPDATE", b"MOVE")
- elif self._server_version < LooseVersion('9.0.0'):
+ elif self._server_version < version.parse('9.0.0'):
self._commands_with_count = (
b"INSERT", b"DELETE", b"UPDATE", b"MOVE", b"FETCH",
b"COPY")
diff --git a/mamonsu/plugins/pgsql/driver/pool.py b/mamonsu/plugins/pgsql/driver/pool.py
index 88f5ec79..a8433d98 100644
--- a/mamonsu/plugins/pgsql/driver/pool.py
+++ b/mamonsu/plugins/pgsql/driver/pool.py
@@ -1,6 +1,8 @@
-from distutils.version import LooseVersion
from .connection import Connection, ConnectionInfo
+from mamonsu.lib.version import parse
+import threading
+
class Pool(object):
ExcludeDBs = ["template0", "template1"]
@@ -47,6 +49,25 @@ class Pool(object):
SELECT mamonsu.count_autovacuum();
"""
),
+ "autovacuum_utilization": (
+ """
+ WITH count_tb AS (
+ SELECT count(*)::float AS count
+ FROM pg_catalog.pg_stat_activity
+ WHERE {0}
+ ),
+ settings_tb AS (
+ SELECT setting::float
+ FROM pg_catalog.pg_settings
+ WHERE name = 'autovacuum_max_workers'
+ )
+ SELECT count_tb.count*100/settings_tb.setting
+ FROM count_tb, settings_tb;
+ """,
+ """
+ SELECT mamonsu.autovacuum_utilization();
+ """
+ ),
"buffer_cache": (
"""
SELECT sum(1) * (current_setting('block_size')::int8) AS size,
@@ -65,7 +86,7 @@ class Pool(object):
"""
SELECT application_name,
{0}
- coalesce((pg_{1}_{2}_diff(pg_current_{1}_{2}(), replay_lsn))::int, 0) AS total_lag
+ coalesce((pg_{1}_{2}_diff(pg_current_{1}_{2}(), replay_{2}))::int, 0) AS total_lag
FROM pg_stat_replication;
""",
"""
@@ -74,6 +95,30 @@ class Pool(object):
total_lag
FROM mamonsu.count_{1}_lag_lsn();
"""
+ ),
+ "wal_held_bytes_master": (
+ """
+ SELECT slot_name,
+ coalesce((pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn))::int, 0) AS wal_held_bytes
+ FROM pg_replication_slots;
+ """,
+ """
+ SELECT slot_name,
+ wal_held_bytes
+ FROM mamonsu.bytes_held_by_inactive_slot_on_master();
+ """
+ ),
+ "wal_held_bytes_replica": (
+ """
+ SELECT slot_name,
+ coalesce((pg_wal_lsn_diff(pg_last_wal_replay_lsn(), restart_lsn))::int, 0) AS wal_held_bytes
+ FROM pg_replication_slots;
+ """,
+ """
+ SELECT slot_name,
+ wal_held_bytes
+ FROM mamonsu.bytes_held_by_inactive_slot_on_replica();
+ """
)
}
@@ -88,9 +133,11 @@ def __init__(self, params=None):
"bootstrap": {"storage": {}, "counter": 0, "cache": 10, "version": False},
"recovery": {"storage": {}, "counter": 0, "cache": 10},
"extension_schema": {"pg_buffercache": {}, "pg_stat_statements": {}, "pg_wait_sampling": {}, "pgpro_stats": {}},
+ "extension_versions": {},
"pgpro": {"storage": {}},
"pgproee": {"storage": {}}
}
+ self._lock = threading.RLock()
def connection_string(self, db=None):
db = self._normalize_db(db)
@@ -102,69 +149,88 @@ def query(self, query, db=None):
return self._connections[db].query(query)
def server_version(self, db=None):
- db = self._normalize_db(db)
- if db in self._cache["server_version"]["storage"]:
+ with self._lock:
+ db = self._normalize_db(db)
+ if db in self._cache["server_version"]["storage"]:
+ return self._cache["server_version"]["storage"][db]
+
+ version_string = self.query("show server_version", db)[0][0]
+ result = bytes(
+ version_string.split(" ")[0], "utf-8")
+ self._cache["server_version"]["storage"][db] = "{0}".format(
+ result.decode("ascii"))
return self._cache["server_version"]["storage"][db]
- result = bytes(
- self.query("show server_version", db)[0][0], "utf-8")
- self._cache["server_version"]["storage"][db] = "{0}".format(
- result.decode("ascii"))
- return self._cache["server_version"]["storage"][db]
+
+ def extension_version(self, extension, db=None):
+ with self._lock:
+ db = self._normalize_db(db)
+ if extension in self._cache["extension_versions"] and db in self._cache["extension_versions"][extension][db]:
+ return self._cache["extension_versions"][extension][db]
+
+ version_string = self.query("select extversion from pg_catalog.pg_extension where lower(extname) = lower('{0}');".format(extension), db)[0][0]
+ result = bytes(
+ version_string.split(" ")[0], "utf-8")
+ self._cache["extension_versions"][extension] = {}
+ self._cache["extension_versions"][extension][db] = "{0}".format(
+ result.decode("ascii"))
+ return self._cache["extension_versions"][extension][db]
def server_version_greater(self, version, db=None):
db = self._normalize_db(db)
- return self.server_version(db) >= LooseVersion(version)
+ return parse(self.server_version(db)) >= parse(version)
def server_version_less(self, version, db=None):
db = self._normalize_db(db)
- return self.server_version(db) <= LooseVersion(version)
+ return parse(self.server_version(db)) <= parse(version)
def bootstrap_version_greater(self, version):
- return str(
- self._cache["bootstrap"]["version"]) >= LooseVersion(version)
+ with self._lock:
+ return parse(str(self._cache["bootstrap"]["version"])) >= parse(version)
def bootstrap_version_less(self, version):
- return str(
- self._cache["bootstrap"]["version"]) <= LooseVersion(version)
+ with self._lock:
+ return parse(str(self._cache["bootstrap"]["version"])) <= parse(version)
def in_recovery(self, db=None):
- db = self._normalize_db(db)
- if db in self._cache["recovery"]["storage"]:
- if self._cache["recovery"]["counter"] < self._cache["recovery"]["cache"]:
- self._cache["recovery"]["counter"] += 1
- return self._cache["recovery"]["storage"][db]
- self._cache["recovery"]["counter"] = 0
- self._cache["recovery"]["storage"][db] = self.query(
- "select pg_catalog.pg_is_in_recovery()", db)[0][0]
- return self._cache["recovery"]["storage"][db]
+ with self._lock:
+ db = self._normalize_db(db)
+ if db in self._cache["recovery"]["storage"]:
+ if self._cache["recovery"]["counter"] < self._cache["recovery"]["cache"]:
+ self._cache["recovery"]["counter"] += 1
+ return self._cache["recovery"]["storage"][db]
+ self._cache["recovery"]["counter"] = 0
+ self._cache["recovery"]["storage"][db] = self.query(
+ "select pg_catalog.pg_is_in_recovery()", db)[0][0]
+ return self._cache["recovery"]["storage"][db]
def is_bootstraped(self, db=None):
- db = self._normalize_db(db)
- if db in self._cache["bootstrap"]["storage"]:
- if self._cache["bootstrap"]["counter"] < self._cache["bootstrap"]["cache"]:
- self._cache["bootstrap"]["counter"] += 1
- return self._cache["bootstrap"]["storage"][db]
- self._cache["bootstrap"]["counter"] = 0
- # TODO: изменить на нормальное название, 'config' слишком общее
- sql = """
- SELECT count(*)
- FROM pg_catalog.pg_class
- WHERE relname = 'config';
- """
- result = int(self.query(sql, db)[0][0])
- self._cache["bootstrap"]["storage"][db] = (result == 1)
- if self._cache["bootstrap"]["storage"][db]:
- self._connections[db].log.info("Found mamonsu bootstrap")
+ with self._lock:
+ db = self._normalize_db(db)
+ if db in self._cache["bootstrap"]["storage"]:
+ if self._cache["bootstrap"]["counter"] < self._cache["bootstrap"]["cache"]:
+ self._cache["bootstrap"]["counter"] += 1
+ return self._cache["bootstrap"]["storage"][db]
+ self._cache["bootstrap"]["counter"] = 0
+ # TODO: изменить на нормальное название, 'config' слишком общее
sql = """
- SELECT max(version)
- FROM mamonsu.config;
+ SELECT count(*)
+ FROM pg_catalog.pg_class
+ WHERE relname = 'config';
"""
- self._cache["bootstrap"]["version"] = self.query(sql, db)[0][0]
- else:
- self._connections[db].log.info("Mamonsu bootstrap is not found")
- self._connections[db].log.info(
- "hint: run `mamonsu bootstrap` if you want to run without superuser rights")
- return self._cache["bootstrap"]["storage"][db]
+ result = int(self.query(sql, db)[0][0])
+ self._cache["bootstrap"]["storage"][db] = (result == 1)
+ if self._cache["bootstrap"]["storage"][db]:
+ self._connections[db].log.info("Found mamonsu bootstrap")
+ sql = """
+ SELECT max(version)
+ FROM mamonsu.config;
+ """
+ self._cache["bootstrap"]["version"] = self.query(sql, db)[0][0]
+ else:
+ self._connections[db].log.info("Mamonsu bootstrap is not found")
+ self._connections[db].log.info(
+ "hint: run `mamonsu bootstrap` if you want to run without superuser rights")
+ return self._cache["bootstrap"]["storage"][db]
def is_superuser(self, db=None):
_ = self._normalize_db(db)
@@ -176,62 +242,73 @@ def is_superuser(self, db=None):
return False
def is_pgpro(self, db=None):
- db = self._normalize_db(db)
- if db in self._cache["pgpro"]:
+ with self._lock:
+ db = self._normalize_db(db)
+ if db in self._cache["pgpro"]:
+ return self._cache["pgpro"][db]
+ try:
+ self.query("""
+ SELECT pgpro_version();
+ """)
+ self._cache["pgpro"][db] = True
+ except:
+ self._cache["pgpro"][db] = False
return self._cache["pgpro"][db]
- try:
- self.query("""
- SELECT pgpro_version();
- """)
- self._cache["pgpro"][db] = True
- except:
- self._cache["pgpro"][db] = False
- return self._cache["pgpro"][db]
def is_pgpro_ee(self, db=None):
- db = self._normalize_db(db)
- if not self.is_pgpro(db):
- return False
- if db in self._cache["pgproee"]:
+ with self._lock:
+ db = self._normalize_db(db)
+ if not self.is_pgpro(db):
+ return False
+ if db in self._cache["pgproee"]:
+ return self._cache["pgproee"][db]
+ try:
+ ed = self.query("""
+ SELECT pgpro_edition();
+ """)[0][0]
+ self._connections[db].log.info("pgpro_edition is {}".format(ed))
+ self._cache["pgproee"][db] = (ed.lower() == "enterprise")
+ except:
+ self._connections[db].log.info("pgpro_edition() is not defined")
+ self._cache["pgproee"][db] = False
return self._cache["pgproee"][db]
- try:
- ed = self.query("""
- SELECT pgpro_edition();
- """)[0][0]
- self._connections[db].log.info("pgpro_edition is {}".format(ed))
- self._cache["pgproee"][db] = (ed.lower() == "enterprise")
- except:
- self._connections[db].log.info("pgpro_edition() is not defined")
- self._cache["pgproee"][db] = False
- return self._cache["pgproee"][db]
+
+ def extension_version_greater(self, extension, version, db=None):
+ db = self._normalize_db(db)
+ return parse(self.extension_version(extension, db)) >= parse(version)
+
+ def extension_version_less(self, extension, version, db=None):
+ db = self._normalize_db(db)
+ return parse(self.extension_version(extension, db)) <= parse(version)
def extension_installed(self, ext, db=None):
db = self._normalize_db(db)
result = self.query("""
- SELECT count(*)
- FROM pg_catalog.pg_extension
+ SELECT count(*)
+ FROM pg_catalog.pg_extension
WHERE lower(extname) = lower('{0}');
""".format(ext), db)
return (int(result[0][0])) == 1
def extension_schema(self, extension, db=None):
- db = self._normalize_db(db)
- if db in self._cache["extension_schema"][extension]:
- return self._cache["extension_schema"][extension][db]
- try:
- self._cache["extension_schema"][extension][db] = self.query("""
- SELECT n.nspname
- FROM pg_extension e
- JOIN pg_namespace n ON e.extnamespace = n.oid
- WHERE e.extname = '{0}'
- """.format(extension), db)[0][0]
- return self._cache["extension_schema"][extension][db]
- except:
- self._connections[db].log.info("{0} is not installed".format(extension))
+ with self._lock:
+ db = self._normalize_db(db)
+ if db in self._cache["extension_schema"][extension]:
+ return self._cache["extension_schema"][extension][db]
+ try:
+ self._cache["extension_schema"][extension][db] = self.query("""
+ SELECT n.nspname
+ FROM pg_extension e
+ JOIN pg_namespace n ON e.extnamespace = n.oid
+ WHERE e.extname = '{0}'
+ """.format(extension), db)[0][0]
+ return self._cache["extension_schema"][extension][db]
+ except:
+ self._connections[db].log.info("{0} is not installed".format(extension))
def databases(self):
result, databases = self.query("""
- SELECT datname
+ SELECT datname
FROM pg_catalog.pg_database;
"""), []
for row in result:
@@ -290,13 +367,13 @@ def get_sys_param(self, param, db=None):
db = self._normalize_db(db)
if self.is_bootstraped() and self.bootstrap_version_greater("2.3.4"):
result = self.query("""
- SELECT *
+ SELECT *
FROM mamonsu.get_sys_param('{0}');
""".format(param))[0][0]
else:
result = self.query("""
- SELECT setting
- FROM pg_catalog.pg_settings
+ SELECT setting
+ FROM pg_catalog.pg_settings
WHERE name = '{0}';
""".format(param), db)[0][0]
return result
diff --git a/mamonsu/plugins/pgsql/health.py b/mamonsu/plugins/pgsql/health.py
index 1a5c1788..d0a9697e 100644
--- a/mamonsu/plugins/pgsql/health.py
+++ b/mamonsu/plugins/pgsql/health.py
@@ -5,12 +5,12 @@
import time
from mamonsu.lib.zbx_template import ZbxTemplate
-
class PgHealth(Plugin):
AgentPluginType = "pg"
- DEFAULT_CONFIG = {
- "uptime": str(60 * 10),
- "cache": str(80)
+ # key: (macro, value)
+ plugin_macros = {
+ "pg_uptime": [("macro", "{$PG_UPTIME}"), ("value", 60 * 10)],
+ "cache_hit_ratio_percent": [("macro", "{$CACHE_HIT_RATIO_PERCENT}"), ("value", 80)]
}
query_health = """
SELECT 1 AS health;
@@ -57,7 +57,10 @@ def items(self, template, dashboard=False):
"value_type": Plugin.VALUE_TYPE.numeric_float,
"units": Plugin.UNITS.percent,
"type": Plugin.TYPE.CALCULATED,
- "params": "last(pgsql.blocks[hit])*100/(last(pgsql.blocks[hit])+last(pgsql.blocks[read]))"
+ "params": "last(//{blocks_hit})*100/(last(//{blocks_hit})+last(//{blocks_read}))".format(
+ # TODO: hardcoded params
+ blocks_hit=self.right_type("pgsql.blocks{0}", "hit"),
+ blocks_read=self.right_type("pgsql.blocks{0}", "read"))
}) + template.item({
"name": "PostgreSQL Health: Service Uptime",
"key": self.right_type(self.key_uptime),
@@ -93,23 +96,37 @@ def items(self, template, dashboard=False):
"position": 3}
}]
+ def macros(self, template, dashboard=False):
+ result = ""
+ for macro in self.plugin_macros.keys():
+ result += template.mamonsu_macro(defaults=self.plugin_macros[macro])
+ if not dashboard:
+ return result
+ else:
+ return []
+
def triggers(self, template, dashboard=False):
- result = template.trigger({
- "name": "PostgreSQL Health: service has been restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})",
- "expression": "{#TEMPLATE:" + self.right_type(self.key_uptime) + ".change()}>" + str(
- self.plugin_config("uptime"))
- }) + template.trigger({
- "name": "PostgreSQL Health: cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})",
- "expression": "{#TEMPLATE:" + self.right_type(self.key_cache, "hit") + ".last()}<" + str(
- self.plugin_config("cache"))
- }) + template.trigger({
- "name": "PostgreSQL Health: no ping from PostgreSQL for 3 minutes on {HOSTNAME}",
- "expression": "{#TEMPLATE:" + self.right_type(self.key_ping) + ".nodata(180)}=1"
- })
- return result
+ if self.Type == 'mamonsu':
+ result = template.trigger({
+ "name": "PostgreSQL Health: service has been restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})",
+ "expression": "{#TEMPLATE:" + self.right_type(self.key_uptime) + ".change()}>" +
+ self.plugin_macros["pg_uptime"][0][1]
+ }) + template.trigger({
+ "name": "PostgreSQL Health: cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})",
+ "expression": "{#TEMPLATE:" + self.right_type(self.key_cache, "hit") + ".last()}<" +
+ self.plugin_macros["cache_hit_ratio_percent"][0][1]
+ }) + template.trigger({
+ "name": "PostgreSQL Health: no ping from PostgreSQL for 3 minutes on {HOSTNAME}",
+ "expression": "{#TEMPLATE:" + self.right_type(self.key_ping) + ".nodata(180)}=1"
+ })
+ return result
+ else:
+ return ""
def keys_and_queries(self, template_zabbix):
- result = ["{0}[*],$2 $1 -c \"{1}\"".format(self.key_ping.format(""), self.query_health),
- "{0}[*],$2 $1 -c \"{1}\"".format(self.key_uptime.format(""), self.query_uptime),
- "{0}[*],$2 $1 -c \"{1}\"".format(self.key_version.format(""), self.query_version)]
+ # TODO: define another metric key because it duplicates native zabbix agents keys
+ # result = ["{0}[*],$2 $1 -c \"{1}\"".format(self.key_ping.format(""), self.query_health),
+ # "{0}[*],$2 $1 -c \"{1}\"".format(self.key_uptime.format(""), self.query_uptime),
+ # "{0}[*],$2 $1 -c \"{1}\"".format(self.key_version.format(""), self.query_version)]
+ result = ["{0}[*],$2 $1 -c \"{1}\"".format(self.key_version.format(""), self.query_version)]
return template_zabbix.key_and_query(result)
diff --git a/mamonsu/plugins/pgsql/instance.py b/mamonsu/plugins/pgsql/instance.py
index c1070b24..c0a3a9ce 100644
--- a/mamonsu/plugins/pgsql/instance.py
+++ b/mamonsu/plugins/pgsql/instance.py
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
from mamonsu.plugins.pgsql.plugin import PgsqlPlugin as Plugin
-from distutils.version import LooseVersion
from .pool import Pooler
from mamonsu.lib.zbx_template import ZbxTemplate
@@ -70,7 +69,7 @@ class Instance(Plugin):
Plugin.UNITS.none, Plugin.DELTA.simple_change)
]
- key_server_mode = "pgsql.server_mode"
+ key_server_mode = "pgsql.server_mode{0}"
query_server_mode = """
SELECT CASE WHEN pg_is_in_recovery() THEN 'STANDBY'
ELSE 'MASTER'
@@ -98,7 +97,7 @@ def run(self, zbx):
zbx_key, value = "pgsql.{0}".format(all_items[key][1]), int(value)
zbx.send(zbx_key, value, all_items[key][5], only_positive_speed=True)
result_server_mode = Pooler.query(self.query_server_mode)[0][0]
- zbx.send(self.key_server_mode, result_server_mode)
+ zbx.send(self.right_type(self.key_server_mode), result_server_mode)
del columns, result, result_server_mode
def items(self, template, dashboard=False):
@@ -118,14 +117,14 @@ def items(self, template, dashboard=False):
"delay": self.plugin_config("interval"),
"delta": delta
})
- result += template.item({
- "key": self.key_server_mode,
- "name": "PostgreSQL Instance: Server Mode",
- "value_type": self.VALUE_TYPE.text,
- "units": self.UNITS.none,
- "delay": self.plugin_config("interval"),
- "delta": Plugin.DELTA.as_is
- })
+ result += template.item({
+ "key": self.right_type(self.key_server_mode),
+ "name": "PostgreSQL Instance: Server Mode",
+ "value_type": self.VALUE_TYPE.text,
+ "units": self.UNITS.none,
+ "delay": self.plugin_config("interval"),
+ "delta": Plugin.DELTA.as_is
+ })
if not dashboard:
return result
else:
@@ -197,12 +196,12 @@ def graphs(self, template, dashboard=False):
def triggers(self, template, dashboard=False):
return template.trigger({
"name": "PostgreSQL Instance: server mode has been changed on {HOSTNAME} to {ITEM.LASTVALUE}",
- "expression": "{#TEMPLATE:" + self.key_server_mode + ".change()}>0"
+ "expression": "{#TEMPLATE:" + self.right_type(self.key_server_mode) + ".change()}>0"
})
def keys_and_queries(self, template_zabbix):
result = []
- if LooseVersion(self.VersionPG) < LooseVersion("12"):
+ if Pooler.server_version_less("11"):
all_items = self.Items
else:
all_items = self.Items + self.Items_pg_12
@@ -211,5 +210,5 @@ def keys_and_queries(self, template_zabbix):
keys = item[1].split("[")
result.append("{0}[*],$2 $1 -c \"{1}\"".format("{0}{1}.{2}".format(self.key, keys[0], keys[1][:-1]),
self.query_agent.format(format(item[0]))))
- result.append("{0}[*],$2 $1 -c \"{1}\"".format(self.key_server_mode, self.query_server_mode))
+ result.append("{0},$2 $1 -c \"{1}\"".format(self.key_server_mode.format("[*]"), self.query_server_mode))
return template_zabbix.key_and_query(result)
diff --git a/mamonsu/plugins/pgsql/memory_leak_diagnostic.py b/mamonsu/plugins/pgsql/memory_leak_diagnostic.py
index a9da0a18..14c0749b 100644
--- a/mamonsu/plugins/pgsql/memory_leak_diagnostic.py
+++ b/mamonsu/plugins/pgsql/memory_leak_diagnostic.py
@@ -4,10 +4,11 @@
import os
from .pool import Pooler
import re
-from distutils.version import LooseVersion
import mamonsu.lib.platform as platform
import posix
+import mamonsu.lib.version as version
+
class MemoryLeakDiagnostic(Plugin):
DEFAULT_CONFIG = {
@@ -91,7 +92,7 @@ def run(self, zbx):
for row in Pooler.query(query=self.query):
pids.append(row[0])
- if (LooseVersion(self.os_release) < LooseVersion("4.5")
+ if (version.parse(self.os_release) < version.parse("4.5")
and not (self.os_name == "centos" and self.os_version == "7")) \
or (not self.os_name and not self.os_version):
for pid in pids:
diff --git a/mamonsu/plugins/pgsql/oldest.py b/mamonsu/plugins/pgsql/oldest.py
index ba0dbbd7..2a335d4c 100644
--- a/mamonsu/plugins/pgsql/oldest.py
+++ b/mamonsu/plugins/pgsql/oldest.py
@@ -35,9 +35,10 @@ class Oldest(Plugin):
WHERE leader_pid is not NULL;
"""
- DEFAULT_CONFIG = {
- "max_xid_age": str(5000 * 60 * 60),
- "max_transaction_time": str(5 * 60 * 60)
+ # key: (macro, value)
+ plugin_macros = {
+ "max_xid_age": [("macro", "{$MAX_XID_AGE}"), ("value", 5000 * 60 * 60)],
+ "max_transaction_time": [("macro", "{$MAX_TRANSACTION_TIME}"), ("value", 5 * 60 * 60)],
}
def run(self, zbx):
@@ -85,16 +86,25 @@ def items(self, template, dashboard=False):
"position": 2}
}]
+ def macros(self, template, dashboard=False):
+ result = ""
+ for macro in self.plugin_macros.keys():
+ result += template.mamonsu_macro(defaults=self.plugin_macros[macro])
+ if not dashboard:
+ return result
+ else:
+ return []
+
def triggers(self, template, dashboard=False):
return template.trigger({
"name": "PostgreSQL Transactions: the oldest XID is too big on {HOSTNAME}",
- "expression": "{#TEMPLATE:" + self.right_type(self.key, "xid_age") + ".last()}>" + self.plugin_config(
- "max_xid_age")
+ "expression": "{#TEMPLATE:" + self.right_type(self.key, "xid_age") + ".last()}>" +
+ self.plugin_macros["max_xid_age"][0][1]
}) + template.trigger({
"name": "PostgreSQL Transactions: running transaction is too old on {HOSTNAME}",
"expression": "{#TEMPLATE:" + self.right_type(self.key,
- "transaction_time") + ".last()}>" + self.plugin_config(
- "max_transaction_time")
+ "transaction_time") + ".last()}>" +
+ self.plugin_macros["max_transaction_time"][0][1]
})
def keys_and_queries(self, template_zabbix):
diff --git a/mamonsu/plugins/pgsql/pg_locks.py b/mamonsu/plugins/pgsql/pg_locks.py
index 9713ec29..63a3be49 100644
--- a/mamonsu/plugins/pgsql/pg_locks.py
+++ b/mamonsu/plugins/pgsql/pg_locks.py
@@ -22,28 +22,28 @@ class PgLocks(Plugin):
Items = [
# key, desc, color
("accessshare",
- "Read Only Queries",
+ "total number of locks acquired (or waiting) by queries that only reads tables and do not modify",
"00CC00"),
("rowshare",
- "SELECT FOR SHARE and SELECT FOR UPDATE",
+ "total number of locks acquired (or waiting) by all queries like SELECT FOR SHARE and SELECT FOR UPDATE",
"3B415A"),
("rowexclusive",
- "Write Queries",
+ "total number of locks acquired (or waiting) by all queries like UPDATE, DELETE, INSERT and MERGE",
"FF5656"),
("shareupdateexclusive",
- "VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY",
+ "total number of locks acquired (or waiting) by all queries like VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY, CREATE STATISTICS, COMMENT ON, REINDEX CONCURRENTLY, and some forms of ALTER INDEX and ALTER TABLE",
"F6CB93"),
("share",
- "CREATE INDEX",
+ "total number of locks acquired (or waiting) by all queries like CREATE INDEX",
"006AAE"),
("sharerowexclusive",
- "Locks from Application",
+ "total number of locks acquired (or waiting) by all queries like CREATE TRIGGER and some forms of ALTER TABLE",
"00B0B8"),
("exclusive",
- "Locks from Application or Some Operations on System Catalogs",
+ "total number of locks acquired (or waiting) by all queries like REFRESH MATERIALIZED VIEW CONCURRENTLY",
"9C8A4E"),
("accessexclusive",
- "ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE",
+ "total number of locks acquired (or waiting) by all queries like DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, REFRESH MATERIALIZED VIEW, LOCK TABLE and some forms of ALTER INDEX and ALTER TABLE",
"793F5D")
]
@@ -103,5 +103,5 @@ def keys_and_queries(self, template_zabbix):
result = []
for item in self.Items:
result.append("{0}[*],$2 $1 -c \"{1}\"".format(self.key.format("." + item[0]),
- self.query_agent.format("{0}lock".format(item[0]))))
+ self.query_agent.format("{0}lock".format(item[0]))))
return template_zabbix.key_and_query(result)
diff --git a/mamonsu/plugins/pgsql/prepared_transaction.py b/mamonsu/plugins/pgsql/prepared_transaction.py
index 3b1aff5c..0aecb95c 100644
--- a/mamonsu/plugins/pgsql/prepared_transaction.py
+++ b/mamonsu/plugins/pgsql/prepared_transaction.py
@@ -30,8 +30,9 @@ class PreparedTransaction(Plugin):
FROM mamonsu.prepared_transaction();
"""
- DEFAULT_CONFIG = {
- "max_prepared_transaction_time": str(5 * 60 * 60)
+ # key: (macro, value)
+ plugin_macros = {
+ "max_prepared_transaction_time": [("macro", "{$MAX_PREPARED_TRANSACTION_TIME}"), ("value", 5 * 60 * 60)]
}
def run(self, zbx):
@@ -92,10 +93,19 @@ def graphs(self, template, dashboard=False):
else:
return []
+ def macros(self, template, dashboard=False):
+ result = ""
+ for macro in self.plugin_macros.keys():
+ result += template.mamonsu_macro(defaults=self.plugin_macros[macro])
+ if not dashboard:
+ return result
+ else:
+ return []
+
def triggers(self, template, dashboard=False):
result = template.trigger({
"name": "PostgreSQL Prepared Transactions: prepared transaction is too old on {HOSTNAME}",
- "expression": "{#TEMPLATE:" + self.key_prepared["key"] + ".last()}>" + self.plugin_config(
- "max_prepared_transaction_time")
+ "expression": "{#TEMPLATE:" + self.key_prepared["key"] + ".last()}>" +
+ self.plugin_macros["max_prepared_transaction_time"][0][1]
})
return result
diff --git a/mamonsu/plugins/pgsql/replication.py b/mamonsu/plugins/pgsql/replication.py
index 414c024d..7ed701c1 100644
--- a/mamonsu/plugins/pgsql/replication.py
+++ b/mamonsu/plugins/pgsql/replication.py
@@ -1,17 +1,20 @@
# -*- coding: utf-8 -*-
from mamonsu.plugins.pgsql.plugin import PgsqlPlugin as Plugin
-from distutils.version import LooseVersion
from .pool import Pooler
from mamonsu.lib.zbx_template import ZbxTemplate
+import mamonsu.lib.version as version
+
NUMBER_NON_ACTIVE_SLOTS = 0
class Replication(Plugin):
AgentPluginType = "pg"
- DEFAULT_CONFIG = {
- "lag_more_than_in_sec": str(60 * 5)
+ # key: (macro, value)
+ plugin_macros = {
+ "critical_lag_seconds": [("macro", "{$CRITICAL_LAG_SECONDS}"), ("value", 60 * 5)],
+ "critical_bytes_held_by_none_active_slot": [("macro", "{$CRITICAL_BYTES_HELD_BY_NON_ACTIVE_SLOT}"), ("value", 1024 * 1024 * 1024)]
}
# get time of replication lag
@@ -22,8 +25,21 @@ class Replication(Plugin):
END;
"""
+ query_non_active_slots = """
+ SELECT count(*)
+ FROM pg_replication_slots
+ WHERE active = 'false';
+ """
+
+ query_bytes_held_by_non_active_slot = """
+ SELECT slot_name, coalesce(pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn)::bigint, 0) AS wal_size_bytes
+ FROM pg_replication_slots
+ WHERE active = 'false';
+ """
+
# for discovery rule for name of each replica
key_lsn_replication_discovery = "pgsql.replication.discovery{0}"
+ key_replication_non_active_slots_discovery = "pgsql.replication.non_active_slots_discovery{0}"
key_total_lag = "pgsql.replication.total_lag{0}"
# for PG 10 and higher
key_flush = "pgsql.replication.flush_lag{0}"
@@ -34,6 +50,7 @@ class Replication(Plugin):
key_replication = "pgsql.replication_lag{0}"
key_non_active_slots = "pgsql.replication.non_active_slots{0}"
+ key_non_active_slots_held_bytes = "pgsql.replication.non_active_slots_held_bytes{0}"
def run(self, zbx):
@@ -51,13 +68,14 @@ def run(self, zbx):
Pooler.run_sql_type("replication_lag_master_query")
if Pooler.server_version_greater("10.0") and (Pooler.is_superuser() or Pooler.is_bootstraped()):
result_lags = Pooler.run_sql_type("wal_lag_lsn",
- args=[" coalesce((pg_wal_lsn_diff(pg_current_wal_lsn(), sent_lsn))::int, 0) AS send_lag, "
- "coalesce((pg_wal_lsn_diff(sent_lsn, flush_lsn))::int, 0) AS receive_lag, "
- "coalesce((pg_wal_lsn_diff(sent_lsn, write_lsn))::int, 0) AS write_lag, "
- "coalesce((pg_wal_lsn_diff(write_lsn, flush_lsn))::int, 0) AS flush_lag, "
- "coalesce((pg_wal_lsn_diff(flush_lsn, replay_lsn))::int, 0) AS replay_lag, " if not Pooler.is_bootstraped() else
- " send_lag, receive_lag, write_lag, flush_lag, replay_lag, ",
- "wal", "lsn"])
+ args=[
+ " coalesce((pg_wal_lsn_diff(pg_current_wal_lsn(), sent_lsn))::int, 0) AS send_lag, "
+ "coalesce((pg_wal_lsn_diff(sent_lsn, flush_lsn))::int, 0) AS receive_lag, "
+ "coalesce((pg_wal_lsn_diff(sent_lsn, write_lsn))::int, 0) AS write_lag, "
+ "coalesce((pg_wal_lsn_diff(write_lsn, flush_lsn))::int, 0) AS flush_lag, "
+ "coalesce((pg_wal_lsn_diff(flush_lsn, replay_lsn))::int, 0) AS replay_lag, " if not Pooler.is_bootstraped() else
+ " send_lag, receive_lag, write_lag, flush_lag, replay_lag, ",
+ "wal", "lsn"])
if result_lags:
lags = []
for info in result_lags:
@@ -70,6 +88,14 @@ def run(self, zbx):
zbx.send("pgsql.replication.replay_lag[{0}]".format(info[0]), float(info[5]))
zbx.send("pgsql.replication.discovery[]", zbx.json({"data": lags}))
del lags
+ bytes_held_by_non_active_slot = Pooler.run_sql_type("wal_held_bytes_master", args=[])
+ if bytes_held_by_non_active_slot:
+ discovery = []
+ for info in bytes_held_by_non_active_slot:
+ discovery.append({"{#NON_ACTIVE_SLOT_NAME}": info[0]})
+ zbx.send("pgsql.replication.non_active_slots_held_bytes[{0}]".format(info[0]), int(info[1]))
+ zbx.send("pgsql.replication.non_active_slots_discovery[]", zbx.json({"data": discovery}))
+ del discovery
elif Pooler.is_superuser() or Pooler.is_bootstraped():
result_lags = Pooler.run_sql_type("wal_lag_lsn", args=[" ", "xlog", "location"])
if result_lags:
@@ -81,15 +107,18 @@ def run(self, zbx):
del lags
else:
self.disable_and_exit_if_not_superuser()
-
- non_active_slots = Pooler.query("""
- SELECT count(*)
- FROM pg_replication_slots
- WHERE active = 'false';
- """)
+ else:
+ bytes_held_by_non_active_slot = Pooler.run_sql_type("wal_held_bytes_replica", args=[])
+ if bytes_held_by_non_active_slot:
+ discovery = []
+ for info in bytes_held_by_non_active_slot:
+ discovery.append({"{#NON_ACTIVE_SLOT_NAME}": info[0]})
+ zbx.send("pgsql.replication.non_active_slots_held_bytes[{0}]".format(info[0]), int(info[1]))
+ zbx.send("pgsql.replication.non_active_slots_discovery[]", zbx.json({"data": discovery}))
+ del discovery
+ non_active_slots = Pooler.query(self.query_non_active_slots)
zbx.send(self.key_non_active_slots.format("[]"), int(non_active_slots[0][0]))
-
def items(self, template, dashboard=False):
result = ""
if self.Type == "mamonsu":
@@ -110,16 +139,26 @@ def items(self, template, dashboard=False):
else:
return []
+ def macros(self, template, dashboard=False):
+ result = ""
+ for macro in self.plugin_macros.keys():
+ result += template.mamonsu_macro(defaults=self.plugin_macros[macro])
+ if not dashboard:
+ return result
+ else:
+ return []
+
def triggers(self, template, dashboard=False):
triggers = template.trigger({
- "name": "PostgreSQL streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})",
+ "name": "PostgreSQL Replication: streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})",
"expression": "{#TEMPLATE:" + self.right_type(self.key_replication,
- "sec") + ".last()}>" + self.plugin_config(
- "lag_more_than_in_sec")
+ "sec") + ".last()}>" +
+ self.plugin_macros["critical_lag_seconds"][0][1]
}) + template.trigger({
- "name": "PostgreSQL number of non-active replication slots on {HOSTNAME} (value={ITEM.LASTVALUE})",
+ "name": "PostgreSQL Replication: number of non-active replication slots on {HOSTNAME} (value={ITEM.LASTVALUE})",
"expression": "{#TEMPLATE:" + self.right_type(self.key_non_active_slots) + ".last()}>" + str(
- NUMBER_NON_ACTIVE_SLOTS)
+ NUMBER_NON_ACTIVE_SLOTS),
+ "status": 1
})
return triggers
@@ -185,18 +224,55 @@ def discovery_rules(self, template, dashboard=False):
]
}
]
- return template.discovery_rule(rule=rule, conditions=conditions, items=items, graphs=graphs)
+ active_slots_discovery_rule = template.discovery_rule(rule=rule, conditions=conditions, items=items, graphs=graphs)
+
+ rule = {
+ "name": "PostgreSQL Replication: Non Active Slots Discovery",
+ "key": self.key_replication_non_active_slots_discovery.format("[{0}]".format(self.Macros[self.Type]))
+ }
+ if Plugin.old_zabbix:
+ conditions = []
+ rule["filter"] = "{#NON_ACTIVE_SLOT_NAME}:.*"
+ else:
+ conditions = [{
+ "condition": [
+ {"macro": "{#NON_ACTIVE_SLOT_NAME}",
+ "value": ".*",
+ "operator": 8,
+ "formulaid": "A"}
+ ]
+ }]
+ items = [
+ {"key": self.right_type(self.key_non_active_slots_held_bytes, var_discovery="{#NON_ACTIVE_SLOT_NAME},"),
+ "name": "PostgreSQL Replication: Bytes held by non-active slot {#NON_ACTIVE_SLOT_NAME}",
+ "value_type": Plugin.VALUE_TYPE.numeric_float,
+ "delay": self.plugin_config("interval"),
+ "drawtype": 2}
+ ]
+ graphs = []
+ triggers = [
+ {
+ "name": "PostgreSQL Replication: bytes held by slot {#NON_ACTIVE_SLOT_NAME} is too high (value={ITEM.LASTVALUE})",
+ "expression": "{#TEMPLATE:" + self.right_type(self.key_non_active_slots_held_bytes, var_discovery="{#NON_ACTIVE_SLOT_NAME},") + ".last()}>" +
+ self.plugin_macros["critical_bytes_held_by_none_active_slot"][0][1]
+ }
+ ]
+ non_active_slots_discovery_rule = template.discovery_rule(rule=rule, conditions=conditions, items=items, graphs=graphs, triggers=triggers)
+
+ return active_slots_discovery_rule + non_active_slots_discovery_rule
def keys_and_queries(self, template_zabbix):
result = []
- if LooseVersion(self.VersionPG) < LooseVersion("10"):
+ if version.parse(self.VersionPG) < version.parse("10"):
result.append("{0},$2 $1 -c \"{1}\"".format("pgsql.replication_lag.sec[*]",
- self.query_agent_replication_lag.format(
- self.plugin_config("interval"), "xlog_receive_location",
- "xlog_replay_location")))
+ self.query_agent_replication_lag.format(
+ self.plugin_config("interval"), "xlog_receive_location",
+ "xlog_replay_location")))
else:
result.append("{0},$2 $1 -c \"{1}\"".format("pgsql.replication_lag.sec[*]",
- self.query_agent_replication_lag.format(
- self.plugin_config("interval"), "wal_receive_lsn",
- "wal_replay_lsn")))
+ self.query_agent_replication_lag.format(
+ self.plugin_config("interval"), "wal_receive_lsn",
+ "wal_replay_lsn")))
+ result.append("{0},$2 $1 -c \"{1}\"".format("pgsql.replication.non_active_slots[*]",
+ self.query_non_active_slots))
return template_zabbix.key_and_query(result)
diff --git a/mamonsu/plugins/pgsql/statements.py b/mamonsu/plugins/pgsql/statements.py
index 3a67f52f..784f2262 100644
--- a/mamonsu/plugins/pgsql/statements.py
+++ b/mamonsu/plugins/pgsql/statements.py
@@ -1,7 +1,6 @@
# -*- coding: utf-8 -*-
from mamonsu.plugins.pgsql.plugin import PgsqlPlugin as Plugin
-from distutils.version import LooseVersion
from .pool import Pooler
@@ -16,7 +15,7 @@ class Statements(Plugin):
"pgpro_stats":
"""
SELECT {metrics}
- FROM {extension_schema}.pgpro_stats_totals
+ FROM {extension_schema}.pgpro_stats_totals()
WHERE object_type = 'cluster';
""",
"pgpro_stats_bootstrap":
@@ -28,41 +27,40 @@ class Statements(Plugin):
query_info = """
SELECT {metrics}
- FROM {extension_schema}.pg_stat_statements_info;
+ FROM {extension_schema}.{info_view_name};
"""
key = "pgsql."
# zbx_key, sql, desc, unit, delta, (Graph, color, side)
Items = [
("stat[read_bytes]",
- "sum(shared_blks_read+local_blks_read+temp_blks_read)*8*1024",
+ "(sum(shared_blks_read+local_blks_read+temp_blks_read)*8*1024)::bigint",
"Read bytes/s", Plugin.UNITS.bytes_per_second, Plugin.DELTA.speed_per_second,
("PostgreSQL Statements: Bytes", "87C2B9", 0)),
("stat[write_bytes]",
- "sum(shared_blks_written+local_blks_written"
- "+temp_blks_written)*8*1024",
+ "(sum(shared_blks_written+local_blks_written+temp_blks_written)*8*1024)::bigint",
"Write bytes/s", Plugin.UNITS.bytes_per_second, Plugin.DELTA.speed_per_second,
("PostgreSQL Statements: Bytes", "793F5D", 0)),
("stat[dirty_bytes]",
- "sum(shared_blks_dirtied+local_blks_dirtied)*8*1024",
+ "(sum(shared_blks_dirtied+local_blks_dirtied)*8*1024)::bigint",
"Dirty bytes/s", Plugin.UNITS.bytes_per_second, Plugin.DELTA.speed_per_second,
("PostgreSQL Statements: Bytes", "9C8A4E", 0)),
("stat[read_time]",
- "sum(blk_read_time)/float4(100)",
+ "(sum(blk_read_time)/float4(100))::bigint",
"Read IO Time", Plugin.UNITS.s, Plugin.DELTA.speed_per_second,
("PostgreSQL Statements: Spent Time", "87C2B9", 0)),
("stat[write_time]",
- "sum(blk_write_time)/float4(100)",
+ "(sum(blk_write_time)/float4(100))::bigint",
"Write IO Time", Plugin.UNITS.s, Plugin.DELTA.speed_per_second,
("PostgreSQL Statements: Spent Time", "793F5D", 0)),
["stat[other_time]",
- "sum({0}-blk_read_time-blk_write_time)/float4(100)",
+ "(sum({0}-blk_read_time-blk_write_time)/float4(100))::bigint",
"Other (mostly CPU) Time", Plugin.UNITS.s, Plugin.DELTA.speed_per_second,
("PostgreSQL Statements: Spent Time", "9C8A4E", 0)]]
Items_pg_13 = [
("stat[wal_bytes]",
- "sum(wal_bytes)",
+ "sum(wal_bytes)::bigint",
"Amount of WAL Files", Plugin.UNITS.bytes_per_second, Plugin.DELTA.speed_per_second,
("PostgreSQL Statements: WAL Statistics", "00B0B8", 0)),
("stat[wal_records]",
@@ -78,7 +76,7 @@ class Statements(Plugin):
Items_pg_14 = [
("stat_info[dealloc]",
"dealloc",
- "Nnumber of Times pg_stat_statements.max Was Exceeded",
+ "Number of Times pg_stat_statements.max Was Exceeded",
Plugin.UNITS.none,
Plugin.DELTA.simple_change,
("PostgreSQL Statements Info: Number of Times pg_stat_statements.max Was Exceeded", "793F5D", 0)),
@@ -90,57 +88,105 @@ class Statements(Plugin):
("PostgreSQL Statements Info: Last Statistics Reset Time", "9C8A4E", 0))
]
+ Items_pgpro_stats_1_8 = [
+ ("stat[read_bytes]",
+ "(sum(shared_blks_read+local_blks_read+temp_blks_read)*8*1024)::bigint",
+ "Read bytes/s", Plugin.UNITS.bytes_per_second, Plugin.DELTA.speed_per_second,
+ ("PostgreSQL Statements: Bytes", "87C2B9", 0)),
+ ("stat[write_bytes]",
+ "(sum(shared_blks_written+local_blks_written+temp_blks_written)*8*1024)::bigint",
+ "Write bytes/s", Plugin.UNITS.bytes_per_second, Plugin.DELTA.speed_per_second,
+ ("PostgreSQL Statements: Bytes", "793F5D", 0)),
+ ("stat[dirty_bytes]",
+ "(sum(shared_blks_dirtied+local_blks_dirtied)*8*1024)::bigint",
+ "Dirty bytes/s", Plugin.UNITS.bytes_per_second, Plugin.DELTA.speed_per_second,
+ ("PostgreSQL Statements: Bytes", "9C8A4E", 0)),
+ ("stat[read_time]",
+ "(sum(shared_blk_read_time+local_blk_read_time+temp_blk_read_time)/float4(100))::bigint",
+ "Read IO Time", Plugin.UNITS.s, Plugin.DELTA.speed_per_second,
+ ("PostgreSQL Statements: Spent Time", "87C2B9", 0)),
+ ("stat[write_time]",
+ "(sum(shared_blk_write_time+local_blk_write_time+temp_blk_write_time)/float4(100))::bigint",
+ "Write IO Time", Plugin.UNITS.s, Plugin.DELTA.speed_per_second,
+ ("PostgreSQL Statements: Spent Time", "793F5D", 0)),
+ ["stat[other_time]",
+ "(sum(total_exec_time+total_plan_time-shared_blk_read_time-local_blk_read_time-temp_blk_read_time-shared_blk_write_time-local_blk_write_time-temp_blk_write_time)/float4(100))::bigint",
+ "Other (mostly CPU) Time", Plugin.UNITS.s, Plugin.DELTA.speed_per_second,
+ ("PostgreSQL Statements: Spent Time", "9C8A4E", 0)]]
+
all_graphs = [
("PostgreSQL Statements: Bytes", None),
("PostgreSQL Statements: Spent Time", 1),
("PostgreSQL Statements: WAL Statistics", None)]
+ extension = ""
+
# pgpro_stats работает только для PGPRO 12+ в режиме bootstrap и/или если в конфиге указан суперпользователь mamonsu
def run(self, zbx):
- extension = ""
if (Pooler.is_pgpro() or Pooler.is_pgpro_ee()) and Pooler.server_version_greater("12"):
if Pooler.extension_installed("pgpro_stats"):
if not Pooler.is_bootstraped():
self.disable_and_exit_if_not_superuser()
- extension = "pgpro_stats"
+ self.extension = "pgpro_stats"
elif Pooler.extension_installed("pg_stat_statements"):
- extension = "pg_stat_statements"
+ self.extension = "pg_stat_statements"
else:
self.disable_and_exit_if_extension_is_not_installed(ext="pgpro_stats")
else:
if not Pooler.extension_installed("pg_stat_statements"):
self.disable_and_exit_if_extension_is_not_installed(ext="pg_stat_statements")
- extension = "pg_stat_statements"
+ self.extension = "pg_stat_statements"
- extension_schema = self.extension_schema(extension=extension)
+ extension_schema = self.extension_schema(extension=self.extension)
# TODO: add 13 and 14 items when pgpro_stats added new WAL metrics
all_items = self.Items.copy()
- if Pooler.server_version_greater("14"):
+
+ if Pooler.extension_installed("pgpro_stats") and Pooler.extension_version_greater("pgpro_stats", "1.8"):
+ info_view = 'pg_stat_statements_info'
+ if self.extension == "pgpro_stats":
+ info_view = 'pgpro_stats_info'
+
+ info_items = self.Items_pg_14
+ info_params = [x[1] for x in info_items]
+ info_result = Pooler.query(
+ self.query_info.format(metrics=(", ".join(info_params)), extension_schema=extension_schema, info_view_name=info_view))
+ for key, value in enumerate(info_result[0]):
+ zbx_key, value = "pgsql.{0}".format(
+ info_items[key][0]), int(value)
+ zbx.send(zbx_key, value, info_items[key][4])
+
+ all_items = self.Items_pgpro_stats_1_8.copy()
+ all_items += self.Items_pg_13
+
+ elif Pooler.server_version_greater("14"):
self.Items[5][1] = self.Items[5][1].format("total_exec_time+total_plan_time")
- if not Pooler.is_pgpro() or not Pooler.is_pgpro_ee():
- all_items += self.Items_pg_13
- info_items = self.Items_pg_14
- info_params = [x[1] for x in info_items]
- info_result = Pooler.query(
- self.query_info.format(metrics=(", ".join(info_params)), extension_schema=extension_schema))
- for key, value in enumerate(info_result[0]):
- zbx_key, value = "pgsql.{0}".format(
- info_items[key][0]), int(value)
- zbx.send(zbx_key, value, info_items[key][4])
- columns = [x[1] for x in all_items]
+ all_items += self.Items_pg_13
+ info_view = 'pgpro_stats_info'
+ if self.extension == "pg_stat_statements":
+ info_view = 'pg_stat_statements_info'
+ info_items = self.Items_pg_14
+ info_params = [x[1] for x in info_items]
+ info_result = Pooler.query(
+ self.query_info.format(metrics=(", ".join(info_params)),
+ extension_schema=extension_schema,
+ info_view_name=info_view))
+ for key, value in enumerate(info_result[0]):
+ zbx_key, value = "pgsql.{0}".format(
+ info_items[key][0]), int(value)
+ zbx.send(zbx_key, value, info_items[key][4])
+
elif Pooler.server_version_greater("13"):
self.Items[5][1] = self.Items[5][1].format("total_exec_time+total_plan_time")
- if not Pooler.is_pgpro() or not Pooler.is_pgpro_ee():
- all_items += self.Items_pg_13
- columns = [x[1] for x in all_items]
+ all_items += self.Items_pg_13
+
else:
self.Items[5][1] = self.Items[5][1].format("total_time")
- columns = [x[1] for x in all_items]
- result = Pooler.query(self.query[extension + "_bootstrap"].format(
+ columns = [x[1] for x in all_items]
+ result = Pooler.query(self.query[self.extension + "_bootstrap"].format(
columns=", ".join([x[0][x[0].find("[") + 1:x[0].find("]")] for x in all_items]),
metrics=(", ".join(columns)), extension_schema=extension_schema) if Pooler.is_bootstraped() else self.query[
- extension].format(metrics=(", ".join(columns)), extension_schema=extension_schema))
+ self.extension].format(metrics=(", ".join(columns)), extension_schema=extension_schema))
for key, value in enumerate(result[0]):
zbx_key, value = "pgsql.{0}".format(all_items[key][0]), int(value)
zbx.send(zbx_key, value, all_items[key][4])
@@ -177,7 +223,7 @@ def graphs(self, template, dashboard=False):
"key": self.right_type(self.key + keys[0] + "{0}", keys[1][:-1]),
"color": item[5][1],
"yaxisside": item[5][2],
- "drawtype": 2})
+ "drawtype": 2})
# create graph
graph = {
"name": graph_item[0],
@@ -193,20 +239,20 @@ def graphs(self, template, dashboard=False):
def keys_and_queries(self, template_zabbix):
if (Pooler.is_pgpro() or Pooler.is_pgpro_ee()) and Pooler.server_version_greater("12"):
if Pooler.extension_installed("pgpro_stats"):
- extension = "pgpro_stats"
+ self.extension = "pgpro_stats"
elif Pooler.extension_installed("pg_stat_statements"):
- extension = "pg_stat_statements"
+ self.extension = "pg_stat_statements"
else:
if Pooler.extension_installed("pg_stat_statements"):
- extension = "pg_stat_statements"
+ self.extension = "pg_stat_statements"
if Pooler.extension_installed("pgpro_stats") or Pooler.extension_installed("pg_stat_statements"):
- extension_schema = self.extension_schema(extension=extension)
+ extension_schema = self.extension_schema(extension=self.extension)
result = []
all_items = self.Items.copy()
- if LooseVersion(self.VersionPG) < LooseVersion("13"):
+ if Pooler.server_version_less("12"):
self.Items[5][1] = self.Items[5][1].format("total_time")
else:
self.Items[5][1] = self.Items[5][1].format("total_exec_time+total_plan_time")
@@ -217,24 +263,26 @@ def keys_and_queries(self, template_zabbix):
for i, item in enumerate(all_items):
keys = item[0].split("[")
- result.append("{0}[*],$2 $1 -c \"{1}\"".format("{0}{1}.{2}".format(self.key, keys[0], keys[1][:-1]),
- self.query[extension + "_bootstrap"].format(
- columns=", ".join(
- [x[0][x[0].find("[") + 1:x[0].find("]")] for x in
- all_items]), metrics=(", ".join(columns)),
- extension_schema=extension_schema) if Pooler.is_bootstraped() else
- self.query[extension].format(
- metrics=(", ".join(columns)),
- extension_schema=extension_schema)))
-
- if LooseVersion(self.VersionPG) >= LooseVersion("14"):
- if Pooler.is_pgpro() or Pooler.is_pgpro_ee():
- all_items += self.Items_pg_14
- for i, item in enumerate(all_items):
- keys = item[0].split("[")
- result.append("{0}[*],$2 $1 -c \"{1}\"".format("{0}{1}.{2}".format(self.key, keys[0], keys[1][:-1]),
- self.query_info.format(metrics=(item[1]),
- extension_schema=extension_schema)))
+ result.append("{0}[*],$2 $1 -c \"{1}\" | awk -F '|' '{{print ${2}}}'".format(
+ "{0}{1}.{2}".format(self.key, keys[0], keys[1][:-1]),
+ self.query[self.extension + "_bootstrap"].format(
+ columns=", ".join([x[0][x[0].find("[") + 1:x[0].find("]")] for x in all_items]),
+ metrics=(", ".join(columns)),
+ extension_schema=extension_schema) if Pooler.is_bootstraped() else
+ self.query[self.extension].format(
+ metrics=(", ".join(columns)),
+ extension_schema=extension_schema),
+ i + 1))
+
+ if Pooler.server_version_greater("14"):
+ if self.extension == "pg_stat_statements":
+ for i, item in enumerate(self.Items_pg_14):
+ keys = item[0].split("[")
+ result.append(
+ "{0}[*],$2 $1 -c \"{1}\" | awk -F '|' '{{print ${2}}}'".format(
+ "{0}{1}.{2}".format(self.key, keys[0], keys[1][:-1]),
+ self.query_info.format(metrics=(item[1]), extension_schema=extension_schema),
+ i + 1))
return template_zabbix.key_and_query(result)
else:
return
diff --git a/mamonsu/plugins/pgsql/wait_sampling.py b/mamonsu/plugins/pgsql/wait_sampling.py
index 51c498b5..81b3a185 100644
--- a/mamonsu/plugins/pgsql/wait_sampling.py
+++ b/mamonsu/plugins/pgsql/wait_sampling.py
@@ -44,7 +44,7 @@ class WaitSampling(Plugin):
WITH lock_table AS (
SELECT setoflocks.key,
json_data.key AS lock_type,
- json_data.value::int AS count
+ json_data.value::bigint AS count
FROM (SELECT key, value AS locktuple
FROM jsonb_each((SELECT wait_stats
FROM {extension_schema}.pgpro_stats_totals
@@ -106,7 +106,7 @@ class WaitSampling(Plugin):
WITH lock_table AS (
SELECT setoflocks.key,
json_data.key AS lock_type,
- json_data.value::int AS count
+ json_data.value::bigint AS count
FROM (SELECT key, value AS locktuple
FROM jsonb_each((SELECT wait_stats
FROM {extension_schema}.pgpro_stats_totals
@@ -181,7 +181,7 @@ class WaitSampling(Plugin):
WITH lock_table AS (
SELECT setoflocks.key,
json_data.key AS lock_type,
- json_data.value::int AS count
+ json_data.value::bigint AS count
FROM (SELECT key, value AS locktuple
FROM jsonb_each((SELECT wait_stats
FROM {extension_schema}.pgpro_stats_totals
diff --git a/mamonsu/plugins/pgsql/wal.py b/mamonsu/plugins/pgsql/wal.py
index 37caf305..6f621654 100644
--- a/mamonsu/plugins/pgsql/wal.py
+++ b/mamonsu/plugins/pgsql/wal.py
@@ -1,7 +1,7 @@
# -*- coding: utf-8 -*-
+import sys
from mamonsu.plugins.pgsql.plugin import PgsqlPlugin as Plugin
-from distutils.version import LooseVersion
from .pool import Pooler
from mamonsu.lib.zbx_template import ZbxTemplate
@@ -38,10 +38,10 @@ class Wal(Plugin):
# keys for PG 14 and higher
key_wal_records = "pgsql.wal.records.count{0}"
key_wal_fpi = "pgsql.wal.fpi.count{0}"
- key_wal_buffers_full = "pgsql.wal.buffers_full"
- key_wal_write_time = "pgsql.wal.write_time"
- key_wal_sync_time = "pgsql.wal.sync_time"
- key_wal_sync_duty = "pgsql.wal.sync_duty"
+ key_wal_buffers_full = "pgsql.wal.buffers_full{0}"
+ key_wal_write_time = "pgsql.wal.write_time{0}"
+ key_wal_sync_time = "pgsql.wal.sync_time{0}"
+ key_wal_sync_duty = "pgsql.wal.sync_duty{0}"
key_wall = "pgsql.wal.write{0}"
key_count_wall = "pgsql.wal.count{0}"
@@ -49,15 +49,17 @@ class Wal(Plugin):
def run(self, zbx):
# count of WAL files
- result = Pooler.run_sql_type("count_wal_files", args=["wal" if Pooler.server_version_greater("10.0") else "xlog"])
+ result = Pooler.run_sql_type("count_wal_files",
+ args=["wal" if Pooler.server_version_greater("10.0") else "xlog"])
zbx.send(self.key_count_wall.format("[]"), int(result[0][0]))
- if Pooler.server_version_greater("10"):
- result = Pooler.query(self.query_wal_lsn_diff)
- zbx.send(self.key_wall.format("[]"), float(result[0][0]), self.DELTA_SPEED)
- else:
- result = Pooler.query(self.query_xlog_lsn_diff)
- zbx.send(self.key_wall.format("[]"), float(result[0][0]), self.DELTA_SPEED)
+ if not Pooler.in_recovery():
+ if Pooler.server_version_greater("10"):
+ result = Pooler.query(self.query_wal_lsn_diff)
+ zbx.send(self.key_wall.format("[]"), float(result[0][0]), self.DELTA_SPEED)
+ else:
+ result = Pooler.query(self.query_xlog_lsn_diff)
+ zbx.send(self.key_wall.format("[]"), float(result[0][0]), self.DELTA_SPEED)
# PG 14 pg_stat_wal metrics
if Pooler.server_version_greater("14"):
@@ -110,26 +112,26 @@ def items(self, template, dashboard=False):
"delta": delta,
}) + template.item({
"name": "PostgreSQL WAL: Buffers Full",
- "key": self.key_wal_buffers_full,
+ "key": self.right_type(self.key_wal_buffers_full),
"value_type": self.VALUE_TYPE.numeric_float,
"delta": delta,
}) + template.item({
"name": "PostgreSQL WAL: Write Time (ms)",
- "key": self.key_wal_write_time,
+ "key": self.right_type(self.key_wal_write_time),
"value_type": self.VALUE_TYPE.numeric_float,
"delta": delta,
}) + template.item({
"name": "PostgreSQL WAL: Sync Time (ms)",
- "key": self.key_wal_sync_time,
+ "key": self.right_type(self.key_wal_sync_time),
"value_type": self.VALUE_TYPE.numeric_float,
"delta": delta,
}) + template.item({
"name": "PostgreSQL WAL: Sync Duty (%)",
- "key": self.key_wal_sync_duty,
+ "key": self.right_type(self.key_wal_sync_duty),
"value_type": Plugin.VALUE_TYPE.numeric_float,
"units": Plugin.UNITS.percent,
"type": Plugin.TYPE.CALCULATED,
- "params": "last(" + self.key_wal_sync_time + ")/10"
+ "params": "last(//{item})/10".format(item=self.right_type(self.key_wal_sync_time))
})
if not dashboard:
return result
@@ -151,26 +153,26 @@ def items(self, template, dashboard=False):
"page": ZbxTemplate.dashboard_page_wal["name"],
"size": ZbxTemplate.dashboard_widget_size_medium,
"position": 6}
- }]
+ }]
def keys_and_queries(self, template_zabbix):
result = []
- if LooseVersion(self.VersionPG) < LooseVersion("10"):
+ if Pooler.server_version_less("9.6"):
result.append("{0},$2 $1 -c \"{1}\"".format(self.key_wall.format("[*]"), self.query_xlog_lsn_diff))
result.append(
"{0},$2 $1 -c \"{1}\"".format(self.key_count_wall.format("[*]"),
- Pooler.SQL["count_wal_files"][0].format("xlog")))
+ Pooler.SQL["count_wal_files"][0].format("xlog")))
else:
result.append("{0},$2 $1 -c \"{1}\"".format(self.key_wall.format("[*]"), self.query_wal_lsn_diff))
result.append("{0},$2 $1 -c \"{1}\"".format(self.key_count_wall.format("[*]"),
- Pooler.SQL["count_wal_files"][0].format("wal")))
-
- if LooseVersion(self.VersionPG) >= LooseVersion("14"):
- result.append("{0},$2 $1 -c \"{1}\"".format(self.key_wal_records.format("[*]"), self.query_wal_records))
- result.append("{0},$2 $1 -c \"{1}\"".format(self.key_wal_fpi.format("[*]"), self.query_wal_fpi))
- result.append(
- "{0},$2 $1 -c \"{1}\"".format(self.key_wal_buffers_full.format("[*]"), self.query_wal_buffers_full))
- result.append(
- "{0},$2 $1 -c \"{1}\"".format(self.key_wal_write_time.format("[*]"), self.query_wal_write_time))
- result.append("{0},$2 $1 -c \"{1}\"".format(self.key_wal_sync_time.format("[*]"), self.query_wal_sync_time))
+ Pooler.SQL["count_wal_files"][0].format("wal")))
+ if Pooler.server_version_greater("14"):
+ result.append("{0},$2 $1 -c \"{1}\"".format(self.key_wal_records.format("[*]"), self.query_wal_records))
+ result.append("{0},$2 $1 -c \"{1}\"".format(self.key_wal_fpi.format("[*]"), self.query_wal_fpi))
+ result.append(
+ "{0},$2 $1 -c \"{1}\"".format(self.key_wal_buffers_full.format("[*]"), self.query_wal_buffers_full))
+ result.append(
+ "{0},$2 $1 -c \"{1}\"".format(self.key_wal_write_time.format("[*]"), self.query_wal_write_time))
+ result.append(
+ "{0},$2 $1 -c \"{1}\"".format(self.key_wal_sync_time.format("[*]"), self.query_wal_sync_time))
return template_zabbix.key_and_query(result)
diff --git a/mamonsu/plugins/system/linux/disk_sizes.py b/mamonsu/plugins/system/linux/disk_sizes.py
index e8e7ba0f..d4618120 100644
--- a/mamonsu/plugins/system/linux/disk_sizes.py
+++ b/mamonsu/plugins/system/linux/disk_sizes.py
@@ -12,13 +12,15 @@ class DiskSizes(Plugin):
# tmp_query_agent_percent_inode_free = " "FIXME for inode
key = "system.vfs"
- DEFAULT_CONFIG = {
- "vfs_percent_free": str(10),
- "vfs_inode_percent_free": str(10)}
+ # key: (macro, value)
+ plugin_macros = {
+ "vfs_percent_free": [("macro", "{$VFS_PERCENT_FREE}"), ("value", 10)],
+ "vfs_inode_percent_free": [("macro", "{$VFS_INODE_PERCENT_FREE}"), ("value", 10)]
+ }
ExcludeFsTypes = [
"none", "unknown", "rootfs", "iso9660", "squashfs", "udf", "romfs", "ramfs", "debugfs", "cgroup", "cgroup_root",
- "pstore", "devtmpfs", "autofs", "cgroup", "configfs", "devpts", "efivarfs", "fusectl", "fuse.gvfsd-fuse",
+ "pstore", "devtmpfs", "autofs", "cgroup2", "configfs", "devpts", "efivarfs", "fusectl", "fuse.gvfsd-fuse",
"hugetlbfs", "mqueue", "binfmt_misc", "nfsd", "proc", "pstore", "selinuxfs", "rpc_pipefs", "securityfs",
"sysfs", "nsfs", "tmpfs", "tracefs"
]
@@ -54,6 +56,15 @@ def run(self, zbx):
zbx.send("system.vfs.discovery[]", zbx.json({"data": points}))
+ def macros(self, template, dashboard=False):
+ result = ""
+ for macro in self.plugin_macros.keys():
+ result += template.mamonsu_macro(defaults=self.plugin_macros[macro])
+ if not dashboard:
+ return result
+ else:
+ return []
+
def discovery_rules(self, template, dashboard=False):
if Plugin.Type == "mamonsu":
@@ -61,7 +72,7 @@ def discovery_rules(self, template, dashboard=False):
else:
key_discovery = "system.vfs.discovery"
rule = {
- "name": "VFS Discovery",
+ "name": "System: VFS Discovery",
"key": key_discovery
}
if Plugin.old_zabbix:
@@ -136,21 +147,21 @@ def discovery_rules(self, template, dashboard=False):
triggers = [
{
- "name": "Free disk space less than 10% on mountpoint "
+ "name": "System: free disk space less than 10% on mountpoint "
"{#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})",
"expression": "{#TEMPLATE:system.vfs."
"percent_free[{#MOUNTPOINT}].last"
- "()}<" + self.plugin_config("vfs_percent_free")
+ "()}<" + self.plugin_macros["vfs_percent_free"][0][1]
},
]
if Plugin.Type == "mamonsu":
triggers.append(
{
- "name": "Free inode space less than 10% on mountpoint "
+ "name": "System: free inode space less than 10% on mountpoint "
"{#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})",
"expression": "{#TEMPLATE:system.vfs.percent_inode_free[{#MOUNTPOINT}].last"
- "()}<" + self.plugin_config("vfs_inode_percent_free")
+ "()}<" + self.plugin_macros["vfs_inode_percent_free"][0][1]
}
)
diff --git a/mamonsu/plugins/system/linux/disk_stats.py b/mamonsu/plugins/system/linux/disk_stats.py
index 696b5f7f..e5381cad 100644
--- a/mamonsu/plugins/system/linux/disk_stats.py
+++ b/mamonsu/plugins/system/linux/disk_stats.py
@@ -23,7 +23,7 @@ class DiskStats(Plugin):
# Track only physical devices without logical partitions
OnlyPhysicalDevices = True
- re_stat = re.compile("^(?:\s+\d+){2}\s+([\w\d]+) (.*)$")
+ re_stat = re.compile(r"^(?:\s+\d+){2}\s+([\w\d]+) (.*)$")
# rd_ios rd_merges rd_sectors rd_ticks
# wr_ios wr_merges wr_sectors wr_ticks
@@ -43,7 +43,7 @@ def run(self, zbx):
if m is None:
continue
dev, val = m.group(1), m.group(2)
- if self.OnlyPhysicalDevices and re.search("\d+$", dev): # get drive name without digits at the end
+ if self.OnlyPhysicalDevices and re.search(r"\d+$", dev): # get drive name without digits at the end
continue
val = [int(x) for x in val.split()]
read_op, read_sc, write_op, write_sc, ticks = val[0], val[2], val[4], val[6], val[9]
diff --git a/mamonsu/plugins/system/linux/memory.py b/mamonsu/plugins/system/linux/memory.py
index ef95f62d..c0906afa 100644
--- a/mamonsu/plugins/system/linux/memory.py
+++ b/mamonsu/plugins/system/linux/memory.py
@@ -5,9 +5,9 @@
class Memory(Plugin):
AgentPluginType = "sys"
- query_agent = "cat /proc/meminfo | awk '/^{0}\:/ "
- query_agent_used = "MemTotal=$(cat /proc/meminfo | awk '/MemTotal\:/ { print $2 }'); " \
- "SUM=$(cat /proc/meminfo | awk '/(MemFree|Buffers|(Swap)?Cached|Slab|PageTables)\:/ " \
+ query_agent = r"cat /proc/meminfo | awk '/^{0}\:/ "
+ query_agent_used = r"MemTotal=$(cat /proc/meminfo | awk '/MemTotal\:/ { print $2 }'); " \
+ r"SUM=$(cat /proc/meminfo | awk '/(MemFree|Buffers|(Swap)?Cached|Slab|PageTables)\:/ " \
"{ SUM += $2 } END {print SUM}'); echo $((($MemTotal-$SUM)*1024))"
query_agent_swap = "expr `grep -Ei 'Swap(Total|Free)' /proc/meminfo | awk '{print $2 * 1024}' | paste -s -d '-' " \
"| sed -E 's/-/ - /g'` "
diff --git a/mamonsu/plugins/system/linux/net.py b/mamonsu/plugins/system/linux/net.py
index 901c207f..a5f86d8b 100644
--- a/mamonsu/plugins/system/linux/net.py
+++ b/mamonsu/plugins/system/linux/net.py
@@ -50,7 +50,7 @@ def discovery_rules(self, template, dashboard=False):
})
rule = {
- "name": "Net Iface Discovery",
+ "name": "System: net Iface Discovery",
"key": key_discovery
}
if Plugin.old_zabbix:
diff --git a/mamonsu/plugins/system/linux/pg_probackup.py b/mamonsu/plugins/system/linux/pg_probackup.py
index 97023acb..89025ca6 100644
--- a/mamonsu/plugins/system/linux/pg_probackup.py
+++ b/mamonsu/plugins/system/linux/pg_probackup.py
@@ -107,7 +107,7 @@ def run(self, zbx):
def discovery_rules(self, template, dashboard=False):
rule = {
- "name": "pg_probackup discovery",
+ "name": "pg_probackup Discovery",
"key": self.key_main.format("[{0}]".format(self.Macros[self.Type])),
}
if Plugin.old_zabbix:
@@ -129,21 +129,21 @@ def discovery_rules(self, template, dashboard=False):
items = [
{
"key": self.right_type(self.key_dir_size, var_discovery="{#BACKUPDIR},"),
- "name": "pg_probackup dir {#BACKUPDIR}: size",
+ "name": "pg_probackup dir {#BACKUPDIR}: Size",
"units": Plugin.UNITS.bytes,
"value_type": Plugin.VALUE_TYPE.numeric_unsigned,
"delay": self.plugin_config("interval")
},
{
"key": self.right_type(self.key_dir_error, var_discovery="{#BACKUPDIR},"),
- "name": "pg_probackup dir {#BACKUPDIR}: error",
+ "name": "pg_probackup dir {#BACKUPDIR}: Error",
"value_type": Plugin.VALUE_TYPE.text,
"delay": self.plugin_config("interval")
},
]
graphs = [
{
- "name": "pg_probackup backup dir: {#BACKUPDIR} size",
+ "name": "pg_probackup Backup dir: {#BACKUPDIR} Size",
"type": 1,
"items": [
{
@@ -156,7 +156,7 @@ def discovery_rules(self, template, dashboard=False):
]
triggers = [
{
- "name": "Error in pg_probackup dir {#BACKUPDIR} (hostname={HOSTNAME} value={ITEM.LASTVALUE})",
+ "name": "pg_probackup: error in dir {#BACKUPDIR} (hostname={HOSTNAME} value={ITEM.LASTVALUE})",
"expression": "{#TEMPLATE:pg_probackup.dir.error[{#BACKUPDIR}].str(ok)}<>1"
}
]
diff --git a/mamonsu/plugins/system/linux/proc_stat.py b/mamonsu/plugins/system/linux/proc_stat.py
index 7b47ed6a..237e1955 100644
--- a/mamonsu/plugins/system/linux/proc_stat.py
+++ b/mamonsu/plugins/system/linux/proc_stat.py
@@ -16,7 +16,7 @@ class ProcStat(Plugin):
# alert fork-rate
ForkRate = 500
# /proc/stat all cpu line
- re_stat = re.compile("cpu\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)")
+ re_stat = re.compile(r"cpu\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)")
ProcessItems = [
# key, zbx_key, name, delta, color, side
@@ -142,7 +142,7 @@ def graphs(self, template, dashboard=False):
def triggers(self, template, dashboard=False):
return template.trigger(
{
- "name": "Process fork-rate too frequently on {HOSTNAME}",
+ "name": "System: process fork-rate too frequently on {HOSTNAME}",
"expression": "{#TEMPLATE:" + self.right_type("system.processes{0}", "forkrate") +
".min(5m)}>" + str(self.ForkRate)
}
diff --git a/mamonsu/plugins/system/linux/scripts.py b/mamonsu/plugins/system/linux/scripts.py
index 1ab25e73..58c2ff6c 100644
--- a/mamonsu/plugins/system/linux/scripts.py
+++ b/mamonsu/plugins/system/linux/scripts.py
@@ -14,13 +14,13 @@ class Scripts(object):
while getopts "s::a:sj:uphvt:" OPTION; do
case ${OPTION} in
-
+
j)
JSON=1
JSON_ATTR=(${OPTARG})
IFS="${IFS_DEFAULT}"
;;
-
+
esac
done
@@ -46,10 +46,10 @@ class Scripts(object):
count=1
while read line; do
values=(${line})
- if [ $(contains "${list_str}" "," "${values[8]}") -eq 0 ]; then
+ if [ $(contains "${list_str}" "," "${values[8]}") -eq 0 ]; then
if [[ ${output} != " " ]]; then
echo " ${output}"
- fi
+ fi
output='{ '
output+='"'{#${JSON_ATTR[0]}}'"'
output+=':'
@@ -57,7 +57,7 @@ class Scripts(object):
output+=' }'
tmp="${output}"
output="${output},"
- fi
+ fi
let "count=count+1"
done <<< "${rval}"
echo " ${tmp}"
@@ -76,22 +76,22 @@ class Scripts(object):
IFS_DEFAULT="${IFS}"
#
#################################################################################
-
-
+
+
while getopts "s::a:sj:uphvt:" OPTION; do
case ${OPTION} in
-
+
j)
JSON=1
JSON_ATTR=(${OPTARG})
IFS="${IFS_DEFAULT}"
;;
-
+
esac
done
-
+
#################################################################################
-
+
output=" "
rval=`cat /proc/diskstats`
if [[ ${JSON} -eq 1 ]]; then
@@ -102,9 +102,9 @@ class Scripts(object):
while read line; do
if [[ ${line} != '' ]]; then
IFS="|" values=(${line})
-
- if [[ $count == 1 ]]; then # for loop0 case
- new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \+/ /gp'`
+
+ if [[ $count == 1 ]]; then # for loop0 case
+ new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \\+/ /gp'`
new_value3=`echo "$new_value2" | cut -d " " -f 3`
read_op=`echo "$new_value2" | cut -d " " -f 4`
read_sc=`echo "$new_value2" | cut -d " " -f 6`
@@ -112,7 +112,7 @@ class Scripts(object):
write_sc=`echo "$new_value2" | cut -d " " -f 10`
ticks=`echo "$new_value2" | cut -d " " -f 13`
else
- new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \+/ /gp'`
+ new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \\+/ /gp'`
new_value3=`echo "$new_value2" | cut -d " " -f 4`
read_op=`echo "$new_value2" | cut -d " " -f 5`
read_sc=`echo "$new_value2" | cut -d " " -f 7`
@@ -123,8 +123,8 @@ class Scripts(object):
if [[ $new_value3 != *"loop"* ]] && [[ $new_value3 != *"ram"* ]] && [[ $new_value3 != *[0-9]* ]]; then
if [[ ${output} != " " ]]; then
echo " ${output}"
- fi
- value=$(($read_op+$value))
+ fi
+ value=$(($read_op+$value))
output='{ '
output+='"'{#${JSON_ATTR[0]}}'"'
output+=':'
@@ -142,7 +142,7 @@ class Scripts(object):
else
echo "${rval:-0}"
fi
-
+
exit ${rcode}
""",
@@ -156,26 +156,26 @@ class Scripts(object):
if [[ ${line} != '' ]]; then
IFS="|" values=(${line})
- if [[ $count == 1 ]]; then # for loop0 case
- new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \+/ /gp'`
+ if [[ $count == 1 ]]; then # for loop0 case
+ new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \\+/ /gp'`
# echo $new_value2
new_value3=`echo "$new_value2" | cut -d " " -f 3`
read_op=`echo "$new_value2" | cut -d " " -f 4`
-
+
else
- new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \+/ /gp'`
+ new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \\+/ /gp'`
new_value3=`echo "$new_value2" | cut -d " " -f 4`
read_op=`echo "$new_value2" | cut -d " " -f 5`
-
+
fi
re='^[0-9]+$'
- has_digits='no'
+ has_digits='no'
if [[ "${new_value3: -1}" =~ $re ]]; then
has_digits='yes'
fi
if [[ $new_value3 != *"loop"* ]] && [[ $new_value3 != *"ram"* ]] && [[ $has_digits == 'no' ]]; then
- value=$(($read_op+$value))
-
+ value=$(($read_op+$value))
+
fi
fi
@@ -195,23 +195,23 @@ class Scripts(object):
if [[ ${line} != '' ]]; then
IFS="|" values=(${line})
- if [[ $count == 1 ]]; then # for loop0 case
- new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \+/ /gp'`
+ if [[ $count == 1 ]]; then # for loop0 case
+ new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \\+/ /gp'`
# echo $new_value2
- new_value3=`echo "$new_value2" | cut -d " " -f 3`
+ new_value3=`echo "$new_value2" | cut -d " " -f 3`
read_sc=`echo "$new_value2" | cut -d " " -f 6`
else
- new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \+/ /gp'`
+ new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \\+/ /gp'`
new_value3=`echo "$new_value2" | cut -d " " -f 4`
- read_sc=`echo "$new_value2" | cut -d " " -f 7`
+ read_sc=`echo "$new_value2" | cut -d " " -f 7`
fi
re='^[0-9]+$'
- has_digits='no'
+ has_digits='no'
if [[ "${new_value3: -1}" =~ $re ]]; then
has_digits='yes'
fi
if [[ $new_value3 != *"loop"* ]] && [[ $new_value3 != *"ram"* ]] && [[ $has_digits == 'no' ]]; then
- value=$(($read_sc+$value))
+ value=$(($read_sc+$value))
fi
fi
let "count=count+1"
@@ -230,28 +230,28 @@ class Scripts(object):
if [[ ${line} != '' ]]; then
IFS="|" values=(${line})
- if [[ $count == 1 ]]; then # for loop0 case
- new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \+/ /gp'`
- new_value3=`echo "$new_value2" | cut -d " " -f 3`
+ if [[ $count == 1 ]]; then # for loop0 case
+ new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \\+/ /gp'`
+ new_value3=`echo "$new_value2" | cut -d " " -f 3`
write_op=`echo "$new_value2" | cut -d " " -f 8`
-
+
else
- new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \+/ /gp'`
+ new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \\+/ /gp'`
new_value3=`echo "$new_value2" | cut -d " " -f 4`
-
+
write_op=`echo "$new_value2" | cut -d " " -f 9`
-
+
fi
re='^[0-9]+$'
- has_digits='no'
+ has_digits='no'
if [[ "${new_value3: -1}" =~ $re ]]; then
has_digits='yes'
fi
if [[ $new_value3 != *"loop"* ]] && [[ $new_value3 != *"ram"* ]] && [[ $has_digits == 'no' ]];then
- #echo $write_op
+ #echo $write_op
+
+ value=$(($write_op+$value))
- value=$(($write_op+$value))
-
fi
fi
@@ -270,25 +270,25 @@ class Scripts(object):
if [[ ${line} != '' ]]; then
IFS="|" values=(${line})
- if [[ $count == 1 ]]; then # for loop0 case
- new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \+/ /gp'`
+ if [[ $count == 1 ]]; then # for loop0 case
+ new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \\+/ /gp'`
new_value3=`echo "$new_value2" | cut -d " " -f 3`
write_sc=`echo "$new_value2" | cut -d " " -f 10`
else
- new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \+/ /gp'`
+ new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \\+/ /gp'`
new_value3=`echo "$new_value2" | cut -d " " -f 4`
write_sc=`echo "$new_value2" | cut -d " " -f 11`
fi
re='^[0-9]+$'
- has_digits='no'
+ has_digits='no'
if [[ "${new_value3: -1}" =~ $re ]]; then
has_digits='yes'
fi
#echo $values
if [[ $new_value3 != *"loop"* ]] && [[ $new_value3 != *"ram"* ]] && [[ $has_digits == 'no' ]]; then
- #echo $write_sc
+ #echo $write_sc
#echo $new_value3
- value=$(($write_sc+$value))
+ value=$(($write_sc+$value))
fi
fi
let "count=count+1"
@@ -302,7 +302,7 @@ class Scripts(object):
#################################################################################
while getopts "s::a:sj:uphvt:" OPTION; do
case ${OPTION} in
-
+
j)
JSON=1
JSON_ATTR=(${OPTARG})
@@ -323,7 +323,7 @@ class Scripts(object):
if [[ "${values[0]}" != *"lo:"* ]] && [[ "${#values[@]}">1 ]]; then
if [[ ${output} != " " ]] && [[ $count > 4 ]]; then
echo " ${output}"
- fi
+ fi
output='{ '
output+='"'{#${JSON_ATTR[0]}}'"'
output+=':'
@@ -332,7 +332,7 @@ class Scripts(object):
output+=' }'
tmp="${output}"
output="${output},"
- fi
+ fi
let "count=count+1"
done <<< "${rval}"
echo " ${tmp}"
@@ -356,19 +356,19 @@ class Scripts(object):
if [[ ${line} != '' ]]; then
IFS="|" values=(${line})
- if [[ $count == 1 ]]; then # for loop0 case
- new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \+/ /gp'`
+ if [[ $count == 1 ]]; then # for loop0 case
+ new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \\+/ /gp'`
# echo $new_value2
new_value3=`echo "$new_value2" | cut -d " " -f 3`
ticks=`echo "$new_value2" | cut -d " " -f 13`
else
- new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \+/ /gp'`
+ new_value2=`echo ${values[0]} | sed -n '/[0-9]/s/ \\+/ /gp'`
new_value3=`echo "$new_value2" | cut -d " " -f 4`
ticks=`echo "$new_value2" | cut -d " " -f 14`
fi
if [[ $new_value3 != *"loop"* ]] && [[ $new_value3 != *"ram"* ]]; then
- #echo $ticks
- value=$(($ticks+$value))
+ #echo $ticks
+ value=$(($ticks+$value))
fi
fi
let "count=count+1"
diff --git a/mamonsu/plugins/system/linux/uptime.py b/mamonsu/plugins/system/linux/uptime.py
index 94d07867..5cfabdb6 100644
--- a/mamonsu/plugins/system/linux/uptime.py
+++ b/mamonsu/plugins/system/linux/uptime.py
@@ -4,7 +4,10 @@
class SystemUptime(Plugin):
AgentPluginType = "sys"
- DEFAULT_CONFIG = {"uptime": str(60 * 5)}
+ # key: (macro, value)
+ plugin_macros = {
+ "system_uptime": [("macro", "{$SYSTEM_UPTIME}"), ("value", 60 * 5)]
+ }
query_agent = "cat /proc/uptime | awk '{ print int($1) }'"
key = "system.uptime{0}"
@@ -24,14 +27,24 @@ def items(self, template, dashboard=False):
else:
return []
+ def macros(self, template, dashboard=False):
+ result = ""
+ for macro in self.plugin_macros.keys():
+ result += template.mamonsu_macro(defaults=self.plugin_macros[macro])
+ if not dashboard:
+ return result
+ else:
+ return []
+
def triggers(self, template, dashboard=False):
return template.trigger(
{
- "name": "System was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})",
- "expression": "{#TEMPLATE:" + self.right_type(self.key) + ".last()}<" + self.plugin_config("uptime")
+ "name": "System: {HOSTNAME} was restarted (start time={ITEM.LASTVALUE})",
+ "expression": "{#TEMPLATE:" + self.right_type(self.key) + ".last()}<" + self.plugin_macros["system_uptime"][0][1]
}
)
- def keys_and_queries(self, template_zabbix):
- result = ["system.uptime,{0}".format(self.query_agent)]
- return template_zabbix.key_and_query(result)
+ # TODO: define another metric key because it duplicates native zabbix agents keys
+ # def keys_and_queries(self, template_zabbix):
+ # result = ["system.uptime,{0}".format(self.query_agent)]
+ # return template_zabbix.key_and_query(result)
diff --git a/mamonsu/plugins/system/windows/cpu.py b/mamonsu/plugins/system/windows/cpu.py
index 54f58721..6cf8b701 100644
--- a/mamonsu/plugins/system/windows/cpu.py
+++ b/mamonsu/plugins/system/windows/cpu.py
@@ -64,6 +64,6 @@ def graphs(self, template, dashboard=False):
def triggers(self, template, dashboard=False):
return template.trigger({
- "name": "CPU privileged time is too big on {HOSTNAME}",
+ "name": "System: CPU privileged time is too big on {HOSTNAME}",
"expression": "{#TEMPLATE:system.cpu[privileged_time].last()}>" + str(self.MaxPrivilegedTime)
})
diff --git a/mamonsu/tools/bootstrap/sql.py b/mamonsu/tools/bootstrap/sql.py
index ecbc3dd6..bf99442a 100644
--- a/mamonsu/tools/bootstrap/sql.py
+++ b/mamonsu/tools/bootstrap/sql.py
@@ -7,9 +7,14 @@
$do$
BEGIN
IF NOT EXISTS (
- SELECT FROM pg_catalog.pg_roles
+ SELECT FROM pg_catalog.pg_roles
WHERE rolname = '{0}') THEN
CREATE ROLE {0} LOGIN PASSWORD '{0}';
+ IF EXISTS (
+ SELECT FROM pg_catalog.pg_roles
+ WHERE rolname = 'pg_monitor') THEN
+ GRANT pg_monitor TO {0};
+ END IF;
END IF;
END
$do$;
@@ -81,6 +86,49 @@
END
$do$;
+DO
+$do$
+BEGIN
+ IF (SELECT setting::integer FROM pg_settings WHERE name = 'server_version_num') >= 100000 THEN
+ DROP FUNCTION IF EXISTS mamonsu.autovacuum_utilization();
+ CREATE OR REPLACE FUNCTION mamonsu.autovacuum_utilization()
+ RETURNS FLOAT AS $$
+ WITH count_tb AS (
+ SELECT count(*)::float AS count
+ FROM pg_catalog.pg_stat_activity
+ WHERE backend_type = 'autovacuum worker'
+ ),
+ settings_tb AS (
+ SELECT setting::float
+ FROM pg_catalog.pg_settings
+ WHERE name = 'autovacuum_max_workers'
+ )
+ SELECT count_tb.count*100/settings_tb.setting
+ FROM count_tb, settings_tb
+ $$ LANGUAGE SQL SECURITY DEFINER;
+ ELSE
+ DROP FUNCTION IF EXISTS mamonsu.autovacuum_utilization();
+ CREATE OR REPLACE FUNCTION mamonsu.autovacuum_utilization()
+ RETURNS FLOAT AS $$
+ WITH count_tb AS (
+ SELECT count(*)::float AS count
+ FROM pg_catalog.pg_stat_activity
+ WHERE query LIKE '%%autovacuum%%'
+ AND state <> 'idle'
+ AND pid <> pg_catalog.pg_backend_pid()
+ ),
+ settings_tb AS (
+ SELECT setting::float
+ FROM pg_catalog.pg_settings
+ WHERE name = 'autovacuum_max_workers'
+ )
+ SELECT count_tb.count*100/settings_tb.setting
+ FROM count_tb, settings_tb
+ $$ LANGUAGE SQL SECURITY DEFINER;
+ END IF;
+END
+$do$;
+
DO
$do$
BEGIN
@@ -118,15 +166,15 @@
DROP FUNCTION IF EXISTS mamonsu.get_oldest_transaction();
CREATE or REPLACE FUNCTION mamonsu.get_oldest_transaction()
RETURNS DOUBLE PRECISION AS $$
- SELECT
- CASE WHEN extract(epoch from max(now() - xact_start)) IS NOT null
+ SELECT
+ CASE WHEN extract(epoch from max(now() - xact_start)) IS NOT null
AND extract(epoch from max(now() - xact_start))>0
- THEN extract(epoch from max(now() - xact_start))
- ELSE 0
- END
- FROM pg_catalog.pg_stat_activity
- WHERE
- pid NOT IN(select pid from pg_stat_replication) AND
+ THEN extract(epoch from max(now() - xact_start))
+ ELSE 0
+ END
+ FROM pg_catalog.pg_stat_activity
+ WHERE
+ pid NOT IN(select pid from pg_stat_replication) AND
pid <> pg_backend_pid()
$$ LANGUAGE SQL SECURITY DEFINER;
@@ -177,17 +225,34 @@
CREATE OR REPLACE FUNCTION mamonsu.prepared_transaction()
RETURNS TABLE(count_prepared BIGINT, oldest_prepared BIGINT) AS $$
SELECT COUNT(*) AS count_prepared,
-coalesce (ROUND(MAX(EXTRACT (EPOCH FROM (now() - prepared)))),0)::bigint AS oldest_prepared
+coalesce (ROUND(MAX(EXTRACT (EPOCH FROM (now() - prepared)))),0)::bigint AS oldest_prepared
FROM pg_catalog.pg_prepared_xacts$$ LANGUAGE SQL SECURITY DEFINER;
DROP FUNCTION IF EXISTS mamonsu.count_{3}_lag_lsn();
CREATE OR REPLACE FUNCTION mamonsu.count_{3}_lag_lsn()
-RETURNS TABLE(application_name TEXT, {8} total_lag INTEGER) AS $$
+RETURNS TABLE(application_name TEXT, {8} total_lag BIGINT) AS $$
SELECT application_name,
- {6}
- coalesce((pg_{7}_diff(pg_current_{7}(), replay_{9}))::int, 0) AS total_lag
+ {6}
+ coalesce((pg_{7}_diff(pg_current_{7}(), replay_{9}))::bigint, 0) AS total_lag
FROM pg_stat_replication
$$ LANGUAGE SQL SECURITY DEFINER;
+
+DROP FUNCTION IF EXISTS mamonsu.bytes_held_by_inactive_slot_on_master();
+CREATE OR REPLACE FUNCTION mamonsu.bytes_held_by_inactive_slot_on_master()
+RETURNS TABLE(slot_name TEXT, wal_held_bytes BIGINT) AS $$
+SELECT slot_name::TEXT, coalesce((pg_{7}_diff(pg_current_wal_lsn(), restart_lsn))::bigint, 0) AS wal_held_bytes
+FROM pg_replication_slots
+WHERE active = 'false'
+$$ LANGUAGE SQL SECURITY DEFINER;
+
+DROP FUNCTION IF EXISTS mamonsu.bytes_held_by_inactive_slot_on_replica();
+CREATE OR REPLACE FUNCTION mamonsu.bytes_held_by_inactive_slot_on_replica()
+RETURNS TABLE(slot_name TEXT, wal_held_bytes BIGINT) AS $$
+SELECT slot_name::TEXT, coalesce((pg_{7}_diff(pg_last_wal_replay_lsn(), restart_lsn))::bigint, 0) AS wal_held_bytes
+FROM pg_replication_slots
+WHERE active = 'false'
+$$ LANGUAGE SQL SECURITY DEFINER;
+
"""
CreatePgBuffercacheFunctionsSQL = """
@@ -239,18 +304,18 @@
FROM pg_extension e
JOIN pg_namespace n
ON e.extnamespace = n.oid
- WHERE e.extname = 'pgpro_stats';
+ WHERE e.extname = 'pgpro_stats';
EXECUTE 'DROP FUNCTION IF EXISTS mamonsu.wait_sampling_all_locks();
CREATE OR REPLACE FUNCTION mamonsu.wait_sampling_all_locks()
RETURNS TABLE(lock_type text, count bigint) AS $$
WITH lock_table AS (
SELECT setoflocks.key,
json_data.key AS lock_type,
- json_data.value::int AS count
+ json_data.value::bigint AS count
FROM (SELECT key, value AS locktuple
FROM jsonb_each((SELECT wait_stats
- FROM ' || extension_schema || '.pgpro_stats_totals
- WHERE object_type = ''cluster''))) setoflocks,
+ FROM ' || extension_schema || '.pgpro_stats_totals()
+ WHERE object_type = ''cluster''))) setoflocks,
jsonb_each(setoflocks.locktuple) AS json_data)
SELECT
CASE
@@ -275,11 +340,11 @@
WITH lock_table AS (
SELECT setoflocks.key,
json_data.key AS lock_type,
- json_data.value::int AS count
+ json_data.value::bigint AS count
FROM (SELECT key, value AS locktuple
FROM jsonb_each((SELECT wait_stats
- FROM ' || extension_schema || '.pgpro_stats_totals
- WHERE object_type = ''cluster''))) setoflocks,
+ FROM ' || extension_schema || '.pgpro_stats_totals()
+ WHERE object_type = ''cluster''))) setoflocks,
jsonb_each(setoflocks.locktuple) AS json_data)
SELECT
lock_type,
@@ -295,11 +360,11 @@
WITH lock_table AS (
SELECT setoflocks.key,
json_data.key AS lock_type,
- json_data.value::int AS count
+ json_data.value::bigint AS count
FROM (SELECT key, value AS locktuple
FROM jsonb_each((SELECT wait_stats
- FROM ' || extension_schema || '.pgpro_stats_totals
- WHERE object_type = ''cluster''))) setoflocks,
+ FROM ' || extension_schema || '.pgpro_stats_totals()
+ WHERE object_type = ''cluster''))) setoflocks,
jsonb_each(setoflocks.locktuple) AS json_data
WHERE setoflocks.key IN (''Lock'', ''LWLock'', ''LWLockTranche'', ''LWLockNamed''))
SELECT
@@ -367,13 +432,13 @@
FROM pg_extension e
JOIN pg_namespace n
ON e.extnamespace = n.oid
- WHERE e.extname = 'pgpro_stats';
+ WHERE e.extname = 'pgpro_stats';
EXECUTE 'DROP FUNCTION IF EXISTS mamonsu.statements_pro();
CREATE OR REPLACE FUNCTION mamonsu.statements_pro()
RETURNS TABLE({columns}) AS $$
SELECT {metrics}
- FROM ' || extension_schema || '.pgpro_stats_totals
- WHERE object_type = ''cluster'';
+ FROM ' || extension_schema || '.pgpro_stats_totals()
+ WHERE object_type = ''cluster'';
$$ LANGUAGE SQL SECURITY DEFINER;';
ELSE
EXIT functions_creation;
diff --git a/mamonsu/tools/bootstrap/start.py b/mamonsu/tools/bootstrap/start.py
index 62aae9f2..6fbc5821 100644
--- a/mamonsu/tools/bootstrap/start.py
+++ b/mamonsu/tools/bootstrap/start.py
@@ -237,12 +237,19 @@ def run_deploy():
if Pooler.is_pgpro() or Pooler.is_pgpro_ee():
bootstrap_extension_queries = fill_query_params(CreateWaitSamplingFunctionsSQL)
Pooler.query(bootstrap_extension_queries)
- statements_items = [x[1] for x in Statements.Items]
- statements_items[5] = statements_items[5].format("total_exec_time+total_plan_time")
- statements_columns = [x[0][x[0].find("[")+1:x[0].find("]")] for x in Statements.Items]
- bootstrap_extension_queries = CreateStatementsFunctionsSQL.format(
- columns=" bigint, ".join(statements_columns) + " bigint", metrics=(", ".join(statements_items)))
- Pooler.query(bootstrap_extension_queries)
+ if Pooler.extension_installed("pgpro_stats") and Pooler.extension_version_greater("pgpro_stats", "1.8"):
+ statements_items = [x[1] for x in Statements.Items_pgpro_stats_1_8] + [x[1] for x in Statements.Items_pg_13]
+ statements_columns = [x[0][x[0].find("[")+1:x[0].find("]")] for x in Statements.Items_pgpro_stats_1_8] + [x[0][x[0].find("[")+1:x[0].find("]")] for x in Statements.Items_pg_13]
+ bootstrap_extension_queries = CreateStatementsFunctionsSQL.format(
+ columns=" bigint, ".join(statements_columns) + " bigint", metrics=(", ".join(statements_items)))
+ Pooler.query(bootstrap_extension_queries)
+ elif Pooler.server_version_greater("12"):
+ statements_items = [x[1] for x in Statements.Items] + ([x[1] for x in Statements.Items_pg_13] if Pooler.server_version_greater("13") else [])
+ statements_items[5] = statements_items[5].format("total_exec_time+total_plan_time")
+ statements_columns = [x[0][x[0].find("[")+1:x[0].find("]")] for x in Statements.Items] + ([x[0][x[0].find("[")+1:x[0].find("]")] for x in Statements.Items_pg_13] if Pooler.server_version_greater("13") else [])
+ bootstrap_extension_queries = CreateStatementsFunctionsSQL.format(
+ columns=" bigint, ".join(statements_columns) + " bigint", metrics=(", ".join(statements_items)))
+ Pooler.query(bootstrap_extension_queries)
except Exception as e:
sys.stderr.write(
"Bootstrap failed to create auxiliary extensions and functions.\n"
diff --git a/mamonsu/tools/zabbix_cli/dashboard.py b/mamonsu/tools/zabbix_cli/dashboard.py
index e0ef3975..6d20ba96 100644
--- a/mamonsu/tools/zabbix_cli/dashboard.py
+++ b/mamonsu/tools/zabbix_cli/dashboard.py
@@ -1,6 +1,7 @@
from datetime import datetime
from mamonsu.plugins.pgsql.archive_command import ArchiveCommand
+from mamonsu.plugins.pgsql.autovacuum import Autovacuum
from mamonsu.plugins.pgsql.bgwriter import BgWriter
from mamonsu.plugins.pgsql.checkpoint import Checkpoint
from mamonsu.plugins.pgsql.connections import Connections
@@ -32,11 +33,7 @@ def generate_dashboard(template, uuid):
{42}
{1}
{1}
-
-
- Templates
-
-
+
{42}
@@ -1053,7 +1050,7 @@ def generate_dashboard(template, uuid):
Instance.graphs_name["transactions"],
Memory.graph_name_free_used,
ArchiveCommand.key.format("[" + ArchiveCommand.Items[2][0] + "]"),
- Databases.key_autovacumm.format("[]"),
+ Autovacuum.key_count.format("[]"),
BgWriter.graph_name_buffers,
BgWriter.graph_name_ws,
Instance.key + Instance.Items[1][1],
@@ -1086,6 +1083,6 @@ def generate_dashboard(template, uuid):
Instance.key + Instance.Items[11][1],
PgHealth.key_uptime.format("[]"),
Wal.key_wal_records.format("[]"),
- Wal.key_wal_sync_duty,
+ Wal.key_wal_sync_duty.format("[]"),
Wal.key_count_wall.format("[]"),
uuid).replace("\\r\\n", " ").split())
diff --git a/mamonsu/tools/zabbix_cli/operations.py b/mamonsu/tools/zabbix_cli/operations.py
index 9eb1df49..811ab0b1 100644
--- a/mamonsu/tools/zabbix_cli/operations.py
+++ b/mamonsu/tools/zabbix_cli/operations.py
@@ -3,9 +3,10 @@
from __future__ import print_function
import sys
import json
+import mamonsu.lib.version as version
from mamonsu.tools.zabbix_cli.request import Request
from mamonsu.lib.parser import zabbix_msg
-from distutils.version import LooseVersion
+
from mamonsu.tools.zabbix_cli.dashboard import generate_dashboard
@@ -62,20 +63,20 @@ def _generic_delete(self, typ, ids):
sys.exit(3)
def _generic_list(self, typ):
+ name, fltr = '', ''
if typ == 'template':
name, fltr = 'name', 'host'
elif typ == 'hostgroup':
- name, fltr = 'name', 'host'
+ name = 'name'
elif typ == 'host':
- fltr, name = 'host', 'host'
+ name, fltr = 'host', 'host'
else:
sys.stderr.write('Unknown type: {0} for listing'.format(typ))
sys.exit(4)
try:
for x in self.req.post(
method='{0}.get'.format(typ),
- params={
- 'filter': {fltr: []}}):
+ params={'filter': {fltr: []}} if fltr != '' else {'filter': []}):
print(x[name])
except Exception as e:
sys.stderr.write('List error: {0}\n'.format(e))
@@ -171,10 +172,10 @@ def template(self, args):
}
},
'source': open(file).read()}
- if LooseVersion(zabbix_version) < LooseVersion('5.4'):
+ if version.parse(zabbix_version) < version.parse('5.4'):
params['rules']['applications'] = {'createMissing': True,
'deleteMissing': True}
- if LooseVersion(zabbix_version) < LooseVersion('5.2'):
+ if version.parse(zabbix_version) < version.parse('5.2'):
params['rules']['templateScreens'] = {'createMissing': True,
'updateExisting': False,
'deleteMissing': True}
@@ -329,7 +330,7 @@ def dashboard(self, args):
if not len(args) == 2:
return self._print_help()
zabbix_version = str(self.req.post(method='apiinfo.version', params=[]))
- if LooseVersion(zabbix_version) < LooseVersion('6.0'):
+ if version.parse(zabbix_version) < version.parse('6.0'):
print("You can import Mamonsu dashboard only on Zabbix 6.0+.")
return
else:
diff --git a/mamonsu/tools/zabbix_cli/request.py b/mamonsu/tools/zabbix_cli/request.py
index 01bb126a..0ccd78c0 100644
--- a/mamonsu/tools/zabbix_cli/request.py
+++ b/mamonsu/tools/zabbix_cli/request.py
@@ -4,6 +4,7 @@
import logging
from collections import OrderedDict
+import mamonsu.lib.version as version
import urllib.request as urllib2
@@ -13,20 +14,22 @@ class Request(object):
def __init__(self, url, user, passwd):
self._url, self._user, self._passwd = url, user, passwd
self._id, self._auth_tocken = 0, None
-
+ self._api_version = self.post(method='apiinfo.version', params=[])
+
def set_user(self, user):
self._user=user
-
+
def set_passwd(self, passwd):
self._passwd=passwd
-
+
def _auth(self):
if self._auth_tocken is None:
if not self._user:
return None
+ user_field = 'user' if version.parse(self._api_version) < version.parse('6.4') else 'username'
self._auth_tocken = self.post(
'user.login',
- {'user': self._user, 'password': self._passwd})
+ {user_field: self._user, 'password': self._passwd})
return self._auth_tocken
def _get_id(self):
diff --git a/mamonsu_win32.spec b/mamonsu_win32.spec
index 503a4f3a..ca505867 100644
--- a/mamonsu_win32.spec
+++ b/mamonsu_win32.spec
@@ -9,6 +9,7 @@ a = Analysis(['mamonsu_win32.py'],
datas=[],
hiddenimports=[
'mamonsu.plugins.pgsql.archive_command',
+ 'mamonsu.plugins.pgsql.autovacuum',
'mamonsu.plugins.pgsql.bgwriter',
'mamonsu.plugins.pgsql.cfs',
'mamonsu.plugins.pgsql.checkpoint',
diff --git a/packaging/conf/example_linux.conf b/packaging/conf/example_linux.conf
index 065b98c4..c3234a69 100644
--- a/packaging/conf/example_linux.conf
+++ b/packaging/conf/example_linux.conf
@@ -66,8 +66,8 @@ max_size_mb = 1024
# specify logging settings for mamonsu
[log]
-file = None
-level = INFO
+file = /var/log/mamonsu/mamonsu.log
+level = DEBUG
format = [%(levelname)s] %(asctime)s - %(name)s - %(message)s
######### Individual Plugin Sections ############
@@ -78,13 +78,17 @@ format = [%(levelname)s] %(asctime)s - %(name)s - %(message)s
# below listed all available parameters for each plugin to modify.
[health]
-max_memory_usage = 41943040
interval = 60
[archivecommand]
-max_count_files = 2
interval = 60
+# Besides standard autovacuum workers count, mamonsu also counts autovacuum utilization.
+# But this metric is instantaneous, so recommended to run this plugin frequently
+# to get a complete picture of autovacuum utilization.
+[autovacuum]
+interval = 30
+
[bgwriter]
interval = 60
@@ -93,21 +97,15 @@ force_enable = False
interval = 60
[checkpoint]
-max_checkpoint_by_wal_in_hour = 12
interval = 300
[connections]
-percent_connections_tr = 90
interval = 60
[databases]
-bloat_scale = 0.2
-min_rows = 50
interval = 300
[pghealth]
-uptime = 600
-cache = 80
interval = 60
[instance]
@@ -130,8 +128,6 @@ interval = 60
private_anon_mem_threshold = 1GB
[oldest]
-max_xid_age = 18000000
-max_query_time = 18000
interval = 60
[pgbuffercache]
@@ -146,7 +142,6 @@ interval = 60
# max_prepared_transaction_time - age of prepared transaction in seconds.
# If pgsql.prepared.oldest exceeds max_prepared_transaction_time the trigger fires.
[preparedtransaction]
-max_prepared_transaction_time = 60
interval = 60
# Get size of relations defined in this section
@@ -161,7 +156,6 @@ relations=postgres.pg_catalog.pg_class,postgres.pg_catalog.pg_user
interval = 300
[replication]
-lag_more_than_in_sec = 300
interval = 60
[statstatements]
@@ -174,8 +168,6 @@ interval = 60
interval = 60
[disksizes]
-vfs_percent_free = 10
-vfs_inode_percent_free = 10
interval = 60
[diskstats]
@@ -206,7 +198,6 @@ pg_probackup_path = /usr/bin/pg_probackup-11
interval = 60
[systemuptime]
-up_time = 300
interval = 60
[agentapi]
@@ -216,4 +207,4 @@ interval = 60
interval = 2
[zbxsender]
-interval = 10
\ No newline at end of file
+interval = 10
diff --git a/packaging/conf/example_win.conf b/packaging/conf/example_win.conf
index f125dc0d..d77008c8 100644
--- a/packaging/conf/example_win.conf
+++ b/packaging/conf/example_win.conf
@@ -78,13 +78,17 @@ format = [%(levelname)s] %(asctime)s - %(name)s - %(message)s
# below listed all available parameters for each plugin to modify.
[health]
-max_memory_usage = 41943040
interval = 60
[archivecommand]
-max_count_files = 2
interval = 60
+# Besides standard autovacuum workers count, mamonsu also counts autovacuum utilization.
+# But this metric is instantaneous, so recommended to run this plugin frequently
+# to get a complete picture of autovacuum utilization.
+[autovacuum]
+interval = 30
+
[bgwriter]
interval = 60
@@ -93,21 +97,15 @@ force_enable = False
interval = 60
[checkpoint]
-max_checkpoint_by_wal_in_hour = 12
interval = 300
[connections]
-percent_connections_tr = 90
interval = 60
[databases]
-bloat_scale = 0.2
-min_rows = 50
interval = 300
[pghealth]
-uptime = 600
-cache = 80
interval = 60
[instance]
@@ -127,11 +125,8 @@ interval = 60
[memoryleakdiagnostic]
enabled = False
interval = 60
-private_anon_mem_threshold = 1GB
[oldest]
-max_xid_age = 18000000
-max_query_time = 18000
interval = 60
[pgbuffercache]
@@ -146,7 +141,6 @@ interval = 60
# max_prepared_transaction_time - age of prepared transaction in seconds.
# If pgsql.prepared.oldest exceeds max_prepared_transaction_time the trigger fires.
[preparedtransaction]
-max_prepared_transaction_time = 60
interval = 60
# Get size of relations defined in this section
@@ -161,7 +155,6 @@ relations=postgres.pg_catalog.pg_class,postgres.pg_catalog.pg_user
interval = 300
[replication]
-lag_more_than_in_sec = 300
interval = 60
[statstatements]
diff --git a/packaging/conf/old_templates/template_2.4.0.xml b/packaging/conf/old_templates/template_2.4.0.xml
deleted file mode 100644
index 55a0282c..00000000
--- a/packaging/conf/old_templates/template_2.4.0.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-2.0
-
-
- Templates
-
-
-
-
- PostgresPro-Linux2
- PostgresPro-Linux2
-
-
- Templates
-
-
-
-
- App-PostgresPro-Linux2
-
-
- - PostgreSQL archive command count files in archive_status need to archive200pgsql.archive_command[count_files_to_archive]736506030000100App-PostgresPro-Linux2
- PostgreSQL archive command size of files need to archive200pgsql.archive_command[size_files_to_archive]736506030000100App-PostgresPro-Linux2
- PostgreSQL archive command count archived files200pgsql.archive_command[archived_files]736506030000100App-PostgresPro-Linux2
- PostgreSQL archive command count attempts to archive files200pgsql.archive_command[failed_trying_to_archive]736506030000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers written during checkpoints200pgsql.bgwriter[buffers_checkpoint]736506030000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers written200pgsql.bgwriter[buffers_clean]736506030000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: number of bgwriter stopped by max write count200pgsql.bgwriter[maxwritten_clean]736506030000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers written directly by a backend200pgsql.bgwriter[buffers_backend]736506030000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: times a backend execute its own fsync200pgsql.bgwriter[buffers_backend_fsync]736506030000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers allocated200pgsql.bgwriter[buffers_alloc]736506030000100App-PostgresPro-Linux2
- PostgreSQL cfs compression: written byte/s200pgsql.cfs.activity[written_bytes]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL cfs compression: scanned byte/s200pgsql.cfs.activity[scanned_bytes]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL cfs compression: compressed files200pgsql.cfs.activity[compressed_files]736506000000100App-PostgresPro-Linux2
- PostgreSQL cfs compression: scanned files200pgsql.cfs.activity[scanned_files]736506000000100App-PostgresPro-Linux2
- PostgreSQL cfs compression: current ratio200pgsql.cfs.activity[current_compress_ratio]736506000000100App-PostgresPro-Linux2
- PostgreSQL cfs compression: total ratio200pgsql.cfs.activity[total_compress_ratio]736506000000100App-PostgresPro-Linux2
- PostgreSQL checkpoints: by timeout (in hour)200pgsql.checkpoint[count_timed]7365030000000100App-PostgresPro-Linux2
- PostgreSQL checkpoints: by wal (in hour)200pgsql.checkpoint[count_wal]7365030000000100App-PostgresPro-Linux2
- PostgreSQL checkpoint: write time200pgsql.checkpoint[write_time]736503000ms0000100App-PostgresPro-Linux2
- PostgreSQL checkpoint: sync time200pgsql.checkpoint[checkpoint_sync_time]736503000ms0000100App-PostgresPro-Linux2
- PostgreSQL: number of total connections200pgsql.connections[total]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of waiting connections200pgsql.connections[waiting]736506000000100App-PostgresPro-Linux2
- PostgreSQL: max connections200pgsql.connections[max_connections]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of active connections200pgsql.connections[active]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of idle connections200pgsql.connections[idle]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of idle in transaction connections200pgsql.connections[idle_in_transaction]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of idle in transaction (aborted)200pgsql.connections[idle_in_transaction_aborted]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of fastpath function call200pgsql.connections[fastpath_function_call]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of disabled200pgsql.connections[disabled]736506000000100App-PostgresPro-Linux2
- PostgreSQL: count of autovacuum workers200pgsql.autovacumm.count[]7365030000000100App-PostgresPro-Linux2
- Block devices: read requests200system.disk.all_read[]736506000000100App-PostgresPro-Linux2
- Block devices: write requests200system.disk.all_write[]736506000000100App-PostgresPro-Linux2
- Block devices: read byte/s200system.disk.all_read_b[]736506000000100App-PostgresPro-Linux2
- Block devices: write byte/s200system.disk.all_write_b[]736506000000100App-PostgresPro-Linux2
- Mamonsu: plugin errors200mamonsu.plugin.errors[]736506040000100App-PostgresPro-Linux2
- Mamonsu: plugin keep alive200mamonsu.plugin.keepalive[]736506000000100App-PostgresPro-Linux2
- Mamonsu: rss memory max usage200mamonsu.memory.rss[max]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL transactions: total200pgsql.transactions[total]736506000000100App-PostgresPro-Linux2
- PostgreSQL blocks: hit200pgsql.blocks[hit]736506000000100App-PostgresPro-Linux2
- PostgreSQL blocks: read200pgsql.blocks[read]736506000000100App-PostgresPro-Linux2
- PostgreSQL event: conflicts200pgsql.events[conflicts]736506000000100App-PostgresPro-Linux2
- PostgreSQL event: deadlocks200pgsql.events[deadlocks]736506000000100App-PostgresPro-Linux2
- PostgreSQL event: rollbacks200pgsql.events[xact_rollback]736506000000100App-PostgresPro-Linux2
- PostgreSQL temp: bytes written200pgsql.temp[bytes]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL temp: files created200pgsql.temp[files]736506000000100App-PostgresPro-Linux2
- PostgreSQL tuples: deleted200pgsql.tuples[deleted]736506000000100App-PostgresPro-Linux2
- PostgreSQL tuples: fetched200pgsql.tuples[fetched]736506000000100App-PostgresPro-Linux2
- PostgreSQL tuples: inserted200pgsql.tuples[inserted]736506000000100App-PostgresPro-Linux2
- PostgreSQL tuples: returned200pgsql.tuples[returned]736506000000100App-PostgresPro-Linux2
- PostgreSQL tuples: updated200pgsql.tuples[updated]736506000000100App-PostgresPro-Linux2
- System load average over 1 minute200system.la[1]736506000000100App-PostgresPro-Linux2
- Apps: User-space applications200system.memory[apps]73650603b0000100App-PostgresPro-Linux2
- Buffers: Block device cache and dirty200system.memory[buffers]73650603b0000100App-PostgresPro-Linux2
- Swap: Swap space used200system.memory[swap]73650603b0000100App-PostgresPro-Linux2
- Cached: Parked file data (file content) cache200system.memory[cached]73650603b0000100App-PostgresPro-Linux2
- Free: Wasted memory200system.memory[unused]73650603b0000100App-PostgresPro-Linux2
- Slab: Kernel used memory (inode cache)200system.memory[slab]73650603b0000100App-PostgresPro-Linux2
- SwapCached: Fetched unmod yet swap pages200system.memory[swap_cache]73650603b0000100App-PostgresPro-Linux2
- PageTables: Map bt virtual and physical200system.memory[page_tables]73650603b0000100App-PostgresPro-Linux2
- VMallocUsed: vmaloc() allocated by kernel200system.memory[vmalloc_used]73650603b0000100App-PostgresPro-Linux2
- Committed_AS: Total committed memory200system.memory[committed]73650603b0000100App-PostgresPro-Linux2
- Mapped: All mmap()ed pages200system.memory[mapped]73650603b0000100App-PostgresPro-Linux2
- Active: Memory recently used200system.memory[active]73650603b0000100App-PostgresPro-Linux2
- Inactive: Memory not currently used200system.memory[inactive]73650603b0000100App-PostgresPro-Linux2
- PostgreSQL: age of oldest xid200pgsql.oldest[xid_age]736506030000100App-PostgresPro-Linux2
- PostgreSQL: oldest query running time in sec200pgsql.oldest[query_time]73650600s0000100App-PostgresPro-Linux2
- Opened files200system.open_files[]736506030000100App-PostgresPro-Linux2
- PostgreSQL: shared buffer size200pgsql.buffers[size]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL: shared buffer twice used size200pgsql.buffers[twice_used]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL: shared buffer dirty size200pgsql.buffers[dirty]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL: ping200pgsql.ping[]73650600ms0000100App-PostgresPro-Linux2
- PostgreSQL: cache hit ratio200pgsql.cache[hit]73650603%0000100App-PostgresPro-Linux2
- PostgreSQL: service uptime200pgsql.uptime[]73650603uptime0000100App-PostgresPro-Linux2
- PostgreSQL locks: Read only queries200pgsql.pg_locks[accessshare]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: SELECT FOR SHARE and SELECT FOR UPDATE200pgsql.pg_locks[rowshare]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: Write queries200pgsql.pg_locks[rowexclusive]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY200pgsql.pg_locks[shareupdateexclusive]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: CREATE INDEX200pgsql.pg_locks[share]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: Locks from application200pgsql.pg_locks[sharerowexclusive]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: Locks from application or some operation on system catalogs200pgsql.pg_locks[exclusive]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE200pgsql.pg_locks[accessexclusive]736506030000100App-PostgresPro-Linux2
- PostgreSQL statements: read bytes/s200pgsql.stat[read_bytes]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL statements: write bytes/s200pgsql.stat[write_bytes]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL statements: dirty bytes/s200pgsql.stat[dirty_bytes]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL statements: read io time200pgsql.stat[read_time]73650600s0000100App-PostgresPro-Linux2
- PostgreSQL statements: write io time200pgsql.stat[write_time]73650600s0000100App-PostgresPro-Linux2
- PostgreSQL statements: other (mostly cpu) time200pgsql.stat[other_time]73650600s0000100App-PostgresPro-Linux2
- Processes: in state running200system.processes[running]736506000000100App-PostgresPro-Linux2
- Processes: in state blocked200system.processes[blocked]736506000000100App-PostgresPro-Linux2
- Processes: forkrate200system.processes[forkrate]736506000000100App-PostgresPro-Linux2
- CPU time spent by normal programs and daemons200system.cpu[user]736506000000100App-PostgresPro-Linux2
- CPU time spent by nice(1)d programs200system.cpu[nice]736506000000100App-PostgresPro-Linux2
- CPU time spent by the kernel in system activities200system.cpu[system]736506000000100App-PostgresPro-Linux2
- CPU time spent Idle CPU time200system.cpu[idle]736506000000100App-PostgresPro-Linux2
- CPU time spent waiting for I/O operations200system.cpu[iowait]736506000000100App-PostgresPro-Linux2
- CPU time spent handling interrupts200system.cpu[irq]736506000000100App-PostgresPro-Linux2
- CPU time spent handling batched interrupts200system.cpu[softirq]736506000000100App-PostgresPro-Linux2
- System up_time200system.up_time[]73650603uptime0000100App-PostgresPro-Linux2
- PostgreSQL: wal write speed200pgsql.wal.write[]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL: streaming replication lag200pgsql.replication_lag[sec]736506000000100App-PostgresPro-Linux2
- PostgreSQL: count of xlog files200pgsql.wal.count[]736506000000100App-PostgresPro-Linux2
- Compressed relations discovery2600000{#COMPRESSED_RELATION}:.*07pgsql.cfs.discovery_compressed_relations[]Relation {#COMPRESSED_RELATION}: compress ratio200pgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]7365060000000100App-PostgresPro-Linux2Relation {#COMPRESSED_RELATION}: compress ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]
Database discovery2600000{#DATABASE}:.*07pgsql.database.discovery[]Database {#DATABASE}: size200pgsql.database.size[{#DATABASE}]736503003b0000100App-PostgresPro-Linux2Max age (datfrozenxid) in: {#DATABASE}200pgsql.database.max_age[{#DATABASE}]7365030000000100App-PostgresPro-Linux2Count of bloating tables in database: {#DATABASE}200pgsql.database.bloating_tables[{#DATABASE}]7365030000000100App-PostgresPro-Linux2Database: {#DATABASE} size9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linux2pgsql.database.size[{#DATABASE}]
Database bloating overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.database.bloating_tables[{#DATABASE}]
1000CC00120- PostgresPro-Linux2pgsql.autovacumm.count[]
Database max age overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.database.max_age[{#DATABASE}]
1000CC00120- PostgresPro-Linux2pgsql.autovacumm.count[]
VFS discovery2600000{#MOUNTPOINT}:.*07system.vfs.discovery[]Mount point {#MOUNTPOINT}: used200system.vfs.used[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-Linux2Mount point {#MOUNTPOINT}: free200system.vfs.free[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-Linux2Mount point {#MOUNTPOINT}: free in percents200system.vfs.percent_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-Linux2Mount point {#MOUNTPOINT}: free inodes in percent200system.vfs.percent_inode_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-Linux2{PostgresPro-Linux2:system.vfs.percent_free[{#MOUNTPOINT}].last()}<10Free disk space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030{PostgresPro-Linux2:system.vfs.percent_inode_free[{#MOUNTPOINT}].last()}<10Free inode space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030Mount point overview: {#MOUNTPOINT}9002000.0100.0111100.00.0000000CC0000020- PostgresPro-Linux2system.vfs.used[{#MOUNTPOINT}]
100000CC020- PostgresPro-Linux2system.vfs.free[{#MOUNTPOINT}]
Block device discovery2600000{#BLOCKDEVICE}:.*07system.disk.discovery[]Block device {#BLOCKDEVICE}: utilization200system.disk.utilization[{#BLOCKDEVICE}]73650600%0000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: read operations200system.disk.read[{#BLOCKDEVICE}]736506000000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: write operations200system.disk.write[{#BLOCKDEVICE}]736506000000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: read byte/s200system.disk.read_b[{#BLOCKDEVICE}]73650600b0000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: write byte/s200system.disk.write_b[{#BLOCKDEVICE}]73650600b0000100App-PostgresPro-Linux2Block device overview: {#BLOCKDEVICE} operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.read[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linux2system.disk.write[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linux2system.disk.utilization[{#BLOCKDEVICE}]
Block device overview: {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.read_b[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linux2system.disk.write_b[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linux2system.disk.utilization[{#BLOCKDEVICE}]
Net iface discovery2600000{#NETDEVICE}:.*07system.net.discovery[]Network device {#NETDEVICE}: RX bytes/s200system.net.rx_bytes[{#NETDEVICE}]73650600b0000100App-PostgresPro-Linux2Network device {#NETDEVICE}: RX errors/s200system.net.rx_errs[{#NETDEVICE}]736506000000100App-PostgresPro-Linux2Network device {#NETDEVICE}: RX drops/s200system.net.rx_drop[{#NETDEVICE}]736506000000100App-PostgresPro-Linux2Network device {#NETDEVICE}: TX bytes/s200system.net.tx_bytes[{#NETDEVICE}]73650600b0000100App-PostgresPro-Linux2Network device {#NETDEVICE}: TX errors/s200system.net.tx_errs[{#NETDEVICE}]736506000000100App-PostgresPro-Linux2Network device {#NETDEVICE}: TX drops/s200system.net.tx_drop[{#NETDEVICE}]736506000000100App-PostgresPro-Linux2Network device: {#NETDEVICE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.net.rx_bytes[{#NETDEVICE}]
100000CC020- PostgresPro-Linux2system.net.tx_bytes[{#NETDEVICE}]
-
-
-
- {PostgresPro-Linux2:pgsql.archive_command[count_files_to_archive].last()}>2PostgreSQL count files in ./archive_status on {HOSTNAME} more than 2030{PostgresPro-Linux2:pgsql.checkpoint[count_wal].last()}>12PostgreSQL required checkpoints occurs to frequently on {HOSTNAME}030 {PostgresPro-Linux2:pgsql.connections[total].last()}/{PostgresPro-Linux2:pgsql.connections[max_connections].last()}*100 >90PostgreSQL many connections on {HOSTNAME} (total connections more than 90% max connections)030{PostgresPro-Linux2:mamonsu.plugin.errors[].strlen()}>1Mamonsu plugin errors on {HOSTNAME}. {ITEM.LASTVALUE}030{PostgresPro-Linux2:mamonsu.plugin.keepalive[].nodata(180)}=1Mamonsu nodata from {HOSTNAME}030{PostgresPro-Linux2:mamonsu.memory.rss[max].last()}>41943040Mamonsu agent memory usage alert on {HOSTNAME}: {ITEM.LASTVALUE} bytes030{PostgresPro-Linux2:pgsql.oldest[xid_age].last()}>18000000PostgreSQL oldest xid is too big on {HOSTNAME}030{PostgresPro-Linux2:pgsql.oldest[query_time].last()}>18000PostgreSQL query running is too old on {HOSTNAME}030{PostgresPro-Linux2:pgsql.uptime[].last()}<600PostgreSQL service was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{PostgresPro-Linux2:pgsql.cache[hit].last()}<80PostgreSQL cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{PostgresPro-Linux2:system.processes[forkrate].min(5m)}>500Process fork-rate to frequently on {HOSTNAME}030{PostgresPro-Linux2:system.up_time[].last()}<300System was restarted on {HOSTNAME} (up_time={ITEM.LASTVALUE})030{PostgresPro-Linux2:pgsql.replication_lag[sec].last()}>300PostgreSQL streaming lag to high on {HOSTNAME} (value={ITEM.LASTVALUE})030
- PostgreSQL archive command archive_status 9002000.0100.0110100.00.0000000FF0000020- PostgresPro-Linux2pgsql.archive_command[count_files_to_archive]
1000FF00120- PostgresPro-Linux2pgsql.archive_command[size_files_to_archive]
PostgreSQL archive command trying_to_archive 9002000.0100.0110100.00.000000000F000020- PostgresPro-Linux2pgsql.archive_command[archived_files]
10FF0000120- PostgresPro-Linux2pgsql.archive_command[failed_trying_to_archive]
PostgreSQL bgwriter9002000.0100.0110100.00.0000000CCCC00120- PostgresPro-Linux2pgsql.bgwriter[buffers_checkpoint]
100000CC120- PostgresPro-Linux2pgsql.bgwriter[buffers_clean]
20777777020- PostgresPro-Linux2pgsql.bgwriter[maxwritten_clean]
30CC0000120- PostgresPro-Linux2pgsql.bgwriter[buffers_backend]
40CC00CC020- PostgresPro-Linux2pgsql.bgwriter[buffers_backend_fsync]
5000CC00120- PostgresPro-Linux2pgsql.bgwriter[buffers_alloc]
PostgreSQL cfs compression: current ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.cfs.activity[current_compress_ratio]
PostgreSQL cfs compression: compressed files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.cfs.activity[compressed_files]
PostgreSQL cfs compression: written bytes9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.cfs.activity[written_bytes]
PostgreSQL cfs compression: total ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.cfs.activity[total_compress_ratio]
PostgreSQL checkpoints9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.checkpoint[count_timed]
10CC0000020- PostgresPro-Linux2pgsql.checkpoint[count_wal]
200000CC120- PostgresPro-Linux2pgsql.checkpoint[write_time]
30000000120- PostgresPro-Linux2pgsql.checkpoint[checkpoint_sync_time]
PostgreSQL connections9002000.0100.0110100.00.000000000BB00020- PostgresPro-Linux2pgsql.connections[active]
100000BB020- PostgresPro-Linux2pgsql.connections[idle]
20CC00CC020- PostgresPro-Linux2pgsql.connections[idle_in_transaction]
30CCCCCC020- PostgresPro-Linux2pgsql.connections[idle_in_transaction_aborted]
40CCCC00020- PostgresPro-Linux2pgsql.connections[fastpath_function_call]
5000CCCC020- PostgresPro-Linux2pgsql.connections[disabled]
60EEEEEE020- PostgresPro-Linux2pgsql.connections[total]
70BB0000020- PostgresPro-Linux2pgsql.connections[waiting]
8000BB00020- PostgresPro-Linux2pgsql.connections[max_connections]
Block devices: read/write operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.all_read[]
100000CC020- PostgresPro-Linux2system.disk.all_write[]
Block devices: read/write bytes9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.all_read_b[]
100000CC020- PostgresPro-Linux2system.disk.all_write_b[]
PostgreSQL instance: rate9002000.0100.0110100.00.00000000000CC120- PostgresPro-Linux2pgsql.transactions[total]
1000CC00020- PostgresPro-Linux2pgsql.blocks[hit]
20CC0000020- PostgresPro-Linux2pgsql.blocks[read]
PostgreSQL instance: events9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linux2pgsql.events[conflicts]
10000000020- PostgresPro-Linux2pgsql.events[deadlocks]
20CC0000020- PostgresPro-Linux2pgsql.events[xact_rollback]
PostgreSQL instance: temp files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.temp[bytes]
100000CC120- PostgresPro-Linux2pgsql.temp[files]
PostgreSQL instance: tuples9002000.0100.0110100.00.0000000000000020- PostgresPro-Linux2pgsql.tuples[deleted]
100000CC020- PostgresPro-Linux2pgsql.tuples[fetched]
2000CC00020- PostgresPro-Linux2pgsql.tuples[inserted]
30CC00CC120- PostgresPro-Linux2pgsql.tuples[returned]
40CC0000020- PostgresPro-Linux2pgsql.tuples[updated]
System load average9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2system.la[1]
Memory overview9004000.0100.0111100.00.0000000CC0000020- PostgresPro-Linux2system.memory[apps]
1000CC00020- PostgresPro-Linux2system.memory[buffers]
200000CC020- PostgresPro-Linux2system.memory[swap]
30CC00CC020- PostgresPro-Linux2system.memory[cached]
40000000020- PostgresPro-Linux2system.memory[unused]
50CCCC00020- PostgresPro-Linux2system.memory[slab]
60777777020- PostgresPro-Linux2system.memory[swap_cache]
70770000020- PostgresPro-Linux2system.memory[page_tables]
80000077020- PostgresPro-Linux2system.memory[vmalloc_used]
90007700020- PostgresPro-Linux2system.memory[committed]
100DF0000020- PostgresPro-Linux2system.memory[mapped]
11000DF00020- PostgresPro-Linux2system.memory[active]
1200000DF020- PostgresPro-Linux2system.memory[inactive]
PostgreSQL oldest query running time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.oldest[query_time]
PostgreSQL age of oldest xid9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.oldest[xid_age]
System: count of opened files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2system.open_files[]
PostgreSQL: shared buffer9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linux2pgsql.buffers[size]
10CC0000020- PostgresPro-Linux2pgsql.buffers[twice_used]
2000CC00020- PostgresPro-Linux2pgsql.buffers[dirty]
PostgreSQL uptime9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.cache[hit]
10DF0101120- PostgresPro-Linux2pgsql.uptime[]
PostgreSQL locks sampling9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linux2pgsql.pg_locks[accessshare]
1000CC00020- PostgresPro-Linux2pgsql.pg_locks[rowshare]
20CC0000020- PostgresPro-Linux2pgsql.pg_locks[rowexclusive]
30CC00CC020- PostgresPro-Linux2pgsql.pg_locks[shareupdateexclusive]
40777777020- PostgresPro-Linux2pgsql.pg_locks[share]
50CCCCCC020- PostgresPro-Linux2pgsql.pg_locks[sharerowexclusive]
60CCCC00020- PostgresPro-Linux2pgsql.pg_locks[exclusive]
7000CCCC020- PostgresPro-Linux2pgsql.pg_locks[accessexclusive]
PostgreSQL statements: bytes9002000.0100.0110100.00.0000000BBBB00020- PostgresPro-Linux2pgsql.stat[read_bytes]
1000CC00020- PostgresPro-Linux2pgsql.stat[write_bytes]
200000CC020- PostgresPro-Linux2pgsql.stat[dirty_bytes]
PostgreSQL statements: spend time9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linux2pgsql.stat[read_time]
100000CC020- PostgresPro-Linux2pgsql.stat[write_time]
20BBBB00020- PostgresPro-Linux2pgsql.stat[other_time]
Processes overview9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.processes[running]
1000CC00020- PostgresPro-Linux2system.processes[blocked]
200000CC120- PostgresPro-Linux2system.processes[forkrate]
CPU time spent9002000.0100.0111100.00.00000000000CC020- PostgresPro-Linux2system.cpu[user]
10CC00CC020- PostgresPro-Linux2system.cpu[nice]
20CC0000020- PostgresPro-Linux2system.cpu[system]
3000CC00020- PostgresPro-Linux2system.cpu[idle]
40CCCC00020- PostgresPro-Linux2system.cpu[iowait]
50777777020- PostgresPro-Linux2system.cpu[irq]
60000077020- PostgresPro-Linux2system.cpu[softirq]
System up_time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2system.up_time[]
PostgreSQL write-ahead log generation speed9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.wal.write[]
PostgreSQL replication lag in second9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.replication_lag[sec]
PostgreSQL count of xlog files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.wal.count[]
-
\ No newline at end of file
diff --git a/packaging/conf/old_templates/template_2.4.0_agent.xml b/packaging/conf/old_templates/template_2.4.0_agent.xml
deleted file mode 100644
index b90f656c..00000000
--- a/packaging/conf/old_templates/template_2.4.0_agent.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-2.0
-
-
- Templates
-
-
-
-
- PostgresPro-Linux2
- PostgresPro-Linux2
-
-
- Templates
-
-
-
-
- App-PostgresPro-Linux2
-
-
- - PostgreSQL archive command count files in archive_status need to archive000pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL archive command size of files need to archive000pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL archive command count archived files000pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL archive command count attempts to archive files000pgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers written during checkpoints000pgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers written000pgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: number of bgwriter stopped by max write count000pgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers written directly by a backend000pgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: times a backend execute its own fsync000pgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers allocated000pgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL checkpoints: by timeout (in hour)000pgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]7365030001000100App-PostgresPro-Linux2
- PostgreSQL checkpoints: by wal (in hour)000pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]7365030001000100App-PostgresPro-Linux2
- PostgreSQL checkpoint: write time000pgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100App-PostgresPro-Linux2
- PostgreSQL checkpoint: sync time000pgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100App-PostgresPro-Linux2
- PostgreSQL: number of total connections000pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of waiting connections000pgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: max connections000pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of active connections000pgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of idle connections000pgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of idle in transaction connections000pgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of idle in transaction (aborted)000pgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of fastpath function call000pgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of disabled000pgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: count of autovacuum workers000pgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-Linux2
- Block devices: read requests000system.disk.all_read736506001000100App-PostgresPro-Linux2
- Block devices: write requests000system.disk.all_write736506001000100App-PostgresPro-Linux2
- Block devices: read byte/s000system.disk.all_read_b736506001000100App-PostgresPro-Linux2
- Block devices: write byte/s000system.disk.all_write_b736506001000100App-PostgresPro-Linux2
- Mamonsu: plugin keep alive000mamonsu.plugin.keepalive736506000000100App-PostgresPro-Linux2
- PostgreSQL transactions: total000pgsql.transactions.total[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- PostgreSQL blocks: hit000pgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- PostgreSQL blocks: read000pgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- PostgreSQL event: conflicts000pgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux2
- PostgreSQL event: deadlocks000pgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux2
- PostgreSQL event: rollbacks000pgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux2
- PostgreSQL temp: bytes written000pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b2000100App-PostgresPro-Linux2
- PostgreSQL temp: files created000pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux2
- PostgreSQL tuples: deleted000pgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- PostgreSQL tuples: fetched000pgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- PostgreSQL tuples: inserted000pgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- PostgreSQL tuples: returned000pgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- PostgreSQL tuples: updated000pgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- System load average over 1 minute000system.la.1736506000000100App-PostgresPro-Linux2
- Apps: User-space applications000system.memory.apps73650603b0000100App-PostgresPro-Linux2
- Buffers: Block device cache and dirty000system.memory.buffers73650603b0000100App-PostgresPro-Linux2
- Swap: Swap space used000system.memory.swap73650603b0000100App-PostgresPro-Linux2
- Cached: Parked file data (file content) cache000system.memory.cached73650603b0000100App-PostgresPro-Linux2
- Free: Wasted memory000system.memory.unused73650603b0000100App-PostgresPro-Linux2
- Slab: Kernel used memory (inode cache)000system.memory.slab73650603b0000100App-PostgresPro-Linux2
- SwapCached: Fetched unmod yet swap pages000system.memory.swap_cache73650603b0000100App-PostgresPro-Linux2
- PageTables: Map bt virtual and physical000system.memory.page_tables73650603b0000100App-PostgresPro-Linux2
- VMallocUsed: vmaloc() allocated by kernel000system.memory.vmalloc_used73650603b0000100App-PostgresPro-Linux2
- Committed_AS: Total committed memory000system.memory.committed73650603b0000100App-PostgresPro-Linux2
- Mapped: All mmap()ed pages000system.memory.mapped73650603b0000100App-PostgresPro-Linux2
- Active: Memory recently used000system.memory.active73650603b0000100App-PostgresPro-Linux2
- Inactive: Memory not currently used000system.memory.inactive73650603b0000100App-PostgresPro-Linux2
- PostgreSQL: age of oldest xid000pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL: oldest query running time in sec000pgsql.oldest.query_time[{$PG_CONNINFO},{$PG_PATH}]73650600s0000100App-PostgresPro-Linux2
- Opened files000system.open_files736506030000100App-PostgresPro-Linux2
- PostgreSQL: shared buffer size000pgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL: shared buffer twice used size000pgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL: shared buffer dirty size000pgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL: ping000pgsql.ping[{$PG_CONNINFO},{$PG_PATH}]7365050ms0000100App-PostgresPro-Linux2
- PostgreSQL: cache hit ratio000pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]73650600%0000100App-PostgresPro-Linux2
- PostgreSQL: service uptime000pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]73650600uptime0000100App-PostgresPro-Linux2
- PostgreSQL locks: Read only queries000pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: SELECT FOR SHARE and SELECT FOR UPDATE000pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: Write queries000pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY000pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: CREATE INDEX000pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: Locks from application000pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: Locks from application or some operation on system catalogs000pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE000pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL statements: read bytes/s000pgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux2
- PostgreSQL statements: write bytes/s000pgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux2
- PostgreSQL statements: dirty bytes/s000pgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux2
- PostgreSQL statements: read io time000pgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux2
- PostgreSQL statements: write io time000pgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux2
- PostgreSQL statements: other (mostly cpu) time000pgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux2
- Processes: in state running000system.processes.running736506000000100App-PostgresPro-Linux2
- Processes: in state blocked000system.processes.blocked736506000000100App-PostgresPro-Linux2
- Processes: forkrate000system.processes.forkrate736506001000100App-PostgresPro-Linux2
- CPU time spent by normal programs and daemons000system.cpu.user736506001000100App-PostgresPro-Linux2
- CPU time spent by nice(1)d programs000system.cpu.nice736506001000100App-PostgresPro-Linux2
- CPU time spent by the kernel in system activities000system.cpu.system736506001000100App-PostgresPro-Linux2
- CPU time spent Idle CPU time000system.cpu.idle736506001000100App-PostgresPro-Linux2
- CPU time spent waiting for I/O operations000system.cpu.iowait736506001000100App-PostgresPro-Linux2
- CPU time spent handling interrupts000system.cpu.irq736506001000100App-PostgresPro-Linux2
- CPU time spent handling batched interrupts000system.cpu.softirq736506001000100App-PostgresPro-Linux2
- System up_time000system.up_time73650603uptime0000100App-PostgresPro-Linux2
- PostgreSQL: wal write speed000pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux2
- PostgreSQL: streaming replication lag000pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: count of xlog files000pgsql.wal.count[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- Database discovery0600000{#DATABASE}:.*07pgsql.database.discovery[{$PG_CONNINFO},{$PG_PATH}]Database {#DATABASE}: size000pgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]736503003b0000100App-PostgresPro-Linux2Max age (datfrozenxid) in: {#DATABASE}000pgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-Linux2Count of bloating tables in database: {#DATABASE}000pgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-Linux2Database: {#DATABASE} size9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linux2pgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
Database bloating overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
1000CC00120- PostgresPro-Linux2pgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
Database max age overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
1000CC00120- PostgresPro-Linux2pgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
VFS discovery0600000{#MOUNTPOINT}:.*07system.vfs.discoveryMount point {#MOUNTPOINT}: used000system.vfs.used[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-Linux2Mount point {#MOUNTPOINT}: free000system.vfs.free[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-Linux2Mount point {#MOUNTPOINT}: free in percents000system.vfs.percent_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-Linux2{PostgresPro-Linux2:system.vfs.percent_free[{#MOUNTPOINT}].last()}<10Free disk space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030Mount point overview: {#MOUNTPOINT}9002000.0100.0111100.00.0000000CC0000020- PostgresPro-Linux2system.vfs.used[{#MOUNTPOINT}]
100000CC020- PostgresPro-Linux2system.vfs.free[{#MOUNTPOINT}]
Block device discovery0600000{#BLOCKDEVICE}:.*07system.disk.discoveryBlock device {#BLOCKDEVICE}: utilization000system.disk.utilization[{#BLOCKDEVICE}]73650600%1000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: read operations000system.disk.read[{#BLOCKDEVICE}]736506001000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: write operations000system.disk.write[{#BLOCKDEVICE}]736506001000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: read byte/s000system.disk.read_b[{#BLOCKDEVICE}]73650600b1000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: write byte/s000system.disk.write_b[{#BLOCKDEVICE}]73650600b1000100App-PostgresPro-Linux2Block device overview: {#BLOCKDEVICE} operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.read[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linux2system.disk.write[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linux2system.disk.utilization[{#BLOCKDEVICE}]
Block device overview: {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.read_b[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linux2system.disk.write_b[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linux2system.disk.utilization[{#BLOCKDEVICE}]
Net iface discovery0600000{#NETDEVICE}:.*07system.net.discoveryNetwork device {#NETDEVICE}: RX bytes/s000system.net.rx_bytes[{#NETDEVICE}]73650600b1000100App-PostgresPro-Linux2Network device {#NETDEVICE}: RX errors/s000system.net.rx_errs[{#NETDEVICE}]736506001000100App-PostgresPro-Linux2Network device {#NETDEVICE}: RX drops/s000system.net.rx_drop[{#NETDEVICE}]736506001000100App-PostgresPro-Linux2Network device {#NETDEVICE}: TX bytes/s000system.net.tx_bytes[{#NETDEVICE}]73650600b1000100App-PostgresPro-Linux2Network device {#NETDEVICE}: TX errors/s000system.net.tx_errs[{#NETDEVICE}]736506001000100App-PostgresPro-Linux2Network device {#NETDEVICE}: TX drops/s000system.net.tx_drop[{#NETDEVICE}]736506001000100App-PostgresPro-Linux2Network device: {#NETDEVICE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.net.rx_bytes[{#NETDEVICE}]
100000CC020- PostgresPro-Linux2system.net.tx_bytes[{#NETDEVICE}]
- {$PG_CONNINFO}-qAt -p 5433 -U postgres {$PG_PATH}/opt/pgpro/std-10/bin/psql
-
-
- {PostgresPro-Linux2:pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}].last()}>2PostgreSQL count files in ./archive_status on {HOSTNAME} more than 2030{PostgresPro-Linux2:pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}].last()}>12PostgreSQL required checkpoints occurs to frequently on {HOSTNAME}030 {PostgresPro-Linux2:pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}].last()}/{PostgresPro-Linux2:pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}].last()}*100 >90PostgreSQL many connections on {HOSTNAME} (total connections more than 90% max connections)030{PostgresPro-Linux2:mamonsu.plugin.keepalive.nodata(180)}=1Mamonsu nodata from {HOSTNAME}030{PostgresPro-Linux2:pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}].last()}>18000000PostgreSQL oldest xid is too big on {HOSTNAME}030{PostgresPro-Linux2:pgsql.oldest.query_time[{$PG_CONNINFO},{$PG_PATH}].last()}>18000PostgreSQL query running is too old on {HOSTNAME}030{PostgresPro-Linux2:pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}].last()}<600PostgreSQL service was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{PostgresPro-Linux2:pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}].last()}<80PostgreSQL cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{PostgresPro-Linux2:system.processes.forkrate.min(5m)}>500Process fork-rate to frequently on {HOSTNAME}030{PostgresPro-Linux2:system.up_time.last()}<300System was restarted on {HOSTNAME} (up_time={ITEM.LASTVALUE})030{PostgresPro-Linux2:pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}].last()}>300PostgreSQL streaming lag to high on {HOSTNAME} (value={ITEM.LASTVALUE})030
- PostgreSQL archive command archive_status 9002000.0100.0110100.00.0000000FF0000020- PostgresPro-Linux2pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]
1000FF00120- PostgresPro-Linux2pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL archive command trying_to_archive 9002000.0100.0110100.00.000000000F000020- PostgresPro-Linux2pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]
10FF0000120- PostgresPro-Linux2pgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL bgwriter9002000.0100.0110100.00.0000000CCCC00120- PostgresPro-Linux2pgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]
100000CC120- PostgresPro-Linux2pgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]
20777777020- PostgresPro-Linux2pgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]
30CC0000120- PostgresPro-Linux2pgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]
40CC00CC020- PostgresPro-Linux2pgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]
5000CC00120- PostgresPro-Linux2pgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL checkpoints9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]
10CC0000020- PostgresPro-Linux2pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]
200000CC120- PostgresPro-Linux2pgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]
30000000120- PostgresPro-Linux2pgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL connections9002000.0100.0110100.00.000000000BB00020- PostgresPro-Linux2pgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]
100000BB020- PostgresPro-Linux2pgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]
20CC00CC020- PostgresPro-Linux2pgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]
30CCCCCC020- PostgresPro-Linux2pgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]
40CCCC00020- PostgresPro-Linux2pgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]
5000CCCC020- PostgresPro-Linux2pgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]
60EEEEEE020- PostgresPro-Linux2pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]
70BB0000020- PostgresPro-Linux2pgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]
8000BB00020- PostgresPro-Linux2pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]
Block devices: read/write operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.all_read
100000CC020- PostgresPro-Linux2system.disk.all_write
Block devices: read/write bytes9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.all_read_b
100000CC020- PostgresPro-Linux2system.disk.all_write_b
PostgreSQL instance: rate9002000.0100.0110100.00.00000000000CC120- PostgresPro-Linux2pgsql.transactions.total[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linux2pgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linux2pgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: events9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linux2pgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]
10000000020- PostgresPro-Linux2pgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linux2pgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: temp files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]
100000CC120- PostgresPro-Linux2pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: tuples9002000.0100.0110100.00.0000000000000020- PostgresPro-Linux2pgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]
100000CC020- PostgresPro-Linux2pgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]
2000CC00020- PostgresPro-Linux2pgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]
30CC00CC120- PostgresPro-Linux2pgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]
40CC0000020- PostgresPro-Linux2pgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]
System load average9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2system.la.1
Memory overview9004000.0100.0111100.00.0000000CC0000020- PostgresPro-Linux2system.memory.apps
1000CC00020- PostgresPro-Linux2system.memory.buffers
200000CC020- PostgresPro-Linux2system.memory.swap
30CC00CC020- PostgresPro-Linux2system.memory.cached
40000000020- PostgresPro-Linux2system.memory.unused
50CCCC00020- PostgresPro-Linux2system.memory.slab
60777777020- PostgresPro-Linux2system.memory.swap_cache
70770000020- PostgresPro-Linux2system.memory.page_tables
80000077020- PostgresPro-Linux2system.memory.vmalloc_used
90007700020- PostgresPro-Linux2system.memory.committed
100DF0000020- PostgresPro-Linux2system.memory.mapped
11000DF00020- PostgresPro-Linux2system.memory.active
1200000DF020- PostgresPro-Linux2system.memory.inactive
PostgreSQL oldest query running time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.oldest.query_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL age of oldest xid9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]
System: count of opened files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2system.open_files
PostgreSQL: shared buffer9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linux2pgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]
10CC0000020- PostgresPro-Linux2pgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]
2000CC00020- PostgresPro-Linux2pgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL uptime9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]
10DF0101120- PostgresPro-Linux2pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL locks sampling9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linux2pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linux2pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linux2pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]
30CC00CC020- PostgresPro-Linux2pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]
40777777020- PostgresPro-Linux2pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]
50CCCCCC020- PostgresPro-Linux2pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]
60CCCC00020- PostgresPro-Linux2pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]
7000CCCC020- PostgresPro-Linux2pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL statements: bytes9002000.0100.0110100.00.0000000BBBB00020- PostgresPro-Linux2pgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linux2pgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]
200000CC020- PostgresPro-Linux2pgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL statements: spend time9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linux2pgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]
100000CC020- PostgresPro-Linux2pgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]
20BBBB00020- PostgresPro-Linux2pgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]
Processes overview9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.processes.running
1000CC00020- PostgresPro-Linux2system.processes.blocked
200000CC120- PostgresPro-Linux2system.processes.forkrate
CPU time spent9002000.0100.0111100.00.00000000000CC020- PostgresPro-Linux2system.cpu.user
10CC00CC020- PostgresPro-Linux2system.cpu.nice
20CC0000020- PostgresPro-Linux2system.cpu.system
3000CC00020- PostgresPro-Linux2system.cpu.idle
40CCCC00020- PostgresPro-Linux2system.cpu.iowait
50777777020- PostgresPro-Linux2system.cpu.irq
60000077020- PostgresPro-Linux2system.cpu.softirq
System up_time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2system.up_time
PostgreSQL write-ahead log generation speed9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL replication lag in second9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL count of xlog files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.wal.count[{$PG_CONNINFO},{$PG_PATH}]
-
\ No newline at end of file
diff --git a/packaging/conf/old_templates/template_2.4.1-2.4.3.xml b/packaging/conf/old_templates/template_2.4.1-2.4.3.xml
deleted file mode 100644
index afb8943d..00000000
--- a/packaging/conf/old_templates/template_2.4.1-2.4.3.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-2.0
-
-
- Templates
-
-
-
-
- PostgresPro-Linux2
- PostgresPro-Linux2
-
-
- Templates
-
-
-
-
- App-PostgresPro-Linux2
-
-
- - PostgreSQL archive command count files in archive_status need to archive200pgsql.archive_command[count_files_to_archive]736506030000100App-PostgresPro-Linux2
- PostgreSQL archive command size of files need to archive200pgsql.archive_command[size_files_to_archive]736506030000100App-PostgresPro-Linux2
- PostgreSQL archive command count archived files200pgsql.archive_command[archived_files]736506030000100App-PostgresPro-Linux2
- PostgreSQL archive command count attempts to archive files200pgsql.archive_command[failed_trying_to_archive]736506030000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers written during checkpoints200pgsql.bgwriter[buffers_checkpoint]736506030000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers written200pgsql.bgwriter[buffers_clean]736506030000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: number of bgwriter stopped by max write count200pgsql.bgwriter[maxwritten_clean]736506030000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers written directly by a backend200pgsql.bgwriter[buffers_backend]736506030000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: times a backend execute its own fsync200pgsql.bgwriter[buffers_backend_fsync]736506030000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers allocated200pgsql.bgwriter[buffers_alloc]736506030000100App-PostgresPro-Linux2
- PostgreSQL cfs compression: written byte/s200pgsql.cfs.activity[written_bytes]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL cfs compression: scanned byte/s200pgsql.cfs.activity[scanned_bytes]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL cfs compression: compressed files200pgsql.cfs.activity[compressed_files]736506000000100App-PostgresPro-Linux2
- PostgreSQL cfs compression: scanned files200pgsql.cfs.activity[scanned_files]736506000000100App-PostgresPro-Linux2
- PostgreSQL cfs compression: current ratio200pgsql.cfs.activity[current_compress_ratio]736506000000100App-PostgresPro-Linux2
- PostgreSQL cfs compression: total ratio200pgsql.cfs.activity[total_compress_ratio]736506000000100App-PostgresPro-Linux2
- PostgreSQL checkpoints: by timeout (in hour)200pgsql.checkpoint[count_timed]7365030000000100App-PostgresPro-Linux2
- PostgreSQL checkpoints: by wal (in hour)200pgsql.checkpoint[count_wal]7365030000000100App-PostgresPro-Linux2
- PostgreSQL checkpoint: write time200pgsql.checkpoint[write_time]736503000ms0000100App-PostgresPro-Linux2
- PostgreSQL checkpoint: sync time200pgsql.checkpoint[checkpoint_sync_time]736503000ms0000100App-PostgresPro-Linux2
- PostgreSQL: number of total connections200pgsql.connections[total]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of waiting connections200pgsql.connections[waiting]736506000000100App-PostgresPro-Linux2
- PostgreSQL: max connections200pgsql.connections[max_connections]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of active connections200pgsql.connections[active]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of idle connections200pgsql.connections[idle]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of idle in transaction connections200pgsql.connections[idle_in_transaction]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of idle in transaction (aborted)200pgsql.connections[idle_in_transaction_aborted]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of fastpath function call200pgsql.connections[fastpath_function_call]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of disabled200pgsql.connections[disabled]736506000000100App-PostgresPro-Linux2
- PostgreSQL: count of autovacuum workers200pgsql.autovacumm.count[]7365030000000100App-PostgresPro-Linux2
- Block devices: read requests200system.disk.all_read[]736506000000100App-PostgresPro-Linux2
- Block devices: write requests200system.disk.all_write[]736506000000100App-PostgresPro-Linux2
- Block devices: read byte/s200system.disk.all_read_b[]736506000000100App-PostgresPro-Linux2
- Block devices: write byte/s200system.disk.all_write_b[]736506000000100App-PostgresPro-Linux2
- Mamonsu: plugin errors200mamonsu.plugin.errors[]736506040000100App-PostgresPro-Linux2
- Mamonsu: plugin keep alive200mamonsu.plugin.keepalive[]736506000000100App-PostgresPro-Linux2
- Mamonsu: rss memory max usage200mamonsu.memory.rss[max]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL transactions: total200pgsql.transactions[total]736506000000100App-PostgresPro-Linux2
- PostgreSQL blocks: hit200pgsql.blocks[hit]736506000000100App-PostgresPro-Linux2
- PostgreSQL blocks: read200pgsql.blocks[read]736506000000100App-PostgresPro-Linux2
- PostgreSQL event: conflicts200pgsql.events[conflicts]736506000000100App-PostgresPro-Linux2
- PostgreSQL event: deadlocks200pgsql.events[deadlocks]736506000000100App-PostgresPro-Linux2
- PostgreSQL event: rollbacks200pgsql.events[xact_rollback]736506000000100App-PostgresPro-Linux2
- PostgreSQL temp: bytes written200pgsql.temp[bytes]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL temp: files created200pgsql.temp[files]736506000000100App-PostgresPro-Linux2
- PostgreSQL tuples: deleted200pgsql.tuples[deleted]736506000000100App-PostgresPro-Linux2
- PostgreSQL tuples: fetched200pgsql.tuples[fetched]736506000000100App-PostgresPro-Linux2
- PostgreSQL tuples: inserted200pgsql.tuples[inserted]736506000000100App-PostgresPro-Linux2
- PostgreSQL tuples: returned200pgsql.tuples[returned]736506000000100App-PostgresPro-Linux2
- PostgreSQL tuples: updated200pgsql.tuples[updated]736506000000100App-PostgresPro-Linux2
- System load average over 1 minute200system.la[1]736506000000100App-PostgresPro-Linux2
- Apps: User-space applications200system.memory[apps]73650603b0000100App-PostgresPro-Linux2
- Buffers: Block device cache and dirty200system.memory[buffers]73650603b0000100App-PostgresPro-Linux2
- Swap: Swap space used200system.memory[swap]73650603b0000100App-PostgresPro-Linux2
- Cached: Parked file data (file content) cache200system.memory[cached]73650603b0000100App-PostgresPro-Linux2
- Free: Wasted memory200system.memory[unused]73650603b0000100App-PostgresPro-Linux2
- Slab: Kernel used memory (inode cache)200system.memory[slab]73650603b0000100App-PostgresPro-Linux2
- SwapCached: Fetched unmod yet swap pages200system.memory[swap_cache]73650603b0000100App-PostgresPro-Linux2
- PageTables: Map bt virtual and physical200system.memory[page_tables]73650603b0000100App-PostgresPro-Linux2
- VMallocUsed: vmaloc() allocated by kernel200system.memory[vmalloc_used]73650603b0000100App-PostgresPro-Linux2
- Committed_AS: Total committed memory200system.memory[committed]73650603b0000100App-PostgresPro-Linux2
- Mapped: All mmap()ed pages200system.memory[mapped]73650603b0000100App-PostgresPro-Linux2
- Active: Memory recently used200system.memory[active]73650603b0000100App-PostgresPro-Linux2
- Inactive: Memory not currently used200system.memory[inactive]73650603b0000100App-PostgresPro-Linux2
- PostgreSQL: age of oldest xid200pgsql.oldest[xid_age]736506030000100App-PostgresPro-Linux2
- PostgreSQL: oldest query running time in sec200pgsql.oldest[query_time]73650600s0000100App-PostgresPro-Linux2
- Opened files200system.open_files[]736506030000100App-PostgresPro-Linux2
- PostgreSQL: shared buffer size200pgsql.buffers[size]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL: shared buffer twice used size200pgsql.buffers[twice_used]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL: shared buffer dirty size200pgsql.buffers[dirty]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL: ping200pgsql.ping[]73650600ms0000100App-PostgresPro-Linux2
- PostgreSQL: cache hit ratio200pgsql.cache[hit]73650603%0000100App-PostgresPro-Linux2
- PostgreSQL: service uptime200pgsql.uptime[]73650603uptime0000100App-PostgresPro-Linux2
- PostgreSQL locks: Read only queries200pgsql.pg_locks[accessshare]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: SELECT FOR SHARE and SELECT FOR UPDATE200pgsql.pg_locks[rowshare]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: Write queries200pgsql.pg_locks[rowexclusive]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY200pgsql.pg_locks[shareupdateexclusive]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: CREATE INDEX200pgsql.pg_locks[share]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: Locks from application200pgsql.pg_locks[sharerowexclusive]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: Locks from application or some operation on system catalogs200pgsql.pg_locks[exclusive]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE200pgsql.pg_locks[accessexclusive]736506030000100App-PostgresPro-Linux2
- PostgreSQL statements: read bytes/s200pgsql.stat[read_bytes]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL statements: write bytes/s200pgsql.stat[write_bytes]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL statements: dirty bytes/s200pgsql.stat[dirty_bytes]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL statements: read io time200pgsql.stat[read_time]73650600s0000100App-PostgresPro-Linux2
- PostgreSQL statements: write io time200pgsql.stat[write_time]73650600s0000100App-PostgresPro-Linux2
- PostgreSQL statements: other (mostly cpu) time200pgsql.stat[other_time]73650600s0000100App-PostgresPro-Linux2
- Processes: in state running200system.processes[running]736506000000100App-PostgresPro-Linux2
- Processes: in state blocked200system.processes[blocked]736506000000100App-PostgresPro-Linux2
- Processes: forkrate200system.processes[forkrate]736506000000100App-PostgresPro-Linux2
- CPU time spent by normal programs and daemons200system.cpu[user]736506000000100App-PostgresPro-Linux2
- CPU time spent by nice(1)d programs200system.cpu[nice]736506000000100App-PostgresPro-Linux2
- CPU time spent by the kernel in system activities200system.cpu[system]736506000000100App-PostgresPro-Linux2
- CPU time spent Idle CPU time200system.cpu[idle]736506000000100App-PostgresPro-Linux2
- CPU time spent waiting for I/O operations200system.cpu[iowait]736506000000100App-PostgresPro-Linux2
- CPU time spent handling interrupts200system.cpu[irq]736506000000100App-PostgresPro-Linux2
- CPU time spent handling batched interrupts200system.cpu[softirq]736506000000100App-PostgresPro-Linux2
- System up_time200system.up_time[]73650603uptime0000100App-PostgresPro-Linux2
- PostgreSQL: wal write speed200pgsql.wal.write[]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL: streaming replication lag200pgsql.replication_lag[sec]736506000000100App-PostgresPro-Linux2
- PostgreSQL: count of xlog files200pgsql.wal.count[]736506000000100App-PostgresPro-Linux2
- Compressed relations discovery2600000{#COMPRESSED_RELATION}:.*07pgsql.cfs.discovery_compressed_relations[]Relation {#COMPRESSED_RELATION}: compress ratio200pgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]7365060000000100App-PostgresPro-Linux2Relation {#COMPRESSED_RELATION}: compress ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]
Database discovery2600000{#DATABASE}:.*07pgsql.database.discovery[]Database {#DATABASE}: size200pgsql.database.size[{#DATABASE}]736503003b0000100App-PostgresPro-Linux2Max age (datfrozenxid) in: {#DATABASE}200pgsql.database.max_age[{#DATABASE}]7365030000000100App-PostgresPro-Linux2Count of bloating tables in database: {#DATABASE}200pgsql.database.bloating_tables[{#DATABASE}]7365030000000100App-PostgresPro-Linux2Database: {#DATABASE} size9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linux2pgsql.database.size[{#DATABASE}]
Database bloating overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.database.bloating_tables[{#DATABASE}]
1000CC00120- PostgresPro-Linux2pgsql.autovacumm.count[]
Database max age overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.database.max_age[{#DATABASE}]
1000CC00120- PostgresPro-Linux2pgsql.autovacumm.count[]
VFS discovery2600000{#MOUNTPOINT}:.*07system.vfs.discovery[]Mount point {#MOUNTPOINT}: used200system.vfs.used[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-Linux2Mount point {#MOUNTPOINT}: free200system.vfs.free[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-Linux2Mount point {#MOUNTPOINT}: free in percents200system.vfs.percent_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-Linux2Mount point {#MOUNTPOINT}: free inodes in percent200system.vfs.percent_inode_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-Linux2{PostgresPro-Linux2:system.vfs.percent_free[{#MOUNTPOINT}].last()}<10Free disk space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030{PostgresPro-Linux2:system.vfs.percent_inode_free[{#MOUNTPOINT}].last()}<10Free inode space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030Mount point overview: {#MOUNTPOINT}9002000.0100.0111100.00.0000000CC0000020- PostgresPro-Linux2system.vfs.used[{#MOUNTPOINT}]
100000CC020- PostgresPro-Linux2system.vfs.free[{#MOUNTPOINT}]
Block device discovery2600000{#BLOCKDEVICE}:.*07system.disk.discovery[]Block device {#BLOCKDEVICE}: utilization200system.disk.utilization[{#BLOCKDEVICE}]73650600%0000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: read operations200system.disk.read[{#BLOCKDEVICE}]736506000000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: write operations200system.disk.write[{#BLOCKDEVICE}]736506000000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: read byte/s200system.disk.read_b[{#BLOCKDEVICE}]73650600b0000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: write byte/s200system.disk.write_b[{#BLOCKDEVICE}]73650600b0000100App-PostgresPro-Linux2Block device overview: {#BLOCKDEVICE} operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.read[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linux2system.disk.write[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linux2system.disk.utilization[{#BLOCKDEVICE}]
Block device overview: {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.read_b[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linux2system.disk.write_b[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linux2system.disk.utilization[{#BLOCKDEVICE}]
Net iface discovery2600000{#NETDEVICE}:.*07system.net.discovery[]Network device {#NETDEVICE}: RX bytes/s200system.net.rx_bytes[{#NETDEVICE}]73650600b0000100App-PostgresPro-Linux2Network device {#NETDEVICE}: RX errors/s200system.net.rx_errs[{#NETDEVICE}]736506000000100App-PostgresPro-Linux2Network device {#NETDEVICE}: RX drops/s200system.net.rx_drop[{#NETDEVICE}]736506000000100App-PostgresPro-Linux2Network device {#NETDEVICE}: TX bytes/s200system.net.tx_bytes[{#NETDEVICE}]73650600b0000100App-PostgresPro-Linux2Network device {#NETDEVICE}: TX errors/s200system.net.tx_errs[{#NETDEVICE}]736506000000100App-PostgresPro-Linux2Network device {#NETDEVICE}: TX drops/s200system.net.tx_drop[{#NETDEVICE}]736506000000100App-PostgresPro-Linux2Network device: {#NETDEVICE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.net.rx_bytes[{#NETDEVICE}]
100000CC020- PostgresPro-Linux2system.net.tx_bytes[{#NETDEVICE}]
-
-
-
- {PostgresPro-Linux2:pgsql.archive_command[count_files_to_archive].last()}>2PostgreSQL count files in ./archive_status on {HOSTNAME} more than 2030{PostgresPro-Linux2:pgsql.checkpoint[count_wal].last()}>12PostgreSQL required checkpoints occurs to frequently on {HOSTNAME}030 {PostgresPro-Linux2:pgsql.connections[total].last()}/{PostgresPro-Linux2:pgsql.connections[max_connections].last()}*100 >90PostgreSQL many connections on {HOSTNAME} (total connections more than 90% max connections)030{PostgresPro-Linux2:mamonsu.plugin.errors[].strlen()}>1Mamonsu plugin errors on {HOSTNAME}. {ITEM.LASTVALUE}030{PostgresPro-Linux2:mamonsu.plugin.keepalive[].nodata(180)}=1Mamonsu nodata from {HOSTNAME}030{PostgresPro-Linux2:mamonsu.memory.rss[max].last()}>41943040Mamonsu agent memory usage alert on {HOSTNAME}: {ITEM.LASTVALUE} bytes030{PostgresPro-Linux2:pgsql.oldest[xid_age].last()}>18000000PostgreSQL oldest xid is too big on {HOSTNAME}030{PostgresPro-Linux2:pgsql.oldest[query_time].last()}>18000PostgreSQL query running is too old on {HOSTNAME}030{PostgresPro-Linux2:pgsql.uptime[].last()}<600PostgreSQL service was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{PostgresPro-Linux2:pgsql.cache[hit].last()}<80PostgreSQL cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{PostgresPro-Linux2:pgsql.ping[].nodata(180)}=1PostgreSQL no ping from PostgreSQL for 3 minutes {HOSTNAME} 030{PostgresPro-Linux2:system.processes[forkrate].min(5m)}>500Process fork-rate to frequently on {HOSTNAME}030{PostgresPro-Linux2:system.up_time[].last()}<300System was restarted on {HOSTNAME} (up_time={ITEM.LASTVALUE})030{PostgresPro-Linux2:pgsql.replication_lag[sec].last()}>300PostgreSQL streaming lag to high on {HOSTNAME} (value={ITEM.LASTVALUE})030
- PostgreSQL archive command archive_status 9002000.0100.0110100.00.0000000FF0000020- PostgresPro-Linux2pgsql.archive_command[count_files_to_archive]
1000FF00120- PostgresPro-Linux2pgsql.archive_command[size_files_to_archive]
PostgreSQL archive command trying_to_archive 9002000.0100.0110100.00.000000000F000020- PostgresPro-Linux2pgsql.archive_command[archived_files]
10FF0000120- PostgresPro-Linux2pgsql.archive_command[failed_trying_to_archive]
PostgreSQL bgwriter9002000.0100.0110100.00.0000000CCCC00120- PostgresPro-Linux2pgsql.bgwriter[buffers_checkpoint]
100000CC120- PostgresPro-Linux2pgsql.bgwriter[buffers_clean]
20777777020- PostgresPro-Linux2pgsql.bgwriter[maxwritten_clean]
30CC0000120- PostgresPro-Linux2pgsql.bgwriter[buffers_backend]
40CC00CC020- PostgresPro-Linux2pgsql.bgwriter[buffers_backend_fsync]
5000CC00120- PostgresPro-Linux2pgsql.bgwriter[buffers_alloc]
PostgreSQL cfs compression: current ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.cfs.activity[current_compress_ratio]
PostgreSQL cfs compression: compressed files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.cfs.activity[compressed_files]
PostgreSQL cfs compression: written bytes9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.cfs.activity[written_bytes]
PostgreSQL cfs compression: total ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.cfs.activity[total_compress_ratio]
PostgreSQL checkpoints9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.checkpoint[count_timed]
10CC0000020- PostgresPro-Linux2pgsql.checkpoint[count_wal]
200000CC120- PostgresPro-Linux2pgsql.checkpoint[write_time]
30000000120- PostgresPro-Linux2pgsql.checkpoint[checkpoint_sync_time]
PostgreSQL connections9002000.0100.0110100.00.000000000BB00020- PostgresPro-Linux2pgsql.connections[active]
100000BB020- PostgresPro-Linux2pgsql.connections[idle]
20CC00CC020- PostgresPro-Linux2pgsql.connections[idle_in_transaction]
30CCCCCC020- PostgresPro-Linux2pgsql.connections[idle_in_transaction_aborted]
40CCCC00020- PostgresPro-Linux2pgsql.connections[fastpath_function_call]
5000CCCC020- PostgresPro-Linux2pgsql.connections[disabled]
60EEEEEE020- PostgresPro-Linux2pgsql.connections[total]
70BB0000020- PostgresPro-Linux2pgsql.connections[waiting]
8000BB00020- PostgresPro-Linux2pgsql.connections[max_connections]
Block devices: read/write operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.all_read[]
100000CC020- PostgresPro-Linux2system.disk.all_write[]
Block devices: read/write bytes9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.all_read_b[]
100000CC020- PostgresPro-Linux2system.disk.all_write_b[]
PostgreSQL instance: rate9002000.0100.0110100.00.00000000000CC120- PostgresPro-Linux2pgsql.transactions[total]
1000CC00020- PostgresPro-Linux2pgsql.blocks[hit]
20CC0000020- PostgresPro-Linux2pgsql.blocks[read]
PostgreSQL instance: events9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linux2pgsql.events[conflicts]
10000000020- PostgresPro-Linux2pgsql.events[deadlocks]
20CC0000020- PostgresPro-Linux2pgsql.events[xact_rollback]
PostgreSQL instance: temp files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.temp[bytes]
100000CC120- PostgresPro-Linux2pgsql.temp[files]
PostgreSQL instance: tuples9002000.0100.0110100.00.0000000000000020- PostgresPro-Linux2pgsql.tuples[deleted]
100000CC020- PostgresPro-Linux2pgsql.tuples[fetched]
2000CC00020- PostgresPro-Linux2pgsql.tuples[inserted]
30CC00CC120- PostgresPro-Linux2pgsql.tuples[returned]
40CC0000020- PostgresPro-Linux2pgsql.tuples[updated]
System load average9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2system.la[1]
Memory overview9004000.0100.0111100.00.0000000CC0000020- PostgresPro-Linux2system.memory[apps]
1000CC00020- PostgresPro-Linux2system.memory[buffers]
200000CC020- PostgresPro-Linux2system.memory[swap]
30CC00CC020- PostgresPro-Linux2system.memory[cached]
40000000020- PostgresPro-Linux2system.memory[unused]
50CCCC00020- PostgresPro-Linux2system.memory[slab]
60777777020- PostgresPro-Linux2system.memory[swap_cache]
70770000020- PostgresPro-Linux2system.memory[page_tables]
80000077020- PostgresPro-Linux2system.memory[vmalloc_used]
90007700020- PostgresPro-Linux2system.memory[committed]
100DF0000020- PostgresPro-Linux2system.memory[mapped]
11000DF00020- PostgresPro-Linux2system.memory[active]
1200000DF020- PostgresPro-Linux2system.memory[inactive]
PostgreSQL oldest query running time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.oldest[query_time]
PostgreSQL age of oldest xid9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.oldest[xid_age]
System: count of opened files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2system.open_files[]
PostgreSQL: shared buffer9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linux2pgsql.buffers[size]
10CC0000020- PostgresPro-Linux2pgsql.buffers[twice_used]
2000CC00020- PostgresPro-Linux2pgsql.buffers[dirty]
PostgreSQL uptime9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.cache[hit]
10DF0101120- PostgresPro-Linux2pgsql.uptime[]
PostgreSQL locks sampling9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linux2pgsql.pg_locks[accessshare]
1000CC00020- PostgresPro-Linux2pgsql.pg_locks[rowshare]
20CC0000020- PostgresPro-Linux2pgsql.pg_locks[rowexclusive]
30CC00CC020- PostgresPro-Linux2pgsql.pg_locks[shareupdateexclusive]
40777777020- PostgresPro-Linux2pgsql.pg_locks[share]
50CCCCCC020- PostgresPro-Linux2pgsql.pg_locks[sharerowexclusive]
60CCCC00020- PostgresPro-Linux2pgsql.pg_locks[exclusive]
7000CCCC020- PostgresPro-Linux2pgsql.pg_locks[accessexclusive]
PostgreSQL statements: bytes9002000.0100.0110100.00.0000000BBBB00020- PostgresPro-Linux2pgsql.stat[read_bytes]
1000CC00020- PostgresPro-Linux2pgsql.stat[write_bytes]
200000CC020- PostgresPro-Linux2pgsql.stat[dirty_bytes]
PostgreSQL statements: spend time9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linux2pgsql.stat[read_time]
100000CC020- PostgresPro-Linux2pgsql.stat[write_time]
20BBBB00020- PostgresPro-Linux2pgsql.stat[other_time]
Processes overview9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.processes[running]
1000CC00020- PostgresPro-Linux2system.processes[blocked]
200000CC120- PostgresPro-Linux2system.processes[forkrate]
CPU time spent9002000.0100.0111100.00.00000000000CC020- PostgresPro-Linux2system.cpu[user]
10CC00CC020- PostgresPro-Linux2system.cpu[nice]
20CC0000020- PostgresPro-Linux2system.cpu[system]
3000CC00020- PostgresPro-Linux2system.cpu[idle]
40CCCC00020- PostgresPro-Linux2system.cpu[iowait]
50777777020- PostgresPro-Linux2system.cpu[irq]
60000077020- PostgresPro-Linux2system.cpu[softirq]
System up_time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2system.up_time[]
PostgreSQL write-ahead log generation speed9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.wal.write[]
PostgreSQL replication lag in second9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.replication_lag[sec]
PostgreSQL count of xlog files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.wal.count[]
-
\ No newline at end of file
diff --git a/packaging/conf/old_templates/template_2.4.1-2.4.3_agent.xml b/packaging/conf/old_templates/template_2.4.1-2.4.3_agent.xml
deleted file mode 100644
index 32985639..00000000
--- a/packaging/conf/old_templates/template_2.4.1-2.4.3_agent.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-2.0
-
-
- Templates
-
-
-
-
- PostgresPro-Linux2
- PostgresPro-Linux2
-
-
- Templates
-
-
-
-
- App-PostgresPro-Linux2
-
-
- - PostgreSQL archive command count files in archive_status need to archive000pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL archive command size of files need to archive000pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL archive command count archived files000pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL archive command count attempts to archive files000pgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers written during checkpoints000pgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers written000pgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: number of bgwriter stopped by max write count000pgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers written directly by a backend000pgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: times a backend execute its own fsync000pgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL bgwriter: buffers allocated000pgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux2
- PostgreSQL checkpoints: by timeout (in hour)000pgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]7365030001000100App-PostgresPro-Linux2
- PostgreSQL checkpoints: by wal (in hour)000pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]7365030001000100App-PostgresPro-Linux2
- PostgreSQL checkpoint: write time000pgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100App-PostgresPro-Linux2
- PostgreSQL checkpoint: sync time000pgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100App-PostgresPro-Linux2
- PostgreSQL: number of total connections000pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of waiting connections000pgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: max connections000pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of active connections000pgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of idle connections000pgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of idle in transaction connections000pgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of idle in transaction (aborted)000pgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of fastpath function call000pgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: number of disabled000pgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: count of autovacuum workers000pgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-Linux2
- Block devices: read requests000system.disk.all_read736506001000100App-PostgresPro-Linux2
- Block devices: write requests000system.disk.all_write736506001000100App-PostgresPro-Linux2
- Block devices: read byte/s000system.disk.all_read_b736506001000100App-PostgresPro-Linux2
- Block devices: write byte/s000system.disk.all_write_b736506001000100App-PostgresPro-Linux2
- Mamonsu: plugin keep alive000mamonsu.plugin.keepalive736506000000100App-PostgresPro-Linux2
- PostgreSQL transactions: total000pgsql.transactions.total[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- PostgreSQL blocks: hit000pgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- PostgreSQL blocks: read000pgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- PostgreSQL event: conflicts000pgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux2
- PostgreSQL event: deadlocks000pgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux2
- PostgreSQL event: rollbacks000pgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux2
- PostgreSQL temp: bytes written000pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b2000100App-PostgresPro-Linux2
- PostgreSQL temp: files created000pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux2
- PostgreSQL tuples: deleted000pgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- PostgreSQL tuples: fetched000pgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- PostgreSQL tuples: inserted000pgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- PostgreSQL tuples: returned000pgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- PostgreSQL tuples: updated000pgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux2
- System load average over 1 minute000system.la.1736506000000100App-PostgresPro-Linux2
- Apps: User-space applications000system.memory.apps73650603b0000100App-PostgresPro-Linux2
- Buffers: Block device cache and dirty000system.memory.buffers73650603b0000100App-PostgresPro-Linux2
- Swap: Swap space used000system.memory.swap73650603b0000100App-PostgresPro-Linux2
- Cached: Parked file data (file content) cache000system.memory.cached73650603b0000100App-PostgresPro-Linux2
- Free: Wasted memory000system.memory.unused73650603b0000100App-PostgresPro-Linux2
- Slab: Kernel used memory (inode cache)000system.memory.slab73650603b0000100App-PostgresPro-Linux2
- SwapCached: Fetched unmod yet swap pages000system.memory.swap_cache73650603b0000100App-PostgresPro-Linux2
- PageTables: Map bt virtual and physical000system.memory.page_tables73650603b0000100App-PostgresPro-Linux2
- VMallocUsed: vmaloc() allocated by kernel000system.memory.vmalloc_used73650603b0000100App-PostgresPro-Linux2
- Committed_AS: Total committed memory000system.memory.committed73650603b0000100App-PostgresPro-Linux2
- Mapped: All mmap()ed pages000system.memory.mapped73650603b0000100App-PostgresPro-Linux2
- Active: Memory recently used000system.memory.active73650603b0000100App-PostgresPro-Linux2
- Inactive: Memory not currently used000system.memory.inactive73650603b0000100App-PostgresPro-Linux2
- PostgreSQL: age of oldest xid000pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL: oldest query running time in sec000pgsql.oldest.query_time[{$PG_CONNINFO},{$PG_PATH}]73650600s0000100App-PostgresPro-Linux2
- Opened files000system.open_files736506030000100App-PostgresPro-Linux2
- PostgreSQL: shared buffer size000pgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL: shared buffer twice used size000pgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL: shared buffer dirty size000pgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux2
- PostgreSQL: ping000pgsql.ping[{$PG_CONNINFO},{$PG_PATH}]7365050ms0000100App-PostgresPro-Linux2
- PostgreSQL: cache hit ratio000pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]73650600%0000100App-PostgresPro-Linux2
- PostgreSQL: service uptime000pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]73650600uptime0000100App-PostgresPro-Linux2
- PostgreSQL locks: Read only queries000pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: SELECT FOR SHARE and SELECT FOR UPDATE000pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: Write queries000pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY000pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: CREATE INDEX000pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: Locks from application000pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: Locks from application or some operation on system catalogs000pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE000pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux2
- PostgreSQL statements: read bytes/s000pgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux2
- PostgreSQL statements: write bytes/s000pgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux2
- PostgreSQL statements: dirty bytes/s000pgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux2
- PostgreSQL statements: read io time000pgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux2
- PostgreSQL statements: write io time000pgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux2
- PostgreSQL statements: other (mostly cpu) time000pgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux2
- Processes: in state running000system.processes.running736506000000100App-PostgresPro-Linux2
- Processes: in state blocked000system.processes.blocked736506000000100App-PostgresPro-Linux2
- Processes: forkrate000system.processes.forkrate736506001000100App-PostgresPro-Linux2
- CPU time spent by normal programs and daemons000system.cpu.user736506001000100App-PostgresPro-Linux2
- CPU time spent by nice(1)d programs000system.cpu.nice736506001000100App-PostgresPro-Linux2
- CPU time spent by the kernel in system activities000system.cpu.system736506001000100App-PostgresPro-Linux2
- CPU time spent Idle CPU time000system.cpu.idle736506001000100App-PostgresPro-Linux2
- CPU time spent waiting for I/O operations000system.cpu.iowait736506001000100App-PostgresPro-Linux2
- CPU time spent handling interrupts000system.cpu.irq736506001000100App-PostgresPro-Linux2
- CPU time spent handling batched interrupts000system.cpu.softirq736506001000100App-PostgresPro-Linux2
- System up_time000system.up_time73650603uptime0000100App-PostgresPro-Linux2
- PostgreSQL: wal write speed000pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux2
- PostgreSQL: streaming replication lag000pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- PostgreSQL: count of xlog files000pgsql.wal.count[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux2
- Database discovery0600000{#DATABASE}:.*07pgsql.database.discovery[{$PG_CONNINFO},{$PG_PATH}]Database {#DATABASE}: size000pgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]736503003b0000100App-PostgresPro-Linux2Max age (datfrozenxid) in: {#DATABASE}000pgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-Linux2Count of bloating tables in database: {#DATABASE}000pgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-Linux2Database: {#DATABASE} size9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linux2pgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
Database bloating overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
1000CC00120- PostgresPro-Linux2pgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
Database max age overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
1000CC00120- PostgresPro-Linux2pgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
VFS discovery0600000{#MOUNTPOINT}:.*07system.vfs.discoveryMount point {#MOUNTPOINT}: used000system.vfs.used[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-Linux2Mount point {#MOUNTPOINT}: free000system.vfs.free[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-Linux2Mount point {#MOUNTPOINT}: free in percents000system.vfs.percent_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-Linux2{PostgresPro-Linux2:system.vfs.percent_free[{#MOUNTPOINT}].last()}<10Free disk space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030Mount point overview: {#MOUNTPOINT}9002000.0100.0111100.00.0000000CC0000020- PostgresPro-Linux2system.vfs.used[{#MOUNTPOINT}]
100000CC020- PostgresPro-Linux2system.vfs.free[{#MOUNTPOINT}]
Block device discovery0600000{#BLOCKDEVICE}:.*07system.disk.discoveryBlock device {#BLOCKDEVICE}: utilization000system.disk.utilization[{#BLOCKDEVICE}]73650600%1000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: read operations000system.disk.read[{#BLOCKDEVICE}]736506001000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: write operations000system.disk.write[{#BLOCKDEVICE}]736506001000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: read byte/s000system.disk.read_b[{#BLOCKDEVICE}]73650600b1000100App-PostgresPro-Linux2Block device {#BLOCKDEVICE}: write byte/s000system.disk.write_b[{#BLOCKDEVICE}]73650600b1000100App-PostgresPro-Linux2Block device overview: {#BLOCKDEVICE} operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.read[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linux2system.disk.write[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linux2system.disk.utilization[{#BLOCKDEVICE}]
Block device overview: {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.read_b[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linux2system.disk.write_b[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linux2system.disk.utilization[{#BLOCKDEVICE}]
Net iface discovery0600000{#NETDEVICE}:.*07system.net.discoveryNetwork device {#NETDEVICE}: RX bytes/s000system.net.rx_bytes[{#NETDEVICE}]73650600b1000100App-PostgresPro-Linux2Network device {#NETDEVICE}: RX errors/s000system.net.rx_errs[{#NETDEVICE}]736506001000100App-PostgresPro-Linux2Network device {#NETDEVICE}: RX drops/s000system.net.rx_drop[{#NETDEVICE}]736506001000100App-PostgresPro-Linux2Network device {#NETDEVICE}: TX bytes/s000system.net.tx_bytes[{#NETDEVICE}]73650600b1000100App-PostgresPro-Linux2Network device {#NETDEVICE}: TX errors/s000system.net.tx_errs[{#NETDEVICE}]736506001000100App-PostgresPro-Linux2Network device {#NETDEVICE}: TX drops/s000system.net.tx_drop[{#NETDEVICE}]736506001000100App-PostgresPro-Linux2Network device: {#NETDEVICE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.net.rx_bytes[{#NETDEVICE}]
100000CC020- PostgresPro-Linux2system.net.tx_bytes[{#NETDEVICE}]
- {$PG_CONNINFO}-qAt -p 5433 -U postgres {$PG_PATH}/opt/pgpro/std-10/bin/psql
-
-
- {PostgresPro-Linux2:pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}].last()}>2PostgreSQL count files in ./archive_status on {HOSTNAME} more than 2030{PostgresPro-Linux2:pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}].last()}>12PostgreSQL required checkpoints occurs to frequently on {HOSTNAME}030 {PostgresPro-Linux2:pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}].last()}/{PostgresPro-Linux2:pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}].last()}*100 >90PostgreSQL many connections on {HOSTNAME} (total connections more than 90% max connections)030{PostgresPro-Linux2:mamonsu.plugin.keepalive.nodata(180)}=1Mamonsu nodata from {HOSTNAME}030{PostgresPro-Linux2:pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}].last()}>18000000PostgreSQL oldest xid is too big on {HOSTNAME}030{PostgresPro-Linux2:pgsql.oldest.query_time[{$PG_CONNINFO},{$PG_PATH}].last()}>18000PostgreSQL query running is too old on {HOSTNAME}030{PostgresPro-Linux2:pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}].last()}<600PostgreSQL service was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{PostgresPro-Linux2:pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}].last()}<80PostgreSQL cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{PostgresPro-Linux2:pgsql.ping[{$PG_CONNINFO},{$PG_PATH}].nodata(180)}=1PostgreSQL no ping from PostgreSQL for 3 minutes {HOSTNAME} 030{PostgresPro-Linux2:system.processes.forkrate.min(5m)}>500Process fork-rate to frequently on {HOSTNAME}030{PostgresPro-Linux2:system.up_time.last()}<300System was restarted on {HOSTNAME} (up_time={ITEM.LASTVALUE})030{PostgresPro-Linux2:pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}].last()}>300PostgreSQL streaming lag to high on {HOSTNAME} (value={ITEM.LASTVALUE})030
- PostgreSQL archive command archive_status 9002000.0100.0110100.00.0000000FF0000020- PostgresPro-Linux2pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]
1000FF00120- PostgresPro-Linux2pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL archive command trying_to_archive 9002000.0100.0110100.00.000000000F000020- PostgresPro-Linux2pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]
10FF0000120- PostgresPro-Linux2pgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL bgwriter9002000.0100.0110100.00.0000000CCCC00120- PostgresPro-Linux2pgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]
100000CC120- PostgresPro-Linux2pgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]
20777777020- PostgresPro-Linux2pgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]
30CC0000120- PostgresPro-Linux2pgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]
40CC00CC020- PostgresPro-Linux2pgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]
5000CC00120- PostgresPro-Linux2pgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL checkpoints9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]
10CC0000020- PostgresPro-Linux2pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]
200000CC120- PostgresPro-Linux2pgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]
30000000120- PostgresPro-Linux2pgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL connections9002000.0100.0110100.00.000000000BB00020- PostgresPro-Linux2pgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]
100000BB020- PostgresPro-Linux2pgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]
20CC00CC020- PostgresPro-Linux2pgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]
30CCCCCC020- PostgresPro-Linux2pgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]
40CCCC00020- PostgresPro-Linux2pgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]
5000CCCC020- PostgresPro-Linux2pgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]
60EEEEEE020- PostgresPro-Linux2pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]
70BB0000020- PostgresPro-Linux2pgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]
8000BB00020- PostgresPro-Linux2pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]
Block devices: read/write operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.all_read
100000CC020- PostgresPro-Linux2system.disk.all_write
Block devices: read/write bytes9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.disk.all_read_b
100000CC020- PostgresPro-Linux2system.disk.all_write_b
PostgreSQL instance: rate9002000.0100.0110100.00.00000000000CC120- PostgresPro-Linux2pgsql.transactions.total[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linux2pgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linux2pgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: events9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linux2pgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]
10000000020- PostgresPro-Linux2pgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linux2pgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: temp files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]
100000CC120- PostgresPro-Linux2pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: tuples9002000.0100.0110100.00.0000000000000020- PostgresPro-Linux2pgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]
100000CC020- PostgresPro-Linux2pgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]
2000CC00020- PostgresPro-Linux2pgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]
30CC00CC120- PostgresPro-Linux2pgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]
40CC0000020- PostgresPro-Linux2pgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]
System load average9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2system.la.1
Memory overview9004000.0100.0111100.00.0000000CC0000020- PostgresPro-Linux2system.memory.apps
1000CC00020- PostgresPro-Linux2system.memory.buffers
200000CC020- PostgresPro-Linux2system.memory.swap
30CC00CC020- PostgresPro-Linux2system.memory.cached
40000000020- PostgresPro-Linux2system.memory.unused
50CCCC00020- PostgresPro-Linux2system.memory.slab
60777777020- PostgresPro-Linux2system.memory.swap_cache
70770000020- PostgresPro-Linux2system.memory.page_tables
80000077020- PostgresPro-Linux2system.memory.vmalloc_used
90007700020- PostgresPro-Linux2system.memory.committed
100DF0000020- PostgresPro-Linux2system.memory.mapped
11000DF00020- PostgresPro-Linux2system.memory.active
1200000DF020- PostgresPro-Linux2system.memory.inactive
PostgreSQL oldest query running time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.oldest.query_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL age of oldest xid9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]
System: count of opened files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2system.open_files
PostgreSQL: shared buffer9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linux2pgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]
10CC0000020- PostgresPro-Linux2pgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]
2000CC00020- PostgresPro-Linux2pgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL uptime9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]
10DF0101120- PostgresPro-Linux2pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL locks sampling9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linux2pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linux2pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linux2pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]
30CC00CC020- PostgresPro-Linux2pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]
40777777020- PostgresPro-Linux2pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]
50CCCCCC020- PostgresPro-Linux2pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]
60CCCC00020- PostgresPro-Linux2pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]
7000CCCC020- PostgresPro-Linux2pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL statements: bytes9002000.0100.0110100.00.0000000BBBB00020- PostgresPro-Linux2pgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linux2pgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]
200000CC020- PostgresPro-Linux2pgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL statements: spend time9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linux2pgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]
100000CC020- PostgresPro-Linux2pgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]
20BBBB00020- PostgresPro-Linux2pgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]
Processes overview9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2system.processes.running
1000CC00020- PostgresPro-Linux2system.processes.blocked
200000CC120- PostgresPro-Linux2system.processes.forkrate
CPU time spent9002000.0100.0111100.00.00000000000CC020- PostgresPro-Linux2system.cpu.user
10CC00CC020- PostgresPro-Linux2system.cpu.nice
20CC0000020- PostgresPro-Linux2system.cpu.system
3000CC00020- PostgresPro-Linux2system.cpu.idle
40CCCC00020- PostgresPro-Linux2system.cpu.iowait
50777777020- PostgresPro-Linux2system.cpu.irq
60000077020- PostgresPro-Linux2system.cpu.softirq
System up_time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linux2system.up_time
PostgreSQL write-ahead log generation speed9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL replication lag in second9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL count of xlog files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linux2pgsql.wal.count[{$PG_CONNINFO},{$PG_PATH}]
-
\ No newline at end of file
diff --git a/packaging/conf/old_templates/template_2.4.4-2.4.5.xml b/packaging/conf/old_templates/template_2.4.4-2.4.5.xml
deleted file mode 100644
index 826c6322..00000000
--- a/packaging/conf/old_templates/template_2.4.4-2.4.5.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-2.0
-
-
- Templates
-
-
-
-
- PostgresPro-Linux
- PostgresPro-Linux
-
-
- Templates
-
-
-
-
- App-PostgresPro-Linux
-
-
- - PostgreSQL archive command count files in archive_status need to archive200pgsql.archive_command[count_files_to_archive]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command size of files need to archive200pgsql.archive_command[size_files_to_archive]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command count archived files200pgsql.archive_command[archived_files]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command count attempts to archive files200pgsql.archive_command[failed_trying_to_archive]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written during checkpoints200pgsql.bgwriter[buffers_checkpoint]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written200pgsql.bgwriter[buffers_clean]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: number of bgwriter stopped by max write count200pgsql.bgwriter[maxwritten_clean]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written directly by a backend200pgsql.bgwriter[buffers_backend]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: times a backend execute its own fsync200pgsql.bgwriter[buffers_backend_fsync]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers allocated200pgsql.bgwriter[buffers_alloc]736506030000100App-PostgresPro-Linux
- PostgreSQL cfs compression: written byte/s200pgsql.cfs.activity[written_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL cfs compression: scanned byte/s200pgsql.cfs.activity[scanned_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL cfs compression: compressed files200pgsql.cfs.activity[compressed_files]736506000000100App-PostgresPro-Linux
- PostgreSQL cfs compression: scanned files200pgsql.cfs.activity[scanned_files]736506000000100App-PostgresPro-Linux
- PostgreSQL cfs compression: current ratio200pgsql.cfs.activity[current_compress_ratio]736506000000100App-PostgresPro-Linux
- PostgreSQL cfs compression: total ratio200pgsql.cfs.activity[total_compress_ratio]736506000000100App-PostgresPro-Linux
- PostgreSQL checkpoints: by timeout (in hour)200pgsql.checkpoint[count_timed]7365030000000100App-PostgresPro-Linux
- PostgreSQL checkpoints: by wal (in hour)200pgsql.checkpoint[count_wal]7365030000000100App-PostgresPro-Linux
- PostgreSQL checkpoint: write time200pgsql.checkpoint[write_time]736503000ms0000100App-PostgresPro-Linux
- PostgreSQL checkpoint: sync time200pgsql.checkpoint[checkpoint_sync_time]736503000ms0000100App-PostgresPro-Linux
- PostgreSQL: number of total connections200pgsql.connections[total]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of waiting connections200pgsql.connections[waiting]736506000000100App-PostgresPro-Linux
- PostgreSQL: max connections200pgsql.connections[max_connections]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of active connections200pgsql.connections[active]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle connections200pgsql.connections[idle]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle in transaction connections200pgsql.connections[idle_in_transaction]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle in transaction (aborted)200pgsql.connections[idle_in_transaction_aborted]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of fastpath function call200pgsql.connections[fastpath_function_call]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of disabled200pgsql.connections[disabled]736506000000100App-PostgresPro-Linux
- PostgreSQL: count of autovacuum workers200pgsql.autovacumm.count[]7365030000000100App-PostgresPro-Linux
- Block devices: read requests200system.disk.all_read[]736506000000100App-PostgresPro-Linux
- Block devices: write requests200system.disk.all_write[]736506000000100App-PostgresPro-Linux
- Block devices: read byte/s200system.disk.all_read_b[]736506000000100App-PostgresPro-Linux
- Block devices: write byte/s200system.disk.all_write_b[]736506000000100App-PostgresPro-Linux
- Mamonsu: plugin errors200mamonsu.plugin.errors[]736506040000100App-PostgresPro-Linux
- Mamonsu: plugin keep alive200mamonsu.plugin.keepalive[]736506000000100App-PostgresPro-Linux
- Mamonsu: rss memory max usage200mamonsu.memory.rss[max]73650600b0000100App-PostgresPro-Linux
- PostgreSQL transactions: total200pgsql.transactions[total]736506000000100App-PostgresPro-Linux
- PostgreSQL blocks: hit200pgsql.blocks[hit]736506000000100App-PostgresPro-Linux
- PostgreSQL blocks: read200pgsql.blocks[read]736506000000100App-PostgresPro-Linux
- PostgreSQL event: conflicts200pgsql.events[conflicts]736506000000100App-PostgresPro-Linux
- PostgreSQL event: deadlocks200pgsql.events[deadlocks]736506000000100App-PostgresPro-Linux
- PostgreSQL event: rollbacks200pgsql.events[xact_rollback]736506000000100App-PostgresPro-Linux
- PostgreSQL temp: bytes written200pgsql.temp[bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL temp: files created200pgsql.temp[files]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: deleted200pgsql.tuples[deleted]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: fetched200pgsql.tuples[fetched]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: inserted200pgsql.tuples[inserted]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: returned200pgsql.tuples[returned]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: updated200pgsql.tuples[updated]736506000000100App-PostgresPro-Linux
- PostgreSQL event: checksum_failures200pgsql.events[checksum_failures]736506000000100App-PostgresPro-Linux
- System load average over 1 minute200system.la[1]736506000000100App-PostgresPro-Linux
- Apps: User-space applications200system.memory[apps]73650603b0000100App-PostgresPro-Linux
- Buffers: Block device cache and dirty200system.memory[buffers]73650603b0000100App-PostgresPro-Linux
- Swap: Swap space used200system.memory[swap]73650603b0000100App-PostgresPro-Linux
- Cached: Parked file data (file content) cache200system.memory[cached]73650603b0000100App-PostgresPro-Linux
- Free: Wasted memory200system.memory[unused]73650603b0000100App-PostgresPro-Linux
- Slab: Kernel used memory (inode cache)200system.memory[slab]73650603b0000100App-PostgresPro-Linux
- SwapCached: Fetched unmod yet swap pages200system.memory[swap_cache]73650603b0000100App-PostgresPro-Linux
- PageTables: Map bt virtual and physical200system.memory[page_tables]73650603b0000100App-PostgresPro-Linux
- VMallocUsed: vmaloc() allocated by kernel200system.memory[vmalloc_used]73650603b0000100App-PostgresPro-Linux
- Committed_AS: Total committed memory200system.memory[committed]73650603b0000100App-PostgresPro-Linux
- Mapped: All mmap()ed pages200system.memory[mapped]73650603b0000100App-PostgresPro-Linux
- Active: Memory recently used200system.memory[active]73650603b0000100App-PostgresPro-Linux
- Inactive: Memory not currently used200system.memory[inactive]73650603b0000100App-PostgresPro-Linux
- PostgreSQL: age of oldest xid200pgsql.oldest[xid_age]736506030000100App-PostgresPro-Linux
- PostgreSQL: oldest transaction running time in sec200pgsql.oldest[transaction_time]73650600s0000100App-PostgresPro-Linux
- Opened files200system.open_files[]736506030000100App-PostgresPro-Linux
- PostgreSQL: shared buffer size200pgsql.buffers[size]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: shared buffer twice used size200pgsql.buffers[twice_used]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: shared buffer dirty size200pgsql.buffers[dirty]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: ping200pgsql.ping[]73650600ms0000100App-PostgresPro-Linux
- PostgreSQL: cache hit ratio200pgsql.cache[hit]73650603%0000100App-PostgresPro-Linux
- PostgreSQL: service uptime200pgsql.uptime[]73650603uptime0000100App-PostgresPro-Linux
- PostgreSQL locks: Read only queries200pgsql.pg_locks[accessshare]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: SELECT FOR SHARE and SELECT FOR UPDATE200pgsql.pg_locks[rowshare]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Write queries200pgsql.pg_locks[rowexclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY200pgsql.pg_locks[shareupdateexclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: CREATE INDEX200pgsql.pg_locks[share]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Locks from application200pgsql.pg_locks[sharerowexclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Locks from application or some operation on system catalogs200pgsql.pg_locks[exclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE200pgsql.pg_locks[accessexclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL statements: read bytes/s200pgsql.stat[read_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL statements: write bytes/s200pgsql.stat[write_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL statements: dirty bytes/s200pgsql.stat[dirty_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL statements: read io time200pgsql.stat[read_time]73650600s0000100App-PostgresPro-Linux
- PostgreSQL statements: write io time200pgsql.stat[write_time]73650600s0000100App-PostgresPro-Linux
- PostgreSQL statements: other (mostly cpu) time200pgsql.stat[other_time]73650600s0000100App-PostgresPro-Linux
- PostgreSQL waits: Lightweight locks200pgsql.all_lock[lwlock]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Heavyweight locks200pgsql.all_lock[hwlock]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Buffer locks200pgsql.all_lock[buffer]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: XID access200pgsql.lwlock[xid]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: WAL access200pgsql.lwlock[wal]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: CLOG access200pgsql.lwlock[clog]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Replication Locks200pgsql.lwlock[replication]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Buffer operations200pgsql.lwlock[buffer]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Other operations200pgsql.lwlock[other]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: lock on a relation200pgsql.hwlock[relation]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: extend a relation200pgsql.hwlock[extend]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: lock on page200pgsql.hwlock[page]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: lock on a tuple200pgsql.hwlock[tuple]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: transaction to finish200pgsql.hwlock[transactionid]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: virtual xid lock200pgsql.hwlock[virtualxid]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: speculative insertion lock200pgsql.hwlock[speculative_token]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: lock on database object200pgsql.hwlock[object]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: userlock200pgsql.hwlock[userlock]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: advisory user lock200pgsql.hwlock[advisory]736506000000100App-PostgresPro-Linux
- Processes: in state running200system.processes[running]736506000000100App-PostgresPro-Linux
- Processes: in state blocked200system.processes[blocked]736506000000100App-PostgresPro-Linux
- Processes: forkrate200system.processes[forkrate]736506000000100App-PostgresPro-Linux
- CPU time spent by normal programs and daemons200system.cpu[user]736506000000100App-PostgresPro-Linux
- CPU time spent by nice(1)d programs200system.cpu[nice]736506000000100App-PostgresPro-Linux
- CPU time spent by the kernel in system activities200system.cpu[system]736506000000100App-PostgresPro-Linux
- CPU time spent Idle CPU time200system.cpu[idle]736506000000100App-PostgresPro-Linux
- CPU time spent waiting for I/O operations200system.cpu[iowait]736506000000100App-PostgresPro-Linux
- CPU time spent handling interrupts200system.cpu[irq]736506000000100App-PostgresPro-Linux
- CPU time spent handling batched interrupts200system.cpu[softirq]736506000000100App-PostgresPro-Linux
- System up_time200system.up_time[]73650603uptime0000100App-PostgresPro-Linux
- PostgreSQL: wal write speed200pgsql.wal.write[]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: streaming replication lag200pgsql.replication_lag[sec]736506000000100App-PostgresPro-Linux
- PostgreSQL: count of xlog files200pgsql.wal.count[]736506000000100App-PostgresPro-Linux
- Compressed relations discovery260000007pgsql.cfs.discovery_compressed_relations[]{#COMPRESSED_RELATION}.*A0Relation {#COMPRESSED_RELATION}: compress ratio200pgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]7365060000000100App-PostgresPro-LinuxRelation {#COMPRESSED_RELATION}: compress ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]
Database discovery260000007pgsql.database.discovery[]{#DATABASE}.*A0Database {#DATABASE}: size200pgsql.database.size[{#DATABASE}]736503003b0000100App-PostgresPro-LinuxMax age (datfrozenxid) in: {#DATABASE}200pgsql.database.max_age[{#DATABASE}]7365030000000100App-PostgresPro-LinuxCount of bloating tables in database: {#DATABASE}200pgsql.database.bloating_tables[{#DATABASE}]7365030000000100App-PostgresPro-LinuxDatabase: {#DATABASE} size9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.database.size[{#DATABASE}]
Database bloating overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.database.bloating_tables[{#DATABASE}]
1000CC00120- PostgresPro-Linuxpgsql.autovacumm.count[]
Database max age overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.database.max_age[{#DATABASE}]
1000CC00120- PostgresPro-Linuxpgsql.autovacumm.count[]
VFS discovery260000007system.vfs.discovery[]{#MOUNTPOINT}.*A0Mount point {#MOUNTPOINT}: used200system.vfs.used[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free200system.vfs.free[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free in percents200system.vfs.percent_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free inodes in percent200system.vfs.percent_inode_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-Linux{PostgresPro-Linux:system.vfs.percent_free[{#MOUNTPOINT}].last()}<10Free disk space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030{PostgresPro-Linux:system.vfs.percent_inode_free[{#MOUNTPOINT}].last()}<10Free inode space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030Mount point overview: {#MOUNTPOINT}9002000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxsystem.vfs.used[{#MOUNTPOINT}]
100000CC020- PostgresPro-Linuxsystem.vfs.free[{#MOUNTPOINT}]
Block device discovery260000007system.disk.discovery[]{#BLOCKDEVICE}.*A0Block device {#BLOCKDEVICE}: utilization200system.disk.utilization[{#BLOCKDEVICE}]73650600%0000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: read operations200system.disk.read[{#BLOCKDEVICE}]736506000000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: write operations200system.disk.write[{#BLOCKDEVICE}]736506000000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: read byte/s200system.disk.read_b[{#BLOCKDEVICE}]73650600b0000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: write byte/s200system.disk.write_b[{#BLOCKDEVICE}]73650600b0000100App-PostgresPro-LinuxBlock device overview: {#BLOCKDEVICE} operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.read[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linuxsystem.disk.write[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Block device overview: {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.read_b[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linuxsystem.disk.write_b[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Net iface discovery260000007system.net.discovery[]{#NETDEVICE}.*A0Network device {#NETDEVICE}: RX bytes/s200system.net.rx_bytes[{#NETDEVICE}]73650600b0000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: RX errors/s200system.net.rx_errs[{#NETDEVICE}]736506000000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: RX drops/s200system.net.rx_drop[{#NETDEVICE}]736506000000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX bytes/s200system.net.tx_bytes[{#NETDEVICE}]73650600b0000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX errors/s200system.net.tx_errs[{#NETDEVICE}]736506000000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX drops/s200system.net.tx_drop[{#NETDEVICE}]736506000000100App-PostgresPro-LinuxNetwork device: {#NETDEVICE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.net.rx_bytes[{#NETDEVICE}]
100000CC020- PostgresPro-Linuxsystem.net.tx_bytes[{#NETDEVICE}]
-
-
-
- {PostgresPro-Linux:pgsql.archive_command[count_files_to_archive].last()}>2PostgreSQL count files in ./archive_status on {HOSTNAME} more than 2030{PostgresPro-Linux:pgsql.checkpoint[count_wal].last()}>12PostgreSQL required checkpoints occurs to frequently on {HOSTNAME}030 {PostgresPro-Linux:pgsql.connections[total].last()}/{PostgresPro-Linux:pgsql.connections[max_connections].last()}*100 >90PostgreSQL many connections on {HOSTNAME} (total connections more than 90% max connections)030{PostgresPro-Linux:mamonsu.plugin.errors[].strlen()}>1Mamonsu plugin errors on {HOSTNAME}. {ITEM.LASTVALUE}030{PostgresPro-Linux:mamonsu.plugin.keepalive[].nodata(180)}=1Mamonsu nodata from {HOSTNAME}030{PostgresPro-Linux:mamonsu.memory.rss[max].last()}>41943040Mamonsu agent memory usage alert on {HOSTNAME}: {ITEM.LASTVALUE} bytes030{PostgresPro-Linux:pgsql.oldest[xid_age].last()}>18000000PostgreSQL oldest xid is too big on {HOSTNAME}030{PostgresPro-Linux:pgsql.oldest[transaction_time].last()}>18000PostgreSQL query running is too old on {HOSTNAME}030{PostgresPro-Linux:pgsql.uptime[].last()}<600PostgreSQL service was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.cache[hit].last()}<80PostgreSQL cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.ping[].nodata(180)}=1PostgreSQL no ping from PostgreSQL for 3 minutes {HOSTNAME} 030{PostgresPro-Linux:system.processes[forkrate].min(5m)}>500Process fork-rate to frequently on {HOSTNAME}030{PostgresPro-Linux:system.up_time[].last()}<300System was restarted on {HOSTNAME} (up_time={ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.replication_lag[sec].last()}>300PostgreSQL streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})030
- PostgreSQL archive command archive_status 9002000.0100.0110100.00.0000000FF0000020- PostgresPro-Linuxpgsql.archive_command[count_files_to_archive]
1000FF00120- PostgresPro-Linuxpgsql.archive_command[size_files_to_archive]
PostgreSQL archive command trying_to_archive 9002000.0100.0110100.00.000000000F000020- PostgresPro-Linuxpgsql.archive_command[archived_files]
10FF0000120- PostgresPro-Linuxpgsql.archive_command[failed_trying_to_archive]
PostgreSQL bgwriter9002000.0100.0110100.00.0000000CCCC00120- PostgresPro-Linuxpgsql.bgwriter[buffers_checkpoint]
100000CC120- PostgresPro-Linuxpgsql.bgwriter[buffers_clean]
20777777020- PostgresPro-Linuxpgsql.bgwriter[maxwritten_clean]
30CC0000120- PostgresPro-Linuxpgsql.bgwriter[buffers_backend]
40CC00CC020- PostgresPro-Linuxpgsql.bgwriter[buffers_backend_fsync]
5000CC00120- PostgresPro-Linuxpgsql.bgwriter[buffers_alloc]
PostgreSQL cfs compression: current ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.activity[current_compress_ratio]
PostgreSQL cfs compression: compressed files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.activity[compressed_files]
PostgreSQL cfs compression: written bytes9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.activity[written_bytes]
PostgreSQL cfs compression: total ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.activity[total_compress_ratio]
PostgreSQL checkpoints9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.checkpoint[count_timed]
10CC0000020- PostgresPro-Linuxpgsql.checkpoint[count_wal]
200000CC120- PostgresPro-Linuxpgsql.checkpoint[write_time]
30000000120- PostgresPro-Linuxpgsql.checkpoint[checkpoint_sync_time]
PostgreSQL connections9002000.0100.0110100.00.000000000BB00020- PostgresPro-Linuxpgsql.connections[active]
100000BB020- PostgresPro-Linuxpgsql.connections[idle]
20CC00CC020- PostgresPro-Linuxpgsql.connections[idle_in_transaction]
30CCCCCC020- PostgresPro-Linuxpgsql.connections[idle_in_transaction_aborted]
40CCCC00020- PostgresPro-Linuxpgsql.connections[fastpath_function_call]
5000CCCC020- PostgresPro-Linuxpgsql.connections[disabled]
60EEEEEE020- PostgresPro-Linuxpgsql.connections[total]
70BB0000020- PostgresPro-Linuxpgsql.connections[waiting]
8000BB00020- PostgresPro-Linuxpgsql.connections[max_connections]
Block devices: read/write operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.all_read[]
100000CC020- PostgresPro-Linuxsystem.disk.all_write[]
Block devices: read/write bytes9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.all_read_b[]
100000CC020- PostgresPro-Linuxsystem.disk.all_write_b[]
PostgreSQL instance: rate9002000.0100.0110100.00.00000000000CC120- PostgresPro-Linuxpgsql.transactions[total]
1000CC00020- PostgresPro-Linuxpgsql.blocks[hit]
20CC0000020- PostgresPro-Linuxpgsql.blocks[read]
PostgreSQL instance: events9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.events[conflicts]
10000000020- PostgresPro-Linuxpgsql.events[deadlocks]
20CC0000020- PostgresPro-Linuxpgsql.events[xact_rollback]
3000FF00020- PostgresPro-Linuxpgsql.events[checksum_failures]
PostgreSQL instance: temp files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.temp[bytes]
100000CC120- PostgresPro-Linuxpgsql.temp[files]
PostgreSQL instance: tuples9002000.0100.0110100.00.0000000000000020- PostgresPro-Linuxpgsql.tuples[deleted]
100000CC020- PostgresPro-Linuxpgsql.tuples[fetched]
2000CC00020- PostgresPro-Linuxpgsql.tuples[inserted]
30CC00CC120- PostgresPro-Linuxpgsql.tuples[returned]
40CC0000020- PostgresPro-Linuxpgsql.tuples[updated]
System load average9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.la[1]
Memory overview9004000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxsystem.memory[apps]
1000CC00020- PostgresPro-Linuxsystem.memory[buffers]
200000CC020- PostgresPro-Linuxsystem.memory[swap]
30CC00CC020- PostgresPro-Linuxsystem.memory[cached]
40000000020- PostgresPro-Linuxsystem.memory[unused]
50CCCC00020- PostgresPro-Linuxsystem.memory[slab]
60777777020- PostgresPro-Linuxsystem.memory[swap_cache]
70770000020- PostgresPro-Linuxsystem.memory[page_tables]
80000077020- PostgresPro-Linuxsystem.memory[vmalloc_used]
90007700020- PostgresPro-Linuxsystem.memory[committed]
100DF0000020- PostgresPro-Linuxsystem.memory[mapped]
11000DF00020- PostgresPro-Linuxsystem.memory[active]
1200000DF020- PostgresPro-Linuxsystem.memory[inactive]
PostgreSQL oldest transaction running time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.oldest[transaction_time]
PostgreSQL age of oldest xid9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.oldest[xid_age]
System: count of opened files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.open_files[]
PostgreSQL: shared buffer9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.buffers[size]
10CC0000020- PostgresPro-Linuxpgsql.buffers[twice_used]
2000CC00020- PostgresPro-Linuxpgsql.buffers[dirty]
PostgreSQL uptime9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cache[hit]
10DF0101120- PostgresPro-Linuxpgsql.uptime[]
PostgreSQL locks sampling9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.pg_locks[accessshare]
1000CC00020- PostgresPro-Linuxpgsql.pg_locks[rowshare]
20CC0000020- PostgresPro-Linuxpgsql.pg_locks[rowexclusive]
30CC00CC020- PostgresPro-Linuxpgsql.pg_locks[shareupdateexclusive]
40777777020- PostgresPro-Linuxpgsql.pg_locks[share]
50CCCCCC020- PostgresPro-Linuxpgsql.pg_locks[sharerowexclusive]
60CCCC00020- PostgresPro-Linuxpgsql.pg_locks[exclusive]
7000CCCC020- PostgresPro-Linuxpgsql.pg_locks[accessexclusive]
PostgreSQL statements: bytes9002000.0100.0110100.00.0000000BBBB00020- PostgresPro-Linuxpgsql.stat[read_bytes]
1000CC00020- PostgresPro-Linuxpgsql.stat[write_bytes]
200000CC020- PostgresPro-Linuxpgsql.stat[dirty_bytes]
PostgreSQL statements: spend time9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.stat[read_time]
100000CC020- PostgresPro-Linuxpgsql.stat[write_time]
20BBBB00020- PostgresPro-Linuxpgsql.stat[other_time]
PostgreSQL waits: Locks by type9002000.0100.0111100.00.00000000000CC020- PostgresPro-Linuxpgsql.all_lock[lwlock]
1000CC00020- PostgresPro-Linuxpgsql.all_lock[hwlock]
20CC0000020- PostgresPro-Linuxpgsql.all_lock[buffer]
PostgreSQL waits: Heavyweight locks9002000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxpgsql.hwlock[relation]
1000CC00020- PostgresPro-Linuxpgsql.hwlock[extend]
200000CC020- PostgresPro-Linuxpgsql.hwlock[page]
30CC00CC020- PostgresPro-Linuxpgsql.hwlock[tuple]
40000000020- PostgresPro-Linuxpgsql.hwlock[transactionid]
50CCCC00020- PostgresPro-Linuxpgsql.hwlock[virtualxid]
60777777020- PostgresPro-Linuxpgsql.hwlock[speculative_token]
70770000020- PostgresPro-Linuxpgsql.hwlock[object]
80000077020- PostgresPro-Linuxpgsql.hwlock[userlock]
90007700020- PostgresPro-Linuxpgsql.hwlock[advisory]
PostgreSQL waits: Lightweight locks9002000.0100.0111100.00.0000000BBBB00020- PostgresPro-Linuxpgsql.lwlock[xid]
10CC0000020- PostgresPro-Linuxpgsql.lwlock[wal]
2000CC00020- PostgresPro-Linuxpgsql.lwlock[clog]
30FFFFCC020- PostgresPro-Linuxpgsql.lwlock[replication]
400000CC020- PostgresPro-Linuxpgsql.lwlock[buffer]
50007700020- PostgresPro-Linuxpgsql.lwlock[other]
Processes overview9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.processes[running]
1000CC00020- PostgresPro-Linuxsystem.processes[blocked]
200000CC120- PostgresPro-Linuxsystem.processes[forkrate]
CPU time spent9002000.0100.0111100.00.00000000000CC020- PostgresPro-Linuxsystem.cpu[user]
10CC00CC020- PostgresPro-Linuxsystem.cpu[nice]
20CC0000020- PostgresPro-Linuxsystem.cpu[system]
3000CC00020- PostgresPro-Linuxsystem.cpu[idle]
40CCCC00020- PostgresPro-Linuxsystem.cpu[iowait]
50777777020- PostgresPro-Linuxsystem.cpu[irq]
60000077020- PostgresPro-Linuxsystem.cpu[softirq]
System up_time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.up_time[]
PostgreSQL write-ahead log generation speed9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.wal.write[]
PostgreSQL replication lag in second9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.replication_lag[sec]
PostgreSQL count of xlog files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.wal.count[]
-
\ No newline at end of file
diff --git a/packaging/conf/old_templates/template_2.4.4-2.4.5_agent.xml b/packaging/conf/old_templates/template_2.4.4-2.4.5_agent.xml
deleted file mode 100644
index 8b879fef..00000000
--- a/packaging/conf/old_templates/template_2.4.4-2.4.5_agent.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-2.0
-
-
- Templates
-
-
-
-
- PostgresPro-Linux
- PostgresPro-Linux
-
-
- Templates
-
-
-
-
- App-PostgresPro-Linux
-
-
- - PostgreSQL archive command count files in archive_status need to archive000pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command size of files need to archive000pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command count archived files000pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL archive command count attempts to archive files000pgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written during checkpoints000pgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written000pgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: number of bgwriter stopped by max write count000pgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written directly by a backend000pgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: times a backend execute its own fsync000pgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers allocated000pgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL checkpoints: by timeout (in hour)000pgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]7365030001000100App-PostgresPro-Linux
- PostgreSQL checkpoints: by wal (in hour)000pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]7365030001000100App-PostgresPro-Linux
- PostgreSQL checkpoint: write time000pgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100App-PostgresPro-Linux
- PostgreSQL checkpoint: sync time000pgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100App-PostgresPro-Linux
- PostgreSQL: number of total connections000pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of waiting connections000pgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: max connections000pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of active connections000pgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle connections000pgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle in transaction connections000pgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle in transaction (aborted)000pgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of fastpath function call000pgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of disabled000pgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: count of autovacuum workers000pgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-Linux
- Block devices: read requests000system.disk.all_read736506001000100App-PostgresPro-Linux
- Block devices: write requests000system.disk.all_write736506001000100App-PostgresPro-Linux
- Block devices: read byte/s000system.disk.all_read_b736506001000100App-PostgresPro-Linux
- Block devices: write byte/s000system.disk.all_write_b736506001000100App-PostgresPro-Linux
- Mamonsu: plugin keep alive000mamonsu.plugin.keepalive736506000000100App-PostgresPro-Linux
- PostgreSQL transactions: total000pgsql.transactions.total[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL blocks: hit000pgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL blocks: read000pgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL event: conflicts000pgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- PostgreSQL event: deadlocks000pgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- PostgreSQL event: rollbacks000pgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- PostgreSQL temp: bytes written000pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b2000100App-PostgresPro-Linux
- PostgreSQL temp: files created000pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- PostgreSQL tuples: deleted000pgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL tuples: fetched000pgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL tuples: inserted000pgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL tuples: returned000pgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL tuples: updated000pgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL event: checksum_failures000pgsql.events.checksum_failures[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- System load average over 1 minute000system.la.1736506000000100App-PostgresPro-Linux
- Apps: User-space applications000system.memory.apps73650603b0000100App-PostgresPro-Linux
- Buffers: Block device cache and dirty000system.memory.buffers73650603b0000100App-PostgresPro-Linux
- Swap: Swap space used000system.memory.swap73650603b0000100App-PostgresPro-Linux
- Cached: Parked file data (file content) cache000system.memory.cached73650603b0000100App-PostgresPro-Linux
- Free: Wasted memory000system.memory.unused73650603b0000100App-PostgresPro-Linux
- Slab: Kernel used memory (inode cache)000system.memory.slab73650603b0000100App-PostgresPro-Linux
- SwapCached: Fetched unmod yet swap pages000system.memory.swap_cache73650603b0000100App-PostgresPro-Linux
- PageTables: Map bt virtual and physical000system.memory.page_tables73650603b0000100App-PostgresPro-Linux
- VMallocUsed: vmaloc() allocated by kernel000system.memory.vmalloc_used73650603b0000100App-PostgresPro-Linux
- Committed_AS: Total committed memory000system.memory.committed73650603b0000100App-PostgresPro-Linux
- Mapped: All mmap()ed pages000system.memory.mapped73650603b0000100App-PostgresPro-Linux
- Active: Memory recently used000system.memory.active73650603b0000100App-PostgresPro-Linux
- Inactive: Memory not currently used000system.memory.inactive73650603b0000100App-PostgresPro-Linux
- PostgreSQL: age of oldest xid000pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL: oldest transaction running time in sec000pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}]73650600s0000100App-PostgresPro-Linux
- Opened files000system.open_files736506030000100App-PostgresPro-Linux
- PostgreSQL: shared buffer size000pgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: shared buffer twice used size000pgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: shared buffer dirty size000pgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: ping000pgsql.ping[{$PG_CONNINFO},{$PG_PATH}]7365050ms0000100App-PostgresPro-Linux
- PostgreSQL: cache hit ratio000pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]73650600%0000100App-PostgresPro-Linux
- PostgreSQL: service uptime000pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]73650600uptime0000100App-PostgresPro-Linux
- PostgreSQL locks: Read only queries000pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: SELECT FOR SHARE and SELECT FOR UPDATE000pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Write queries000pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY000pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: CREATE INDEX000pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Locks from application000pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Locks from application or some operation on system catalogs000pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE000pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL statements: read bytes/s000pgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux
- PostgreSQL statements: write bytes/s000pgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux
- PostgreSQL statements: dirty bytes/s000pgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux
- PostgreSQL statements: read io time000pgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux
- PostgreSQL statements: write io time000pgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux
- PostgreSQL statements: other (mostly cpu) time000pgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux
- Processes: in state running000system.processes.running736506000000100App-PostgresPro-Linux
- Processes: in state blocked000system.processes.blocked736506000000100App-PostgresPro-Linux
- Processes: forkrate000system.processes.forkrate736506001000100App-PostgresPro-Linux
- CPU time spent by normal programs and daemons000system.cpu.user736506001000100App-PostgresPro-Linux
- CPU time spent by nice(1)d programs000system.cpu.nice736506001000100App-PostgresPro-Linux
- CPU time spent by the kernel in system activities000system.cpu.system736506001000100App-PostgresPro-Linux
- CPU time spent Idle CPU time000system.cpu.idle736506001000100App-PostgresPro-Linux
- CPU time spent waiting for I/O operations000system.cpu.iowait736506001000100App-PostgresPro-Linux
- CPU time spent handling interrupts000system.cpu.irq736506001000100App-PostgresPro-Linux
- CPU time spent handling batched interrupts000system.cpu.softirq736506001000100App-PostgresPro-Linux
- System up_time000system.up_time73650603uptime0000100App-PostgresPro-Linux
- PostgreSQL: wal write speed000pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux
- PostgreSQL: streaming replication lag000pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: count of xlog files000pgsql.wal.count[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- Database discovery060000007pgsql.database.discovery[{$PG_CONNINFO},{$PG_PATH}]{#DATABASE}.*A0Database {#DATABASE}: size000pgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]736503003b0000100App-PostgresPro-LinuxMax age (datfrozenxid) in: {#DATABASE}000pgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-LinuxCount of bloating tables in database: {#DATABASE}000pgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-LinuxDatabase: {#DATABASE} size9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
Database bloating overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
1000CC00120- PostgresPro-Linuxpgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
Database max age overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
1000CC00120- PostgresPro-Linuxpgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
VFS discovery060000007system.vfs.discovery{#MOUNTPOINT}.*A0Mount point {#MOUNTPOINT}: used000system.vfs.used[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free000system.vfs.free[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free in percents000system.vfs.percent_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-Linux{PostgresPro-Linux:system.vfs.percent_free[{#MOUNTPOINT}].last()}<10Free disk space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030Mount point overview: {#MOUNTPOINT}9002000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxsystem.vfs.used[{#MOUNTPOINT}]
100000CC020- PostgresPro-Linuxsystem.vfs.free[{#MOUNTPOINT}]
Block device discovery060000007system.disk.discovery{#BLOCKDEVICE}.*A0Block device {#BLOCKDEVICE}: utilization000system.disk.utilization[{#BLOCKDEVICE}]73650600%1000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: read operations000system.disk.read[{#BLOCKDEVICE}]736506001000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: write operations000system.disk.write[{#BLOCKDEVICE}]736506001000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: read byte/s000system.disk.read_b[{#BLOCKDEVICE}]73650600b1000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: write byte/s000system.disk.write_b[{#BLOCKDEVICE}]73650600b1000100App-PostgresPro-LinuxBlock device overview: {#BLOCKDEVICE} operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.read[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linuxsystem.disk.write[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Block device overview: {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.read_b[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linuxsystem.disk.write_b[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Net iface discovery060000007system.net.discovery{#NETDEVICE}.*A0Network device {#NETDEVICE}: RX bytes/s000system.net.rx_bytes[{#NETDEVICE}]73650600b1000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: RX errors/s000system.net.rx_errs[{#NETDEVICE}]736506001000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: RX drops/s000system.net.rx_drop[{#NETDEVICE}]736506001000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX bytes/s000system.net.tx_bytes[{#NETDEVICE}]73650600b1000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX errors/s000system.net.tx_errs[{#NETDEVICE}]736506001000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX drops/s000system.net.tx_drop[{#NETDEVICE}]736506001000100App-PostgresPro-LinuxNetwork device: {#NETDEVICE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.net.rx_bytes[{#NETDEVICE}]
100000CC020- PostgresPro-Linuxsystem.net.tx_bytes[{#NETDEVICE}]
- {$PG_CONNINFO}-qAt -p 5433 -U postgres {$PG_PATH}/opt/pgpro/std-10/bin/psql
-
-
- {PostgresPro-Linux:pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}].last()}>2PostgreSQL count files in ./archive_status on {HOSTNAME} more than 2030{PostgresPro-Linux:pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}].last()}>12PostgreSQL required checkpoints occurs to frequently on {HOSTNAME}030 {PostgresPro-Linux:pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}].last()}/{PostgresPro-Linux:pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}].last()}*100 >90PostgreSQL many connections on {HOSTNAME} (total connections more than 90% max connections)030{PostgresPro-Linux:mamonsu.plugin.keepalive.nodata(180)}=1Mamonsu nodata from {HOSTNAME}030{PostgresPro-Linux:pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}].last()}>18000000PostgreSQL oldest xid is too big on {HOSTNAME}030{PostgresPro-Linux:pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}].last()}>18000PostgreSQL query running is too old on {HOSTNAME}030{PostgresPro-Linux:pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}].last()}<600PostgreSQL service was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}].last()}<80PostgreSQL cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.ping[{$PG_CONNINFO},{$PG_PATH}].nodata(180)}=1PostgreSQL no ping from PostgreSQL for 3 minutes {HOSTNAME} 030{PostgresPro-Linux:system.processes.forkrate.min(5m)}>500Process fork-rate to frequently on {HOSTNAME}030{PostgresPro-Linux:system.up_time.last()}<300System was restarted on {HOSTNAME} (up_time={ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}].last()}>300PostgreSQL streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})030
- PostgreSQL archive command archive_status 9002000.0100.0110100.00.0000000FF0000020- PostgresPro-Linuxpgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]
1000FF00120- PostgresPro-Linuxpgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL archive command trying_to_archive 9002000.0100.0110100.00.000000000F000020- PostgresPro-Linuxpgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]
10FF0000120- PostgresPro-Linuxpgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL bgwriter9002000.0100.0110100.00.0000000CCCC00120- PostgresPro-Linuxpgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]
100000CC120- PostgresPro-Linuxpgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]
20777777020- PostgresPro-Linuxpgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]
30CC0000120- PostgresPro-Linuxpgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]
40CC00CC020- PostgresPro-Linuxpgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]
5000CC00120- PostgresPro-Linuxpgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL checkpoints9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]
10CC0000020- PostgresPro-Linuxpgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]
200000CC120- PostgresPro-Linuxpgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]
30000000120- PostgresPro-Linuxpgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL connections9002000.0100.0110100.00.000000000BB00020- PostgresPro-Linuxpgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]
100000BB020- PostgresPro-Linuxpgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]
20CC00CC020- PostgresPro-Linuxpgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]
30CCCCCC020- PostgresPro-Linuxpgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]
40CCCC00020- PostgresPro-Linuxpgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]
5000CCCC020- PostgresPro-Linuxpgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]
60EEEEEE020- PostgresPro-Linuxpgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]
70BB0000020- PostgresPro-Linuxpgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]
8000BB00020- PostgresPro-Linuxpgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]
Block devices: read/write operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.all_read
100000CC020- PostgresPro-Linuxsystem.disk.all_write
Block devices: read/write bytes9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.all_read_b
100000CC020- PostgresPro-Linuxsystem.disk.all_write_b
PostgreSQL instance: rate9002000.0100.0110100.00.00000000000CC120- PostgresPro-Linuxpgsql.transactions.total[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linuxpgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linuxpgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: events9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]
10000000020- PostgresPro-Linuxpgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linuxpgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]
3000FF00020- PostgresPro-Linuxpgsql.events.checksum_failures[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: temp files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]
100000CC120- PostgresPro-Linuxpgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: tuples9002000.0100.0110100.00.0000000000000020- PostgresPro-Linuxpgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]
100000CC020- PostgresPro-Linuxpgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]
2000CC00020- PostgresPro-Linuxpgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]
30CC00CC120- PostgresPro-Linuxpgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]
40CC0000020- PostgresPro-Linuxpgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]
System load average9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.la.1
Memory overview9004000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxsystem.memory.apps
1000CC00020- PostgresPro-Linuxsystem.memory.buffers
200000CC020- PostgresPro-Linuxsystem.memory.swap
30CC00CC020- PostgresPro-Linuxsystem.memory.cached
40000000020- PostgresPro-Linuxsystem.memory.unused
50CCCC00020- PostgresPro-Linuxsystem.memory.slab
60777777020- PostgresPro-Linuxsystem.memory.swap_cache
70770000020- PostgresPro-Linuxsystem.memory.page_tables
80000077020- PostgresPro-Linuxsystem.memory.vmalloc_used
90007700020- PostgresPro-Linuxsystem.memory.committed
100DF0000020- PostgresPro-Linuxsystem.memory.mapped
11000DF00020- PostgresPro-Linuxsystem.memory.active
1200000DF020- PostgresPro-Linuxsystem.memory.inactive
PostgreSQL oldest transaction running time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL age of oldest xid9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]
System: count of opened files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.open_files
PostgreSQL: shared buffer9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]
10CC0000020- PostgresPro-Linuxpgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]
2000CC00020- PostgresPro-Linuxpgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL uptime9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]
10DF0101120- PostgresPro-Linuxpgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL locks sampling9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linuxpgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linuxpgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]
30CC00CC020- PostgresPro-Linuxpgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]
40777777020- PostgresPro-Linuxpgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]
50CCCCCC020- PostgresPro-Linuxpgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]
60CCCC00020- PostgresPro-Linuxpgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]
7000CCCC020- PostgresPro-Linuxpgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL statements: bytes9002000.0100.0110100.00.0000000BBBB00020- PostgresPro-Linuxpgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linuxpgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]
200000CC020- PostgresPro-Linuxpgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL statements: spend time9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]
100000CC020- PostgresPro-Linuxpgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]
20BBBB00020- PostgresPro-Linuxpgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]
Processes overview9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.processes.running
1000CC00020- PostgresPro-Linuxsystem.processes.blocked
200000CC120- PostgresPro-Linuxsystem.processes.forkrate
CPU time spent9002000.0100.0111100.00.00000000000CC020- PostgresPro-Linuxsystem.cpu.user
10CC00CC020- PostgresPro-Linuxsystem.cpu.nice
20CC0000020- PostgresPro-Linuxsystem.cpu.system
3000CC00020- PostgresPro-Linuxsystem.cpu.idle
40CCCC00020- PostgresPro-Linuxsystem.cpu.iowait
50777777020- PostgresPro-Linuxsystem.cpu.irq
60000077020- PostgresPro-Linuxsystem.cpu.softirq
System up_time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.up_time
PostgreSQL write-ahead log generation speed9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL replication lag in second9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL count of xlog files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.wal.count[{$PG_CONNINFO},{$PG_PATH}]
-
\ No newline at end of file
diff --git a/packaging/conf/old_templates/template_2.6.2.xml b/packaging/conf/old_templates/template_2.6.2.xml
deleted file mode 100644
index c4fe01e3..00000000
--- a/packaging/conf/old_templates/template_2.6.2.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-2.0
-
-
- Templates
-
-
-
-
- PostgresPro-Linux
- PostgresPro-Linux
-
-
- Templates
-
-
-
-
- App-PostgresPro-Linux
-
-
- - PostgreSQL archive command count files in archive_status need to archive200pgsql.archive_command[count_files_to_archive]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command size of files need to archive200pgsql.archive_command[size_files_to_archive]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command count archived files200pgsql.archive_command[archived_files]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command count attempts to archive files200pgsql.archive_command[failed_trying_to_archive]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written during checkpoints200pgsql.bgwriter[buffers_checkpoint]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written200pgsql.bgwriter[buffers_clean]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: number of bgwriter stopped by max write count200pgsql.bgwriter[maxwritten_clean]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written directly by a backend200pgsql.bgwriter[buffers_backend]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: times a backend execute its own fsync200pgsql.bgwriter[buffers_backend_fsync]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers allocated200pgsql.bgwriter[buffers_alloc]736506030000100App-PostgresPro-Linux
- PostgreSQL cfs compression: written byte/s200pgsql.cfs.activity[written_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL cfs compression: scanned byte/s200pgsql.cfs.activity[scanned_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL cfs compression: compressed files200pgsql.cfs.activity[compressed_files]736506000000100App-PostgresPro-Linux
- PostgreSQL cfs compression: scanned files200pgsql.cfs.activity[scanned_files]736506000000100App-PostgresPro-Linux
- PostgreSQL cfs compression: current ratio200pgsql.cfs.activity[current_compress_ratio]736506000000100App-PostgresPro-Linux
- PostgreSQL cfs compression: total ratio200pgsql.cfs.activity[total_compress_ratio]736506000000100App-PostgresPro-Linux
- PostgreSQL checkpoints: by timeout (in hour)200pgsql.checkpoint[count_timed]7365030000000100App-PostgresPro-Linux
- PostgreSQL checkpoints: by wal (in hour)200pgsql.checkpoint[count_wal]7365030000000100App-PostgresPro-Linux
- PostgreSQL checkpoint: write time200pgsql.checkpoint[write_time]736503000ms0000100App-PostgresPro-Linux
- PostgreSQL checkpoint: sync time200pgsql.checkpoint[checkpoint_sync_time]736503000ms0000100App-PostgresPro-Linux
- PostgreSQL: number of total connections200pgsql.connections[total]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of waiting connections200pgsql.connections[waiting]736506000000100App-PostgresPro-Linux
- PostgreSQL: max connections200pgsql.connections[max_connections]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of active connections200pgsql.connections[active]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle connections200pgsql.connections[idle]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle in transaction connections200pgsql.connections[idle_in_transaction]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle in transaction (aborted)200pgsql.connections[idle_in_transaction_aborted]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of fastpath function call200pgsql.connections[fastpath_function_call]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of disabled200pgsql.connections[disabled]736506000000100App-PostgresPro-Linux
- PostgreSQL: count of autovacuum workers200pgsql.autovacumm.count[]7365030000000100App-PostgresPro-Linux
- Block devices: read requests200system.disk.all_read[]736506000000100App-PostgresPro-Linux
- Block devices: write requests200system.disk.all_write[]736506000000100App-PostgresPro-Linux
- Block devices: read byte/s200system.disk.all_read_b[]736506000000100App-PostgresPro-Linux
- Block devices: write byte/s200system.disk.all_write_b[]736506000000100App-PostgresPro-Linux
- Mamonsu: plugin errors200mamonsu.plugin.errors[]736506040000100App-PostgresPro-Linux
- Mamonsu: plugin keep alive200mamonsu.plugin.keepalive[]736506000000100App-PostgresPro-Linux
- Mamonsu: rss memory max usage200mamonsu.memory.rss[max]73650600b0000100App-PostgresPro-Linux
- PostgreSQL transactions: total200pgsql.transactions[total]736506000000100App-PostgresPro-Linux
- PostgreSQL blocks: hit200pgsql.blocks[hit]736506000000100App-PostgresPro-Linux
- PostgreSQL blocks: read200pgsql.blocks[read]736506000000100App-PostgresPro-Linux
- PostgreSQL event: conflicts200pgsql.events[conflicts]736506000000100App-PostgresPro-Linux
- PostgreSQL event: deadlocks200pgsql.events[deadlocks]736506000000100App-PostgresPro-Linux
- PostgreSQL event: rollbacks200pgsql.events[xact_rollback]736506000000100App-PostgresPro-Linux
- PostgreSQL temp: bytes written200pgsql.temp[bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL temp: files created200pgsql.temp[files]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: deleted200pgsql.tuples[deleted]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: fetched200pgsql.tuples[fetched]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: inserted200pgsql.tuples[inserted]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: returned200pgsql.tuples[returned]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: updated200pgsql.tuples[updated]736506000000100App-PostgresPro-Linux
- PostgreSQL event: checksum_failures200pgsql.events[checksum_failures]736506000000100App-PostgresPro-Linux
- System load average over 1 minute200system.la[1]736506000000100App-PostgresPro-Linux
- Apps: User-space applications200system.memory[apps]73650603b0000100App-PostgresPro-Linux
- Buffers: Block device cache and dirty200system.memory[buffers]73650603b0000100App-PostgresPro-Linux
- Swap: Swap space used200system.memory[swap]73650603b0000100App-PostgresPro-Linux
- Cached: Parked file data (file content) cache200system.memory[cached]73650603b0000100App-PostgresPro-Linux
- Free: Wasted memory200system.memory[unused]73650603b0000100App-PostgresPro-Linux
- Slab: Kernel used memory (inode cache)200system.memory[slab]73650603b0000100App-PostgresPro-Linux
- SwapCached: Fetched unmod yet swap pages200system.memory[swap_cache]73650603b0000100App-PostgresPro-Linux
- PageTables: Map bt virtual and physical200system.memory[page_tables]73650603b0000100App-PostgresPro-Linux
- VMallocUsed: vmaloc() allocated by kernel200system.memory[vmalloc_used]73650603b0000100App-PostgresPro-Linux
- Committed_AS: Total committed memory200system.memory[committed]73650603b0000100App-PostgresPro-Linux
- Mapped: All mmap()ed pages200system.memory[mapped]73650603b0000100App-PostgresPro-Linux
- Active: Memory recently used200system.memory[active]73650603b0000100App-PostgresPro-Linux
- Inactive: Memory not currently used200system.memory[inactive]73650603b0000100App-PostgresPro-Linux
- PostgreSQL: age of oldest xid200pgsql.oldest[xid_age]736506030000100App-PostgresPro-Linux
- PostgreSQL: oldest transaction running time in sec200pgsql.oldest[transaction_time]73650600s0000100App-PostgresPro-Linux
- Opened files200system.open_files[]736506030000100App-PostgresPro-Linux
- PostgreSQL: shared buffer size200pgsql.buffers[size]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: shared buffer twice used size200pgsql.buffers[twice_used]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: shared buffer dirty size200pgsql.buffers[dirty]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: ping200pgsql.ping[]73650600ms0000100App-PostgresPro-Linux
- PostgreSQL: cache hit ratio200pgsql.cache[hit]73650603%0000100App-PostgresPro-Linux
- PostgreSQL: service uptime200pgsql.uptime[]73650603uptime0000100App-PostgresPro-Linux
- PostgreSQL locks: Read only queries200pgsql.pg_locks[accessshare]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: SELECT FOR SHARE and SELECT FOR UPDATE200pgsql.pg_locks[rowshare]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Write queries200pgsql.pg_locks[rowexclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY200pgsql.pg_locks[shareupdateexclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: CREATE INDEX200pgsql.pg_locks[share]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Locks from application200pgsql.pg_locks[sharerowexclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Locks from application or some operation on system catalogs200pgsql.pg_locks[exclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE200pgsql.pg_locks[accessexclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL statements: read bytes/s200pgsql.stat[read_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL statements: write bytes/s200pgsql.stat[write_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL statements: dirty bytes/s200pgsql.stat[dirty_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL statements: read io time200pgsql.stat[read_time]73650600s0000100App-PostgresPro-Linux
- PostgreSQL statements: write io time200pgsql.stat[write_time]73650600s0000100App-PostgresPro-Linux
- PostgreSQL statements: other (mostly cpu) time200pgsql.stat[other_time]73650600s0000100App-PostgresPro-Linux
- PostgreSQL waits: Lightweight locks200pgsql.all_lock[lwlock]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Heavyweight locks200pgsql.all_lock[hwlock]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Buffer locks200pgsql.all_lock[buffer]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: XID access200pgsql.lwlock[xid]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: WAL access200pgsql.lwlock[wal]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: CLOG access200pgsql.lwlock[clog]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Replication Locks200pgsql.lwlock[replication]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Buffer operations200pgsql.lwlock[buffer]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Other operations200pgsql.lwlock[other]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: lock on a relation200pgsql.hwlock[relation]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: extend a relation200pgsql.hwlock[extend]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: lock on page200pgsql.hwlock[page]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: lock on a tuple200pgsql.hwlock[tuple]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: transaction to finish200pgsql.hwlock[transactionid]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: virtual xid lock200pgsql.hwlock[virtualxid]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: speculative insertion lock200pgsql.hwlock[speculative_token]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: lock on database object200pgsql.hwlock[object]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: userlock200pgsql.hwlock[userlock]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: advisory user lock200pgsql.hwlock[advisory]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of prepared transactions200pgsql.prepared.count736506000000100App-PostgresPro-Linux
- PostgreSQL: oldest prepared transaction running time in sec200pgsql.prepared.oldest73650600000100App-PostgresPro-Linux
- Processes: in state running200system.processes[running]736506000000100App-PostgresPro-Linux
- Processes: in state blocked200system.processes[blocked]736506000000100App-PostgresPro-Linux
- Processes: forkrate200system.processes[forkrate]736506000000100App-PostgresPro-Linux
- CPU time spent by normal programs and daemons200system.cpu[user]736506000000100App-PostgresPro-Linux
- CPU time spent by nice(1)d programs200system.cpu[nice]736506000000100App-PostgresPro-Linux
- CPU time spent by the kernel in system activities200system.cpu[system]736506000000100App-PostgresPro-Linux
- CPU time spent Idle CPU time200system.cpu[idle]736506000000100App-PostgresPro-Linux
- CPU time spent waiting for I/O operations200system.cpu[iowait]736506000000100App-PostgresPro-Linux
- CPU time spent handling interrupts200system.cpu[irq]736506000000100App-PostgresPro-Linux
- CPU time spent handling batched interrupts200system.cpu[softirq]736506000000100App-PostgresPro-Linux
- System up_time200system.up_time[]73650603uptime0000100App-PostgresPro-Linux
- PostgreSQL: wal write speed200pgsql.wal.write[]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: streaming replication lag200pgsql.replication_lag[sec]736506000000100App-PostgresPro-Linux
- PostgreSQL: count of xlog files200pgsql.wal.count[]736506000000100App-PostgresPro-Linux
- Compressed relations discovery260000007pgsql.cfs.discovery_compressed_relations[]{#COMPRESSED_RELATION}.*A0Relation {#COMPRESSED_RELATION}: compress ratio200pgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]7365060000000100App-PostgresPro-LinuxRelation {#COMPRESSED_RELATION}: compress ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]
Database discovery260000007pgsql.database.discovery[]{#DATABASE}.*A0Database {#DATABASE}: size200pgsql.database.size[{#DATABASE}]736503003b0000100App-PostgresPro-LinuxMax age (datfrozenxid) in: {#DATABASE}200pgsql.database.max_age[{#DATABASE}]7365030000000100App-PostgresPro-LinuxCount of bloating tables in database: {#DATABASE}200pgsql.database.bloating_tables[{#DATABASE}]7365030000000100App-PostgresPro-LinuxDatabase: {#DATABASE} size9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.database.size[{#DATABASE}]
Database bloating overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.database.bloating_tables[{#DATABASE}]
1000CC00120- PostgresPro-Linuxpgsql.autovacumm.count[]
Database max age overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.database.max_age[{#DATABASE}]
1000CC00120- PostgresPro-Linuxpgsql.autovacumm.count[]
VFS discovery260000007system.vfs.discovery[]{#MOUNTPOINT}.*A0Mount point {#MOUNTPOINT}: used200system.vfs.used[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free200system.vfs.free[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free in percents200system.vfs.percent_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free inodes in percent200system.vfs.percent_inode_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-Linux{PostgresPro-Linux:system.vfs.percent_free[{#MOUNTPOINT}].last()}<10Free disk space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030{PostgresPro-Linux:system.vfs.percent_inode_free[{#MOUNTPOINT}].last()}<10Free inode space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030Mount point overview: {#MOUNTPOINT}9002000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxsystem.vfs.used[{#MOUNTPOINT}]
100000CC020- PostgresPro-Linuxsystem.vfs.free[{#MOUNTPOINT}]
Block device discovery260000007system.disk.discovery[]{#BLOCKDEVICE}.*A0Block device {#BLOCKDEVICE}: utilization200system.disk.utilization[{#BLOCKDEVICE}]73650600%0000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: read operations200system.disk.read[{#BLOCKDEVICE}]736506000000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: write operations200system.disk.write[{#BLOCKDEVICE}]736506000000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: read byte/s200system.disk.read_b[{#BLOCKDEVICE}]73650600b0000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: write byte/s200system.disk.write_b[{#BLOCKDEVICE}]73650600b0000100App-PostgresPro-LinuxBlock device overview: {#BLOCKDEVICE} operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.read[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linuxsystem.disk.write[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Block device overview: {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.read_b[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linuxsystem.disk.write_b[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Net iface discovery260000007system.net.discovery[]{#NETDEVICE}.*A0Network device {#NETDEVICE}: RX bytes/s200system.net.rx_bytes[{#NETDEVICE}]73650600b0000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: RX errors/s200system.net.rx_errs[{#NETDEVICE}]736506000000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: RX drops/s200system.net.rx_drop[{#NETDEVICE}]736506000000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX bytes/s200system.net.tx_bytes[{#NETDEVICE}]73650600b0000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX errors/s200system.net.tx_errs[{#NETDEVICE}]736506000000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX drops/s200system.net.tx_drop[{#NETDEVICE}]736506000000100App-PostgresPro-LinuxNetwork device: {#NETDEVICE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.net.rx_bytes[{#NETDEVICE}]
100000CC020- PostgresPro-Linuxsystem.net.tx_bytes[{#NETDEVICE}]
Pg_probackup discovery260000007pg_probackup.discovery[]{#BACKUPDIR}.*A0Pg_probackup catalog {#BACKUPDIR}: size200pg_probackup.dir.size[{#BACKUPDIR}]7365053b0000100App-PostgresPro-LinuxPg_probackup catalog {#BACKUPDIR}: error200pg_probackup.dir.error[{#BACKUPDIR}]73650540000100App-PostgresPro-Linux{PostgresPro-Linux:pg_probackup.dir.error[{#BACKUPDIR}].strlen()}>1Error in backup dir {#BACKUPDIR} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030Pg_probackup: backup dir: {#BACKUPDIR} size9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpg_probackup.dir.size[{#BACKUPDIR}]
Relation size discovery260000007pgsql.relation.size[]{#RELATIONNAME}.*A0Relation size: {#RELATIONNAME}200pgsql.relation.size[{#RELATIONNAME}]7365063b0000100App-PostgresPro-LinuxPostgreSQL relation size: {#RELATIONNAME}9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.relation.size[{#RELATIONNAME}]
-
-
-
- {PostgresPro-Linux:pgsql.archive_command[count_files_to_archive].last()}>2PostgreSQL count files in ./archive_status on {HOSTNAME} more than 2030{PostgresPro-Linux:pgsql.checkpoint[count_wal].last()}>12PostgreSQL required checkpoints occurs to frequently on {HOSTNAME}030 {PostgresPro-Linux:pgsql.connections[total].last()}/{PostgresPro-Linux:pgsql.connections[max_connections].last()}*100 >90PostgreSQL many connections on {HOSTNAME} (total connections more than 90% max connections)030{PostgresPro-Linux:mamonsu.plugin.errors[].strlen()}>1Mamonsu plugin errors on {HOSTNAME}. {ITEM.LASTVALUE}030{PostgresPro-Linux:mamonsu.plugin.keepalive[].nodata(180)}=1Mamonsu nodata from {HOSTNAME}030{PostgresPro-Linux:mamonsu.memory.rss[max].last()}>41943040Mamonsu agent memory usage alert on {HOSTNAME}: {ITEM.LASTVALUE} bytes030{PostgresPro-Linux:pgsql.oldest[xid_age].last()}>18000000PostgreSQL oldest xid is too big on {HOSTNAME}030{PostgresPro-Linux:pgsql.oldest[transaction_time].last()}>18000PostgreSQL query running is too old on {HOSTNAME}030{PostgresPro-Linux:pgsql.uptime[].last()}<600PostgreSQL service was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.cache[hit].last()}<80PostgreSQL cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.ping[].nodata(180)}=1PostgreSQL no ping from PostgreSQL for 3 minutes {HOSTNAME} 030{PostgresPro-Linux:pgsql.prepared.oldest.last()}>3PostgreSQL prepared transaction running is too old on {HOSTNAME}030{PostgresPro-Linux:system.processes[forkrate].min(5m)}>500Process fork-rate to frequently on {HOSTNAME}030{PostgresPro-Linux:system.up_time[].last()}<300System was restarted on {HOSTNAME} (up_time={ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.replication_lag[sec].last()}>300PostgreSQL streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})030
- PostgreSQL archive command archive_status 9002000.0100.0110100.00.0000000FF0000020- PostgresPro-Linuxpgsql.archive_command[count_files_to_archive]
1000FF00120- PostgresPro-Linuxpgsql.archive_command[size_files_to_archive]
PostgreSQL archive command trying_to_archive 9002000.0100.0110100.00.000000000F000020- PostgresPro-Linuxpgsql.archive_command[archived_files]
10FF0000120- PostgresPro-Linuxpgsql.archive_command[failed_trying_to_archive]
PostgreSQL bgwriter9002000.0100.0110100.00.0000000CCCC00120- PostgresPro-Linuxpgsql.bgwriter[buffers_checkpoint]
100000CC120- PostgresPro-Linuxpgsql.bgwriter[buffers_clean]
20777777020- PostgresPro-Linuxpgsql.bgwriter[maxwritten_clean]
30CC0000120- PostgresPro-Linuxpgsql.bgwriter[buffers_backend]
40CC00CC020- PostgresPro-Linuxpgsql.bgwriter[buffers_backend_fsync]
5000CC00120- PostgresPro-Linuxpgsql.bgwriter[buffers_alloc]
PostgreSQL cfs compression: current ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.activity[current_compress_ratio]
PostgreSQL cfs compression: compressed files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.activity[compressed_files]
PostgreSQL cfs compression: written bytes9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.activity[written_bytes]
PostgreSQL cfs compression: total ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.activity[total_compress_ratio]
PostgreSQL checkpoints9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.checkpoint[count_timed]
10CC0000020- PostgresPro-Linuxpgsql.checkpoint[count_wal]
200000CC120- PostgresPro-Linuxpgsql.checkpoint[write_time]
30000000120- PostgresPro-Linuxpgsql.checkpoint[checkpoint_sync_time]
PostgreSQL connections9002000.0100.0110100.00.000000000BB00020- PostgresPro-Linuxpgsql.connections[active]
100000BB020- PostgresPro-Linuxpgsql.connections[idle]
20CC00CC020- PostgresPro-Linuxpgsql.connections[idle_in_transaction]
30CCCCCC020- PostgresPro-Linuxpgsql.connections[idle_in_transaction_aborted]
40CCCC00020- PostgresPro-Linuxpgsql.connections[fastpath_function_call]
5000CCCC020- PostgresPro-Linuxpgsql.connections[disabled]
60EEEEEE020- PostgresPro-Linuxpgsql.connections[total]
70BB0000020- PostgresPro-Linuxpgsql.connections[waiting]
8000BB00020- PostgresPro-Linuxpgsql.connections[max_connections]
Block devices: read/write operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.all_read[]
100000CC020- PostgresPro-Linuxsystem.disk.all_write[]
Block devices: read/write bytes9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.all_read_b[]
100000CC020- PostgresPro-Linuxsystem.disk.all_write_b[]
PostgreSQL instance: rate9002000.0100.0110100.00.00000000000CC120- PostgresPro-Linuxpgsql.transactions[total]
1000CC00020- PostgresPro-Linuxpgsql.blocks[hit]
20CC0000020- PostgresPro-Linuxpgsql.blocks[read]
PostgreSQL instance: events9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.events[conflicts]
10000000020- PostgresPro-Linuxpgsql.events[deadlocks]
20CC0000020- PostgresPro-Linuxpgsql.events[xact_rollback]
3000FF00020- PostgresPro-Linuxpgsql.events[checksum_failures]
PostgreSQL instance: temp files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.temp[bytes]
100000CC120- PostgresPro-Linuxpgsql.temp[files]
PostgreSQL instance: tuples9002000.0100.0110100.00.0000000000000020- PostgresPro-Linuxpgsql.tuples[deleted]
100000CC020- PostgresPro-Linuxpgsql.tuples[fetched]
2000CC00020- PostgresPro-Linuxpgsql.tuples[inserted]
30CC00CC120- PostgresPro-Linuxpgsql.tuples[returned]
40CC0000020- PostgresPro-Linuxpgsql.tuples[updated]
System load average9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.la[1]
Memory overview9004000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxsystem.memory[apps]
1000CC00020- PostgresPro-Linuxsystem.memory[buffers]
200000CC020- PostgresPro-Linuxsystem.memory[swap]
30CC00CC020- PostgresPro-Linuxsystem.memory[cached]
40000000020- PostgresPro-Linuxsystem.memory[unused]
50CCCC00020- PostgresPro-Linuxsystem.memory[slab]
60777777020- PostgresPro-Linuxsystem.memory[swap_cache]
70770000020- PostgresPro-Linuxsystem.memory[page_tables]
80000077020- PostgresPro-Linuxsystem.memory[vmalloc_used]
90007700020- PostgresPro-Linuxsystem.memory[committed]
100DF0000020- PostgresPro-Linuxsystem.memory[mapped]
11000DF00020- PostgresPro-Linuxsystem.memory[active]
1200000DF020- PostgresPro-Linuxsystem.memory[inactive]
PostgreSQL oldest transaction running time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.oldest[transaction_time]
PostgreSQL age of oldest xid9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.oldest[xid_age]
System: count of opened files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.open_files[]
PostgreSQL: shared buffer9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.buffers[size]
10CC0000020- PostgresPro-Linuxpgsql.buffers[twice_used]
2000CC00020- PostgresPro-Linuxpgsql.buffers[dirty]
PostgreSQL uptime9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cache[hit]
10DF0101120- PostgresPro-Linuxpgsql.uptime[]
PostgreSQL locks sampling9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.pg_locks[accessshare]
1000CC00020- PostgresPro-Linuxpgsql.pg_locks[rowshare]
20CC0000020- PostgresPro-Linuxpgsql.pg_locks[rowexclusive]
30CC00CC020- PostgresPro-Linuxpgsql.pg_locks[shareupdateexclusive]
40777777020- PostgresPro-Linuxpgsql.pg_locks[share]
50CCCCCC020- PostgresPro-Linuxpgsql.pg_locks[sharerowexclusive]
60CCCC00020- PostgresPro-Linuxpgsql.pg_locks[exclusive]
7000CCCC020- PostgresPro-Linuxpgsql.pg_locks[accessexclusive]
PostgreSQL statements: bytes9002000.0100.0110100.00.0000000BBBB00020- PostgresPro-Linuxpgsql.stat[read_bytes]
1000CC00020- PostgresPro-Linuxpgsql.stat[write_bytes]
200000CC020- PostgresPro-Linuxpgsql.stat[dirty_bytes]
PostgreSQL statements: spend time9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.stat[read_time]
100000CC020- PostgresPro-Linuxpgsql.stat[write_time]
20BBBB00020- PostgresPro-Linuxpgsql.stat[other_time]
PostgreSQL waits: Locks by type9002000.0100.0111100.00.00000000000CC020- PostgresPro-Linuxpgsql.all_lock[lwlock]
1000CC00020- PostgresPro-Linuxpgsql.all_lock[hwlock]
20CC0000020- PostgresPro-Linuxpgsql.all_lock[buffer]
PostgreSQL waits: Heavyweight locks9002000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxpgsql.hwlock[relation]
1000CC00020- PostgresPro-Linuxpgsql.hwlock[extend]
200000CC020- PostgresPro-Linuxpgsql.hwlock[page]
30CC00CC020- PostgresPro-Linuxpgsql.hwlock[tuple]
40000000020- PostgresPro-Linuxpgsql.hwlock[transactionid]
50CCCC00020- PostgresPro-Linuxpgsql.hwlock[virtualxid]
60777777020- PostgresPro-Linuxpgsql.hwlock[speculative_token]
70770000020- PostgresPro-Linuxpgsql.hwlock[object]
80000077020- PostgresPro-Linuxpgsql.hwlock[userlock]
90007700020- PostgresPro-Linuxpgsql.hwlock[advisory]
PostgreSQL waits: Lightweight locks9002000.0100.0111100.00.0000000BBBB00020- PostgresPro-Linuxpgsql.lwlock[xid]
10CC0000020- PostgresPro-Linuxpgsql.lwlock[wal]
2000CC00020- PostgresPro-Linuxpgsql.lwlock[clog]
30FFFFCC020- PostgresPro-Linuxpgsql.lwlock[replication]
400000CC020- PostgresPro-Linuxpgsql.lwlock[buffer]
50007700020- PostgresPro-Linuxpgsql.lwlock[other]
PostgreSQL prepared transaction9002000.0100.0110100.00.000000000BB00020- PostgresPro-Linuxpgsql.prepared.count
100000BB120- PostgresPro-Linuxpgsql.prepared.oldest
Processes overview9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.processes[running]
1000CC00020- PostgresPro-Linuxsystem.processes[blocked]
200000CC120- PostgresPro-Linuxsystem.processes[forkrate]
CPU time spent9002000.0100.0111100.00.00000000000CC020- PostgresPro-Linuxsystem.cpu[user]
10CC00CC020- PostgresPro-Linuxsystem.cpu[nice]
20CC0000020- PostgresPro-Linuxsystem.cpu[system]
3000CC00020- PostgresPro-Linuxsystem.cpu[idle]
40CCCC00020- PostgresPro-Linuxsystem.cpu[iowait]
50777777020- PostgresPro-Linuxsystem.cpu[irq]
60000077020- PostgresPro-Linuxsystem.cpu[softirq]
System up_time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.up_time[]
PostgreSQL write-ahead log generation speed9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.wal.write[]
PostgreSQL replication lag in second9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.replication_lag[sec]
PostgreSQL count of xlog files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.wal.count[]
-
\ No newline at end of file
diff --git a/packaging/conf/old_templates/template_2.6.2_agent.xml b/packaging/conf/old_templates/template_2.6.2_agent.xml
deleted file mode 100644
index fbe54ffe..00000000
--- a/packaging/conf/old_templates/template_2.6.2_agent.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-2.0
-
-
- Templates
-
-
-
-
- PostgresPro-Linux
- PostgresPro-Linux
-
-
- Templates
-
-
-
-
- App-PostgresPro-Linux
-
-
- - PostgreSQL archive command count files in archive_status need to archive000pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command size of files need to archive000pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command count archived files000pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL archive command count attempts to archive files000pgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written during checkpoints000pgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written000pgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: number of bgwriter stopped by max write count000pgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written directly by a backend000pgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: times a backend execute its own fsync000pgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers allocated000pgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL checkpoints: by timeout (in hour)000pgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]7365030001000100App-PostgresPro-Linux
- PostgreSQL checkpoints: by wal (in hour)000pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]7365030001000100App-PostgresPro-Linux
- PostgreSQL checkpoint: write time000pgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100App-PostgresPro-Linux
- PostgreSQL checkpoint: sync time000pgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100App-PostgresPro-Linux
- PostgreSQL: number of total connections000pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of waiting connections000pgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: max connections000pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of active connections000pgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle connections000pgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle in transaction connections000pgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle in transaction (aborted)000pgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of fastpath function call000pgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of disabled000pgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: count of autovacuum workers000pgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-Linux
- Block devices: read requests000system.disk.all_read736506001000100App-PostgresPro-Linux
- Block devices: write requests000system.disk.all_write736506001000100App-PostgresPro-Linux
- Block devices: read byte/s000system.disk.all_read_b736506001000100App-PostgresPro-Linux
- Block devices: write byte/s000system.disk.all_write_b736506001000100App-PostgresPro-Linux
- Mamonsu: plugin keep alive000mamonsu.plugin.keepalive736506000000100App-PostgresPro-Linux
- PostgreSQL transactions: total000pgsql.transactions.total[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL blocks: hit000pgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL blocks: read000pgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL event: conflicts000pgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- PostgreSQL event: deadlocks000pgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- PostgreSQL event: rollbacks000pgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- PostgreSQL temp: bytes written000pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b2000100App-PostgresPro-Linux
- PostgreSQL temp: files created000pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- PostgreSQL tuples: deleted000pgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL tuples: fetched000pgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL tuples: inserted000pgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL tuples: returned000pgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL tuples: updated000pgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL event: checksum_failures000pgsql.events.checksum_failures[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- System load average over 1 minute000system.la.1736506000000100App-PostgresPro-Linux
- Apps: User-space applications000system.memory.apps73650603b0000100App-PostgresPro-Linux
- Buffers: Block device cache and dirty000system.memory.buffers73650603b0000100App-PostgresPro-Linux
- Swap: Swap space used000system.memory.swap73650603b0000100App-PostgresPro-Linux
- Cached: Parked file data (file content) cache000system.memory.cached73650603b0000100App-PostgresPro-Linux
- Free: Wasted memory000system.memory.unused73650603b0000100App-PostgresPro-Linux
- Slab: Kernel used memory (inode cache)000system.memory.slab73650603b0000100App-PostgresPro-Linux
- SwapCached: Fetched unmod yet swap pages000system.memory.swap_cache73650603b0000100App-PostgresPro-Linux
- PageTables: Map bt virtual and physical000system.memory.page_tables73650603b0000100App-PostgresPro-Linux
- VMallocUsed: vmaloc() allocated by kernel000system.memory.vmalloc_used73650603b0000100App-PostgresPro-Linux
- Committed_AS: Total committed memory000system.memory.committed73650603b0000100App-PostgresPro-Linux
- Mapped: All mmap()ed pages000system.memory.mapped73650603b0000100App-PostgresPro-Linux
- Active: Memory recently used000system.memory.active73650603b0000100App-PostgresPro-Linux
- Inactive: Memory not currently used000system.memory.inactive73650603b0000100App-PostgresPro-Linux
- PostgreSQL: age of oldest xid000pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL: oldest transaction running time in sec000pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}]73650600s0000100App-PostgresPro-Linux
- Opened files000system.open_files736506030000100App-PostgresPro-Linux
- PostgreSQL: shared buffer size000pgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: shared buffer twice used size000pgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: shared buffer dirty size000pgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: ping000pgsql.ping[{$PG_CONNINFO},{$PG_PATH}]7365050ms0000100App-PostgresPro-Linux
- PostgreSQL: cache hit ratio000pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]73650600%0000100App-PostgresPro-Linux
- PostgreSQL: service uptime000pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]73650600uptime0000100App-PostgresPro-Linux
- PostgreSQL locks: Read only queries000pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: SELECT FOR SHARE and SELECT FOR UPDATE000pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Write queries000pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY000pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: CREATE INDEX000pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Locks from application000pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Locks from application or some operation on system catalogs000pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE000pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL statements: read bytes/s000pgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux
- PostgreSQL statements: write bytes/s000pgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux
- PostgreSQL statements: dirty bytes/s000pgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux
- PostgreSQL statements: read io time000pgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux
- PostgreSQL statements: write io time000pgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux
- PostgreSQL statements: other (mostly cpu) time000pgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux
- PostgreSQL: number of prepared transactions000pgsql.prepared.count736506000000100App-PostgresPro-Linux
- PostgreSQL: oldest prepared transaction running time in sec000pgsql.prepared.oldest73650600000100App-PostgresPro-Linux
- Processes: in state running000system.processes.running736506000000100App-PostgresPro-Linux
- Processes: in state blocked000system.processes.blocked736506000000100App-PostgresPro-Linux
- Processes: forkrate000system.processes.forkrate736506001000100App-PostgresPro-Linux
- CPU time spent by normal programs and daemons000system.cpu.user736506001000100App-PostgresPro-Linux
- CPU time spent by nice(1)d programs000system.cpu.nice736506001000100App-PostgresPro-Linux
- CPU time spent by the kernel in system activities000system.cpu.system736506001000100App-PostgresPro-Linux
- CPU time spent Idle CPU time000system.cpu.idle736506001000100App-PostgresPro-Linux
- CPU time spent waiting for I/O operations000system.cpu.iowait736506001000100App-PostgresPro-Linux
- CPU time spent handling interrupts000system.cpu.irq736506001000100App-PostgresPro-Linux
- CPU time spent handling batched interrupts000system.cpu.softirq736506001000100App-PostgresPro-Linux
- System up_time000system.up_time73650603uptime0000100App-PostgresPro-Linux
- PostgreSQL: wal write speed000pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux
- PostgreSQL: streaming replication lag000pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: count of xlog files000pgsql.wal.count[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- Database discovery060000007pgsql.database.discovery[{$PG_CONNINFO},{$PG_PATH}]{#DATABASE}.*A0Database {#DATABASE}: size000pgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]736503003b0000100App-PostgresPro-LinuxMax age (datfrozenxid) in: {#DATABASE}000pgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-LinuxCount of bloating tables in database: {#DATABASE}000pgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-LinuxDatabase: {#DATABASE} size9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
Database bloating overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
1000CC00120- PostgresPro-Linuxpgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
Database max age overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
1000CC00120- PostgresPro-Linuxpgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
VFS discovery060000007system.vfs.discovery{#MOUNTPOINT}.*A0Mount point {#MOUNTPOINT}: used000system.vfs.used[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free000system.vfs.free[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free in percents000system.vfs.percent_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-Linux{PostgresPro-Linux:system.vfs.percent_free[{#MOUNTPOINT}].last()}<10Free disk space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030Mount point overview: {#MOUNTPOINT}9002000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxsystem.vfs.used[{#MOUNTPOINT}]
100000CC020- PostgresPro-Linuxsystem.vfs.free[{#MOUNTPOINT}]
Block device discovery060000007system.disk.discovery{#BLOCKDEVICE}.*A0Block device {#BLOCKDEVICE}: utilization000system.disk.utilization[{#BLOCKDEVICE}]73650600%1000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: read operations000system.disk.read[{#BLOCKDEVICE}]736506001000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: write operations000system.disk.write[{#BLOCKDEVICE}]736506001000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: read byte/s000system.disk.read_b[{#BLOCKDEVICE}]73650600b1000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: write byte/s000system.disk.write_b[{#BLOCKDEVICE}]73650600b1000100App-PostgresPro-LinuxBlock device overview: {#BLOCKDEVICE} operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.read[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linuxsystem.disk.write[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Block device overview: {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.read_b[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linuxsystem.disk.write_b[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Net iface discovery060000007system.net.discovery{#NETDEVICE}.*A0Network device {#NETDEVICE}: RX bytes/s000system.net.rx_bytes[{#NETDEVICE}]73650600b1000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: RX errors/s000system.net.rx_errs[{#NETDEVICE}]736506001000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: RX drops/s000system.net.rx_drop[{#NETDEVICE}]736506001000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX bytes/s000system.net.tx_bytes[{#NETDEVICE}]73650600b1000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX errors/s000system.net.tx_errs[{#NETDEVICE}]736506001000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX drops/s000system.net.tx_drop[{#NETDEVICE}]736506001000100App-PostgresPro-LinuxNetwork device: {#NETDEVICE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.net.rx_bytes[{#NETDEVICE}]
100000CC020- PostgresPro-Linuxsystem.net.tx_bytes[{#NETDEVICE}]
Pg_probackup discovery060000007pg_probackup.discovery[]{#BACKUPDIR}.*A0Pg_probackup catalog {#BACKUPDIR}: size000pg_probackup.dir.size[{#BACKUPDIR}]7365053b0000100App-PostgresPro-LinuxPg_probackup catalog {#BACKUPDIR}: error000pg_probackup.dir.error[{#BACKUPDIR}]73650540000100App-PostgresPro-Linux{PostgresPro-Linux:pg_probackup.dir.error[{#BACKUPDIR}].strlen()}>1Error in backup dir {#BACKUPDIR} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030Pg_probackup: backup dir: {#BACKUPDIR} size9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpg_probackup.dir.size[{#BACKUPDIR}]
Relation size discovery060000007pgsql.relation.size[{$PG_CONNINFO},{$PG_PATH}]{#RELATIONNAME}.*A0Relation size: {#RELATIONNAME}000pgsql.relation.size[{#RELATIONNAME},{$PG_CONNINFO},{$PG_PATH}]7365063b0000100App-PostgresPro-LinuxPostgreSQL relation size: {#RELATIONNAME}9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.relation.size[{#RELATIONNAME},{$PG_CONNINFO},{$PG_PATH}]
- {$PG_CONNINFO}-qAt -p 5433 -U postgres {$PG_PATH}/opt/pgpro/std-10/bin/psql
-
-
- {PostgresPro-Linux:pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}].last()}>2PostgreSQL count files in ./archive_status on {HOSTNAME} more than 2030{PostgresPro-Linux:pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}].last()}>12PostgreSQL required checkpoints occurs to frequently on {HOSTNAME}030 {PostgresPro-Linux:pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}].last()}/{PostgresPro-Linux:pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}].last()}*100 >90PostgreSQL many connections on {HOSTNAME} (total connections more than 90% max connections)030{PostgresPro-Linux:mamonsu.plugin.keepalive.nodata(180)}=1Mamonsu nodata from {HOSTNAME}030{PostgresPro-Linux:pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}].last()}>18000000PostgreSQL oldest xid is too big on {HOSTNAME}030{PostgresPro-Linux:pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}].last()}>18000PostgreSQL query running is too old on {HOSTNAME}030{PostgresPro-Linux:pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}].last()}<600PostgreSQL service was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}].last()}<80PostgreSQL cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.ping[{$PG_CONNINFO},{$PG_PATH}].nodata(180)}=1PostgreSQL no ping from PostgreSQL for 3 minutes {HOSTNAME} 030{PostgresPro-Linux:pgsql.prepared.oldest.last()}>3PostgreSQL prepared transaction running is too old on {HOSTNAME}030{PostgresPro-Linux:system.processes.forkrate.min(5m)}>500Process fork-rate to frequently on {HOSTNAME}030{PostgresPro-Linux:system.up_time.last()}<300System was restarted on {HOSTNAME} (up_time={ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}].last()}>300PostgreSQL streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})030
- PostgreSQL archive command archive_status 9002000.0100.0110100.00.0000000FF0000020- PostgresPro-Linuxpgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]
1000FF00120- PostgresPro-Linuxpgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL archive command trying_to_archive 9002000.0100.0110100.00.000000000F000020- PostgresPro-Linuxpgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]
10FF0000120- PostgresPro-Linuxpgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL bgwriter9002000.0100.0110100.00.0000000CCCC00120- PostgresPro-Linuxpgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]
100000CC120- PostgresPro-Linuxpgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]
20777777020- PostgresPro-Linuxpgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]
30CC0000120- PostgresPro-Linuxpgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]
40CC00CC020- PostgresPro-Linuxpgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]
5000CC00120- PostgresPro-Linuxpgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL checkpoints9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]
10CC0000020- PostgresPro-Linuxpgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]
200000CC120- PostgresPro-Linuxpgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]
30000000120- PostgresPro-Linuxpgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL connections9002000.0100.0110100.00.000000000BB00020- PostgresPro-Linuxpgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]
100000BB020- PostgresPro-Linuxpgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]
20CC00CC020- PostgresPro-Linuxpgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]
30CCCCCC020- PostgresPro-Linuxpgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]
40CCCC00020- PostgresPro-Linuxpgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]
5000CCCC020- PostgresPro-Linuxpgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]
60EEEEEE020- PostgresPro-Linuxpgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]
70BB0000020- PostgresPro-Linuxpgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]
8000BB00020- PostgresPro-Linuxpgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]
Block devices: read/write operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.all_read
100000CC020- PostgresPro-Linuxsystem.disk.all_write
Block devices: read/write bytes9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.all_read_b
100000CC020- PostgresPro-Linuxsystem.disk.all_write_b
PostgreSQL instance: rate9002000.0100.0110100.00.00000000000CC120- PostgresPro-Linuxpgsql.transactions.total[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linuxpgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linuxpgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: events9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]
10000000020- PostgresPro-Linuxpgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linuxpgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]
3000FF00020- PostgresPro-Linuxpgsql.events.checksum_failures[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: temp files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]
100000CC120- PostgresPro-Linuxpgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: tuples9002000.0100.0110100.00.0000000000000020- PostgresPro-Linuxpgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]
100000CC020- PostgresPro-Linuxpgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]
2000CC00020- PostgresPro-Linuxpgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]
30CC00CC120- PostgresPro-Linuxpgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]
40CC0000020- PostgresPro-Linuxpgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]
System load average9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.la.1
Memory overview9004000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxsystem.memory.apps
1000CC00020- PostgresPro-Linuxsystem.memory.buffers
200000CC020- PostgresPro-Linuxsystem.memory.swap
30CC00CC020- PostgresPro-Linuxsystem.memory.cached
40000000020- PostgresPro-Linuxsystem.memory.unused
50CCCC00020- PostgresPro-Linuxsystem.memory.slab
60777777020- PostgresPro-Linuxsystem.memory.swap_cache
70770000020- PostgresPro-Linuxsystem.memory.page_tables
80000077020- PostgresPro-Linuxsystem.memory.vmalloc_used
90007700020- PostgresPro-Linuxsystem.memory.committed
100DF0000020- PostgresPro-Linuxsystem.memory.mapped
11000DF00020- PostgresPro-Linuxsystem.memory.active
1200000DF020- PostgresPro-Linuxsystem.memory.inactive
PostgreSQL oldest transaction running time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL age of oldest xid9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]
System: count of opened files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.open_files
PostgreSQL: shared buffer9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]
10CC0000020- PostgresPro-Linuxpgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]
2000CC00020- PostgresPro-Linuxpgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL uptime9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]
10DF0101120- PostgresPro-Linuxpgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL locks sampling9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linuxpgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linuxpgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]
30CC00CC020- PostgresPro-Linuxpgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]
40777777020- PostgresPro-Linuxpgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]
50CCCCCC020- PostgresPro-Linuxpgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]
60CCCC00020- PostgresPro-Linuxpgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]
7000CCCC020- PostgresPro-Linuxpgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL statements: bytes9002000.0100.0110100.00.0000000BBBB00020- PostgresPro-Linuxpgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linuxpgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]
200000CC020- PostgresPro-Linuxpgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL statements: spend time9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]
100000CC020- PostgresPro-Linuxpgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]
20BBBB00020- PostgresPro-Linuxpgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL prepared transaction9002000.0100.0110100.00.000000000BB00020- PostgresPro-Linuxpgsql.prepared.count
100000BB120- PostgresPro-Linuxpgsql.prepared.oldest
Processes overview9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.processes.running
1000CC00020- PostgresPro-Linuxsystem.processes.blocked
200000CC120- PostgresPro-Linuxsystem.processes.forkrate
CPU time spent9002000.0100.0111100.00.00000000000CC020- PostgresPro-Linuxsystem.cpu.user
10CC00CC020- PostgresPro-Linuxsystem.cpu.nice
20CC0000020- PostgresPro-Linuxsystem.cpu.system
3000CC00020- PostgresPro-Linuxsystem.cpu.idle
40CCCC00020- PostgresPro-Linuxsystem.cpu.iowait
50777777020- PostgresPro-Linuxsystem.cpu.irq
60000077020- PostgresPro-Linuxsystem.cpu.softirq
System up_time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.up_time
PostgreSQL write-ahead log generation speed9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL replication lag in second9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL count of xlog files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.wal.count[{$PG_CONNINFO},{$PG_PATH}]
-
\ No newline at end of file
diff --git a/packaging/conf/old_templates/template_2.7.1.xml b/packaging/conf/old_templates/template_2.7.1.xml
deleted file mode 100644
index 73daff68..00000000
--- a/packaging/conf/old_templates/template_2.7.1.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-2.0
-
-
- Templates
-
-
-
-
- PostgresPro-Linux
- PostgresPro-Linux
-
-
- Templates
-
-
-
-
- App-PostgresPro-Linux
-
-
- - PostgreSQL archive command count files in archive_status need to archive200pgsql.archive_command[count_files_to_archive]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command size of files need to archive200pgsql.archive_command[size_files_to_archive]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command count archived files200pgsql.archive_command[archived_files]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command count attempts to archive files200pgsql.archive_command[failed_trying_to_archive]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written during checkpoints200pgsql.bgwriter[buffers_checkpoint]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written200pgsql.bgwriter[buffers_clean]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: number of bgwriter stopped by max write count200pgsql.bgwriter[maxwritten_clean]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written directly by a backend200pgsql.bgwriter[buffers_backend]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: times a backend execute its own fsync200pgsql.bgwriter[buffers_backend_fsync]736506030000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers allocated200pgsql.bgwriter[buffers_alloc]736506030000100App-PostgresPro-Linux
- PostgreSQL cfs compression: written byte/s200pgsql.cfs.activity[written_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL cfs compression: scanned byte/s200pgsql.cfs.activity[scanned_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL cfs compression: compressed files200pgsql.cfs.activity[compressed_files]736506000000100App-PostgresPro-Linux
- PostgreSQL cfs compression: scanned files200pgsql.cfs.activity[scanned_files]736506000000100App-PostgresPro-Linux
- PostgreSQL cfs compression: current ratio200pgsql.cfs.activity[current_compress_ratio]736506000000100App-PostgresPro-Linux
- PostgreSQL cfs compression: total ratio200pgsql.cfs.activity[total_compress_ratio]736506000000100App-PostgresPro-Linux
- PostgreSQL checkpoints: by timeout (in hour)200pgsql.checkpoint[count_timed]7365030000000100App-PostgresPro-Linux
- PostgreSQL checkpoints: by wal (in hour)200pgsql.checkpoint[count_wal]7365030000000100App-PostgresPro-Linux
- PostgreSQL checkpoint: write time200pgsql.checkpoint[write_time]736503000ms0000100App-PostgresPro-Linux
- PostgreSQL checkpoint: sync time200pgsql.checkpoint[checkpoint_sync_time]736503000ms0000100App-PostgresPro-Linux
- PostgreSQL: number of total connections200pgsql.connections[total]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of waiting connections200pgsql.connections[waiting]736506000000100App-PostgresPro-Linux
- PostgreSQL: max connections200pgsql.connections[max_connections]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of active connections200pgsql.connections[active]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle connections200pgsql.connections[idle]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle in transaction connections200pgsql.connections[idle_in_transaction]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle in transaction (aborted)200pgsql.connections[idle_in_transaction_aborted]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of fastpath function call200pgsql.connections[fastpath_function_call]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of disabled200pgsql.connections[disabled]736506000000100App-PostgresPro-Linux
- PostgreSQL: count of autovacuum workers200pgsql.autovacumm.count[]7365030000000100App-PostgresPro-Linux
- Block devices: read requests200system.disk.all_read[]736506000000100App-PostgresPro-Linux
- Block devices: write requests200system.disk.all_write[]736506000000100App-PostgresPro-Linux
- Block devices: read byte/s200system.disk.all_read_b[]736506000000100App-PostgresPro-Linux
- Block devices: write byte/s200system.disk.all_write_b[]736506000000100App-PostgresPro-Linux
- Mamonsu: plugin errors200mamonsu.plugin.errors[]736506040000100App-PostgresPro-Linux
- Mamonsu: plugin keep alive200mamonsu.plugin.keepalive[]736506000000100App-PostgresPro-Linux
- Mamonsu: rss memory max usage200mamonsu.memory.rss[max]73650600b0000100App-PostgresPro-Linux
- PostgreSQL transactions: total200pgsql.transactions[total]736506000000100App-PostgresPro-Linux
- PostgreSQL blocks: hit200pgsql.blocks[hit]736506000000100App-PostgresPro-Linux
- PostgreSQL blocks: read200pgsql.blocks[read]736506000000100App-PostgresPro-Linux
- PostgreSQL event: conflicts200pgsql.events[conflicts]736506000000100App-PostgresPro-Linux
- PostgreSQL event: deadlocks200pgsql.events[deadlocks]736506000000100App-PostgresPro-Linux
- PostgreSQL event: rollbacks200pgsql.events[xact_rollback]736506000000100App-PostgresPro-Linux
- PostgreSQL temp: bytes written200pgsql.temp[bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL temp: files created200pgsql.temp[files]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: deleted200pgsql.tuples[deleted]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: fetched200pgsql.tuples[fetched]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: inserted200pgsql.tuples[inserted]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: returned200pgsql.tuples[returned]736506000000100App-PostgresPro-Linux
- PostgreSQL tuples: updated200pgsql.tuples[updated]736506000000100App-PostgresPro-Linux
- PostgreSQL event: checksum_failures200pgsql.events[checksum_failures]736506000000100App-PostgresPro-Linux
- System load average over 1 minute200system.la[1]736506000000100App-PostgresPro-Linux
- Apps: User-space applications200system.memory[apps]73650603b0000100App-PostgresPro-Linux
- Buffers: Block device cache and dirty200system.memory[buffers]73650603b0000100App-PostgresPro-Linux
- Swap: Swap space used200system.memory[swap]73650603b0000100App-PostgresPro-Linux
- Cached: Parked file data (file content) cache200system.memory[cached]73650603b0000100App-PostgresPro-Linux
- Free: Wasted memory200system.memory[unused]73650603b0000100App-PostgresPro-Linux
- Slab: Kernel used memory (inode cache)200system.memory[slab]73650603b0000100App-PostgresPro-Linux
- SwapCached: Fetched unmod yet swap pages200system.memory[swap_cache]73650603b0000100App-PostgresPro-Linux
- PageTables: Map bt virtual and physical200system.memory[page_tables]73650603b0000100App-PostgresPro-Linux
- VMallocUsed: vmaloc() allocated by kernel200system.memory[vmalloc_used]73650603b0000100App-PostgresPro-Linux
- Committed_AS: Total committed memory200system.memory[committed]73650603b0000100App-PostgresPro-Linux
- Mapped: All mmap()ed pages200system.memory[mapped]73650603b0000100App-PostgresPro-Linux
- Active: Memory recently used200system.memory[active]73650603b0000100App-PostgresPro-Linux
- Inactive: Memory not currently used200system.memory[inactive]73650603b0000100App-PostgresPro-Linux
- PostgreSQL: number of pids which private anonymous memory exceeds private_anon_mem_threshold200pgsql.memory_leak_diagnostic.count_diff[]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of pids which private anonymous memory exceeds private_anon_mem_threshold, text of message200pgsql.memory_leak_diagnostic.msg_text[]736506040000100App-PostgresPro-Linux
- PostgreSQL: age of oldest xid200pgsql.oldest[xid_age]736506030000100App-PostgresPro-Linux
- PostgreSQL: oldest transaction running time in sec200pgsql.oldest[transaction_time]73650600s0000100App-PostgresPro-Linux
- PostgreSQL: number of parallel queries being executed now200pgsql.parallel[queries]736506030000100App-PostgresPro-Linux
- Opened files200system.open_files[]736506030000100App-PostgresPro-Linux
- PostgreSQL: shared buffer size200pgsql.buffers[size]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: shared buffer twice used size200pgsql.buffers[twice_used]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: shared buffer dirty size200pgsql.buffers[dirty]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: ping200pgsql.ping[]73650600ms0000100App-PostgresPro-Linux
- PostgreSQL: cache hit ratio200pgsql.cache[hit]73650603%0000100App-PostgresPro-Linux
- PostgreSQL: service uptime200pgsql.uptime[]73650603uptime0000100App-PostgresPro-Linux
- PostgreSQL locks: Read only queries200pgsql.pg_locks[accessshare]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: SELECT FOR SHARE and SELECT FOR UPDATE200pgsql.pg_locks[rowshare]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Write queries200pgsql.pg_locks[rowexclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY200pgsql.pg_locks[shareupdateexclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: CREATE INDEX200pgsql.pg_locks[share]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Locks from application200pgsql.pg_locks[sharerowexclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Locks from application or some operation on system catalogs200pgsql.pg_locks[exclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE200pgsql.pg_locks[accessexclusive]736506030000100App-PostgresPro-Linux
- PostgreSQL statements: read bytes/s200pgsql.stat[read_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL statements: write bytes/s200pgsql.stat[write_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL statements: dirty bytes/s200pgsql.stat[dirty_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL statements: read io time200pgsql.stat[read_time]73650600s0000100App-PostgresPro-Linux
- PostgreSQL statements: write io time200pgsql.stat[write_time]73650600s0000100App-PostgresPro-Linux
- PostgreSQL statements: other (mostly cpu) time200pgsql.stat[other_time]73650600s0000100App-PostgresPro-Linux
- PostgreSQL statements: amount of wal files200pgsql.stat[wal_bytes]73650600b0000100App-PostgresPro-Linux
- PostgreSQL statements: amount of wal records200pgsql.stat[wal_records]736506000000100App-PostgresPro-Linux
- PostgreSQL statements: full page writes200pgsql.stat[wal_fpi]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Lightweight locks200pgsql.all_lock[lwlock]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Heavyweight locks200pgsql.all_lock[hwlock]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Buffer locks200pgsql.all_lock[buffer]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: XID access200pgsql.lwlock[xid]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: WAL access200pgsql.lwlock[wal]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: CLOG access200pgsql.lwlock[clog]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Replication Locks200pgsql.lwlock[replication]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Buffer operations200pgsql.lwlock[buffer]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: Other operations200pgsql.lwlock[other]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: lock on a relation200pgsql.hwlock[relation]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: extend a relation200pgsql.hwlock[extend]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: lock on page200pgsql.hwlock[page]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: lock on a tuple200pgsql.hwlock[tuple]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: transaction to finish200pgsql.hwlock[transactionid]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: virtual xid lock200pgsql.hwlock[virtualxid]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: speculative insertion lock200pgsql.hwlock[speculative_token]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: lock on database object200pgsql.hwlock[object]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: userlock200pgsql.hwlock[userlock]736506000000100App-PostgresPro-Linux
- PostgreSQL waits: advisory user lock200pgsql.hwlock[advisory]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of prepared transactions200pgsql.prepared.count736506000000100App-PostgresPro-Linux
- PostgreSQL: oldest prepared transaction time in sec200pgsql.prepared.oldest736506000000100App-PostgresPro-Linux
- Processes: in state running200system.processes[running]736506000000100App-PostgresPro-Linux
- Processes: in state blocked200system.processes[blocked]736506000000100App-PostgresPro-Linux
- Processes: forkrate200system.processes[forkrate]736506000000100App-PostgresPro-Linux
- CPU time spent by normal programs and daemons200system.cpu[user]736506000000100App-PostgresPro-Linux
- CPU time spent by nice(1)d programs200system.cpu[nice]736506000000100App-PostgresPro-Linux
- CPU time spent by the kernel in system activities200system.cpu[system]736506000000100App-PostgresPro-Linux
- CPU time spent Idle CPU time200system.cpu[idle]736506000000100App-PostgresPro-Linux
- CPU time spent waiting for I/O operations200system.cpu[iowait]736506000000100App-PostgresPro-Linux
- CPU time spent handling interrupts200system.cpu[irq]736506000000100App-PostgresPro-Linux
- CPU time spent handling batched interrupts200system.cpu[softirq]736506000000100App-PostgresPro-Linux
- System up_time200system.up_time[]73650603uptime0000100App-PostgresPro-Linux
- PostgreSQL: wal write speed200pgsql.wal.write[]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: streaming replication lag200pgsql.replication_lag[sec]736506000000100App-PostgresPro-Linux
- PostgreSQL: count of xlog files200pgsql.wal.count[]736506000000100App-PostgresPro-Linux
- PostgreSQL: count non-active replication slots200pgsql.replication.non_active_slots[]736506030000100App-PostgresPro-Linux
- Compressed relations discovery260000007pgsql.cfs.discovery_compressed_relations[]{#COMPRESSED_RELATION}.*A0Relation {#COMPRESSED_RELATION}: compress ratio200pgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]7365060000000100App-PostgresPro-LinuxRelation {#COMPRESSED_RELATION}: compress ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]
Database discovery260000007pgsql.database.discovery[]{#DATABASE}.*A0Database {#DATABASE}: size200pgsql.database.size[{#DATABASE}]736503003b0000100App-PostgresPro-LinuxMax age (datfrozenxid) in: {#DATABASE}200pgsql.database.max_age[{#DATABASE}]7365030000000100App-PostgresPro-LinuxCount of bloating tables in database: {#DATABASE}200pgsql.database.bloating_tables[{#DATABASE}]7365030000000100App-PostgresPro-LinuxDatabase: {#DATABASE} size9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.database.size[{#DATABASE}]
Database bloating overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.database.bloating_tables[{#DATABASE}]
1000CC00120- PostgresPro-Linuxpgsql.autovacumm.count[]
Database max age overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.database.max_age[{#DATABASE}]
1000CC00120- PostgresPro-Linuxpgsql.autovacumm.count[]
VFS discovery260000007system.vfs.discovery[]{#MOUNTPOINT}.*A0Mount point {#MOUNTPOINT}: used200system.vfs.used[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free200system.vfs.free[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free in percents200system.vfs.percent_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free inodes in percent200system.vfs.percent_inode_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-Linux{PostgresPro-Linux:system.vfs.percent_free[{#MOUNTPOINT}].last()}<10Free disk space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030{PostgresPro-Linux:system.vfs.percent_inode_free[{#MOUNTPOINT}].last()}<10Free inode space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030Mount point overview: {#MOUNTPOINT}9002000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxsystem.vfs.used[{#MOUNTPOINT}]
100000CC020- PostgresPro-Linuxsystem.vfs.free[{#MOUNTPOINT}]
Block device discovery260000007system.disk.discovery[]{#BLOCKDEVICE}.*A0Block device {#BLOCKDEVICE}: utilization200system.disk.utilization[{#BLOCKDEVICE}]73650600%0000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: read operations200system.disk.read[{#BLOCKDEVICE}]736506000000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: write operations200system.disk.write[{#BLOCKDEVICE}]736506000000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: read byte/s200system.disk.read_b[{#BLOCKDEVICE}]73650600b0000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: write byte/s200system.disk.write_b[{#BLOCKDEVICE}]73650600b0000100App-PostgresPro-LinuxBlock device overview: {#BLOCKDEVICE} operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.read[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linuxsystem.disk.write[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Block device overview: {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.read_b[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linuxsystem.disk.write_b[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Net iface discovery260000007system.net.discovery[]{#NETDEVICE}.*A0Network device {#NETDEVICE}: RX bytes/s200system.net.rx_bytes[{#NETDEVICE}]73650600b0000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: RX errors/s200system.net.rx_errs[{#NETDEVICE}]736506000000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: RX drops/s200system.net.rx_drop[{#NETDEVICE}]736506000000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX bytes/s200system.net.tx_bytes[{#NETDEVICE}]73650600b0000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX errors/s200system.net.tx_errs[{#NETDEVICE}]736506000000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX drops/s200system.net.tx_drop[{#NETDEVICE}]736506000000100App-PostgresPro-LinuxNetwork device: {#NETDEVICE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.net.rx_bytes[{#NETDEVICE}]
100000CC020- PostgresPro-Linuxsystem.net.tx_bytes[{#NETDEVICE}]
Pg_probackup discovery260000007pg_probackup.discovery[]{#BACKUPDIR}.*A0Pg_probackup dir {#BACKUPDIR}: size200pg_probackup.dir.size[{#BACKUPDIR}]736503003b0000100App-PostgresPro-LinuxPg_probackup dir {#BACKUPDIR}: error200pg_probackup.dir.error[{#BACKUPDIR}]7365030040000100App-PostgresPro-Linux{PostgresPro-Linux:pg_probackup.dir.error[{#BACKUPDIR}].str(ok)}<>1Error in pg_probackup dir {#BACKUPDIR} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030Pg_probackup: backup dir: {#BACKUPDIR} size9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpg_probackup.dir.size[{#BACKUPDIR}]
Relation size discovery260000007pgsql.relation.size[]{#RELATIONNAME}.*A0Relation size: {#RELATIONNAME}200pgsql.relation.size[{#RELATIONNAME}]736503003b0000100App-PostgresPro-LinuxPostgreSQL relation size: {#RELATIONNAME}9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.relation.size[{#RELATIONNAME}]
Replication lag discovery260000007pgsql.replication.discovery[]{#APPLICATION_NAME}.*A0Time elapsed between flushing recent WAL locally and receiving notification that this standby server {#APPLICATION_NAME} has written and flushed it200pgsql.replication.flush_lag[{#APPLICATION_NAME}]736506040000100App-PostgresPro-LinuxTime elapsed between flushing recent WAL locally and receiving notification that this standby server {#APPLICATION_NAME} has written, flushed and applied200pgsql.replication.replay_lag[{#APPLICATION_NAME}]736506040000100App-PostgresPro-LinuxTime elapsed between flushing recent WAL locally and receiving notification that this standby server {#APPLICATION_NAME} has written it200pgsql.replication.write_lag[{#APPLICATION_NAME}]736506040000100App-PostgresPro-LinuxDelta of total lag for {#APPLICATION_NAME}200pgsql.replication.total_lag[{#APPLICATION_NAME}]736506000000100App-PostgresPro-LinuxDelta of total lag for {#APPLICATION_NAME}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.replication.total_lag[{#APPLICATION_NAME}]
-
-
-
- {PostgresPro-Linux:pgsql.archive_command[count_files_to_archive].last()}>2PostgreSQL count files in ./archive_status on {HOSTNAME} more than 2030{PostgresPro-Linux:pgsql.checkpoint[count_wal].last()}>12PostgreSQL required checkpoints occurs to frequently on {HOSTNAME}030 {PostgresPro-Linux:pgsql.connections[total].last()}/{PostgresPro-Linux:pgsql.connections[max_connections].last()}*100 >90PostgreSQL many connections on {HOSTNAME} (total connections more than 90% max connections)030{PostgresPro-Linux:mamonsu.plugin.errors[].strlen()}>1Mamonsu plugin errors on {HOSTNAME}. {ITEM.LASTVALUE}030{PostgresPro-Linux:mamonsu.plugin.keepalive[].nodata(180)}=1Mamonsu nodata from {HOSTNAME}030{PostgresPro-Linux:mamonsu.memory.rss[max].last()}>41943040Mamonsu agent memory usage alert on {HOSTNAME}: {ITEM.LASTVALUE} bytes030{PostgresPro-Linux:pgsql.memory_leak_diagnostic.msg_text[].strlen()}>1PostgreSQL: number of pids which private anonymous memory exceeds private_anon_mem_threshold on {HOSTNAME}. {ITEM.LASTVALUE}030{PostgresPro-Linux:pgsql.oldest[xid_age].last()}>18000000PostgreSQL oldest xid is too big on {HOSTNAME}030{PostgresPro-Linux:pgsql.oldest[transaction_time].last()}>18000PostgreSQL query running is too old on {HOSTNAME}030{PostgresPro-Linux:pgsql.uptime[].last()}<600PostgreSQL service was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.cache[hit].last()}<80PostgreSQL cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.ping[].nodata(180)}=1PostgreSQL no ping from PostgreSQL for 3 minutes {HOSTNAME} 030{PostgresPro-Linux:pgsql.prepared.oldest.last()}>60PostgreSQL prepared transaction is too old on {HOSTNAME}030{PostgresPro-Linux:system.processes[forkrate].min(5m)}>500Process fork-rate to frequently on {HOSTNAME}030{PostgresPro-Linux:system.up_time[].last()}<300System was restarted on {HOSTNAME} (up_time={ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.replication_lag[sec].last()}>300PostgreSQL streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.replication.non_active_slots[].last()}#0PostgreSQL number of non-active replication slots on {HOSTNAME} (value={ITEM.LASTVALUE})030
- PostgreSQL archive command archive_status 9002000.0100.0110100.00.0000000FF0000020- PostgresPro-Linuxpgsql.archive_command[count_files_to_archive]
1000FF00120- PostgresPro-Linuxpgsql.archive_command[size_files_to_archive]
PostgreSQL archive command trying_to_archive 9002000.0100.0110100.00.000000000F000020- PostgresPro-Linuxpgsql.archive_command[archived_files]
10FF0000120- PostgresPro-Linuxpgsql.archive_command[failed_trying_to_archive]
PostgreSQL bgwriter9002000.0100.0110100.00.0000000CCCC00120- PostgresPro-Linuxpgsql.bgwriter[buffers_checkpoint]
100000CC120- PostgresPro-Linuxpgsql.bgwriter[buffers_clean]
20777777020- PostgresPro-Linuxpgsql.bgwriter[maxwritten_clean]
30CC0000120- PostgresPro-Linuxpgsql.bgwriter[buffers_backend]
40CC00CC020- PostgresPro-Linuxpgsql.bgwriter[buffers_backend_fsync]
5000CC00120- PostgresPro-Linuxpgsql.bgwriter[buffers_alloc]
PostgreSQL cfs compression: current ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.activity[current_compress_ratio]
PostgreSQL cfs compression: compressed files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.activity[compressed_files]
PostgreSQL cfs compression: written bytes9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.activity[written_bytes]
PostgreSQL cfs compression: total ratio9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cfs.activity[total_compress_ratio]
PostgreSQL checkpoints9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.checkpoint[count_timed]
10CC0000020- PostgresPro-Linuxpgsql.checkpoint[count_wal]
200000CC120- PostgresPro-Linuxpgsql.checkpoint[write_time]
30000000120- PostgresPro-Linuxpgsql.checkpoint[checkpoint_sync_time]
PostgreSQL connections9002000.0100.0110100.00.000000000BB00020- PostgresPro-Linuxpgsql.connections[active]
100000BB020- PostgresPro-Linuxpgsql.connections[idle]
20CC00CC020- PostgresPro-Linuxpgsql.connections[idle_in_transaction]
30CCCCCC020- PostgresPro-Linuxpgsql.connections[idle_in_transaction_aborted]
40CCCC00020- PostgresPro-Linuxpgsql.connections[fastpath_function_call]
5000CCCC020- PostgresPro-Linuxpgsql.connections[disabled]
60EEEEEE020- PostgresPro-Linuxpgsql.connections[total]
70BB0000020- PostgresPro-Linuxpgsql.connections[waiting]
8000BB00020- PostgresPro-Linuxpgsql.connections[max_connections]
Block devices: read/write operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.all_read[]
100000CC020- PostgresPro-Linuxsystem.disk.all_write[]
Block devices: read/write bytes9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.all_read_b[]
100000CC020- PostgresPro-Linuxsystem.disk.all_write_b[]
PostgreSQL instance: rate9002000.0100.0110100.00.00000000000CC120- PostgresPro-Linuxpgsql.transactions[total]
1000CC00020- PostgresPro-Linuxpgsql.blocks[hit]
20CC0000020- PostgresPro-Linuxpgsql.blocks[read]
PostgreSQL instance: events9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.events[conflicts]
10000000020- PostgresPro-Linuxpgsql.events[deadlocks]
20CC0000020- PostgresPro-Linuxpgsql.events[xact_rollback]
3000FF00020- PostgresPro-Linuxpgsql.events[checksum_failures]
PostgreSQL instance: temp files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.temp[bytes]
100000CC120- PostgresPro-Linuxpgsql.temp[files]
PostgreSQL instance: tuples9002000.0100.0110100.00.0000000000000020- PostgresPro-Linuxpgsql.tuples[deleted]
100000CC020- PostgresPro-Linuxpgsql.tuples[fetched]
2000CC00020- PostgresPro-Linuxpgsql.tuples[inserted]
30CC00CC120- PostgresPro-Linuxpgsql.tuples[returned]
40CC0000020- PostgresPro-Linuxpgsql.tuples[updated]
System load average9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.la[1]
Memory overview9004000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxsystem.memory[apps]
1000CC00020- PostgresPro-Linuxsystem.memory[buffers]
200000CC020- PostgresPro-Linuxsystem.memory[swap]
30CC00CC020- PostgresPro-Linuxsystem.memory[cached]
40000000020- PostgresPro-Linuxsystem.memory[unused]
50CCCC00020- PostgresPro-Linuxsystem.memory[slab]
60777777020- PostgresPro-Linuxsystem.memory[swap_cache]
70770000020- PostgresPro-Linuxsystem.memory[page_tables]
80000077020- PostgresPro-Linuxsystem.memory[vmalloc_used]
90007700020- PostgresPro-Linuxsystem.memory[committed]
100DF0000020- PostgresPro-Linuxsystem.memory[mapped]
11000DF00020- PostgresPro-Linuxsystem.memory[active]
1200000DF020- PostgresPro-Linuxsystem.memory[inactive]
PostgreSQL: number of pids which private anonymous memory exceeds private_anon_mem_threshold9002000.0100.0110100.00.0000000FF0000020- PostgresPro-Linuxpgsql.memory_leak_diagnostic.count_diff[]
PostgreSQL oldest transaction running time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.oldest[transaction_time]
PostgreSQL age of oldest xid9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.oldest[xid_age]
PostgreSQL number of parallel queries being executed now9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.parallel[queries]
System: count of opened files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.open_files[]
PostgreSQL: shared buffer9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.buffers[size]
10CC0000020- PostgresPro-Linuxpgsql.buffers[twice_used]
2000CC00020- PostgresPro-Linuxpgsql.buffers[dirty]
PostgreSQL uptime9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cache[hit]
10DF0101120- PostgresPro-Linuxpgsql.uptime[]
PostgreSQL locks sampling9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.pg_locks[accessshare]
1000CC00020- PostgresPro-Linuxpgsql.pg_locks[rowshare]
20CC0000020- PostgresPro-Linuxpgsql.pg_locks[rowexclusive]
30CC00CC020- PostgresPro-Linuxpgsql.pg_locks[shareupdateexclusive]
40777777020- PostgresPro-Linuxpgsql.pg_locks[share]
50CCCCCC020- PostgresPro-Linuxpgsql.pg_locks[sharerowexclusive]
60CCCC00020- PostgresPro-Linuxpgsql.pg_locks[exclusive]
7000CCCC020- PostgresPro-Linuxpgsql.pg_locks[accessexclusive]
PostgreSQL statements: bytes9002000.0100.0110100.00.0000000BBBB00020- PostgresPro-Linuxpgsql.stat[read_bytes]
1000CC00020- PostgresPro-Linuxpgsql.stat[write_bytes]
200000CC020- PostgresPro-Linuxpgsql.stat[dirty_bytes]
PostgreSQL statements: spend time9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.stat[read_time]
100000CC020- PostgresPro-Linuxpgsql.stat[write_time]
20BBBB00020- PostgresPro-Linuxpgsql.stat[other_time]
PostgreSQL statements: wal statistics9002000.0100.0110100.00.0000000BCC000020- PostgresPro-Linuxpgsql.stat[wal_bytes]
10CC6600020- PostgresPro-Linuxpgsql.stat[wal_records]
2000CCCC020- PostgresPro-Linuxpgsql.stat[wal_fpi]
PostgreSQL waits: Locks by type9002000.0100.0111100.00.00000000000CC020- PostgresPro-Linuxpgsql.all_lock[lwlock]
1000CC00020- PostgresPro-Linuxpgsql.all_lock[hwlock]
20CC0000020- PostgresPro-Linuxpgsql.all_lock[buffer]
PostgreSQL waits: Heavyweight locks9002000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxpgsql.hwlock[relation]
1000CC00020- PostgresPro-Linuxpgsql.hwlock[extend]
200000CC020- PostgresPro-Linuxpgsql.hwlock[page]
30CC00CC020- PostgresPro-Linuxpgsql.hwlock[tuple]
40000000020- PostgresPro-Linuxpgsql.hwlock[transactionid]
50CCCC00020- PostgresPro-Linuxpgsql.hwlock[virtualxid]
60777777020- PostgresPro-Linuxpgsql.hwlock[speculative_token]
70770000020- PostgresPro-Linuxpgsql.hwlock[object]
80000077020- PostgresPro-Linuxpgsql.hwlock[userlock]
90007700020- PostgresPro-Linuxpgsql.hwlock[advisory]
PostgreSQL waits: Lightweight locks9002000.0100.0111100.00.0000000BBBB00020- PostgresPro-Linuxpgsql.lwlock[xid]
10CC0000020- PostgresPro-Linuxpgsql.lwlock[wal]
2000CC00020- PostgresPro-Linuxpgsql.lwlock[clog]
30FFFFCC020- PostgresPro-Linuxpgsql.lwlock[replication]
400000CC020- PostgresPro-Linuxpgsql.lwlock[buffer]
50007700020- PostgresPro-Linuxpgsql.lwlock[other]
PostgreSQL prepared transaction9002000.0100.0110100.00.000000000BB00020- PostgresPro-Linuxpgsql.prepared.count
100000BB120- PostgresPro-Linuxpgsql.prepared.oldest
Processes overview9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.processes[running]
1000CC00020- PostgresPro-Linuxsystem.processes[blocked]
200000CC120- PostgresPro-Linuxsystem.processes[forkrate]
CPU time spent9002000.0100.0111100.00.00000000000CC020- PostgresPro-Linuxsystem.cpu[user]
10CC00CC020- PostgresPro-Linuxsystem.cpu[nice]
20CC0000020- PostgresPro-Linuxsystem.cpu[system]
3000CC00020- PostgresPro-Linuxsystem.cpu[idle]
40CCCC00020- PostgresPro-Linuxsystem.cpu[iowait]
50777777020- PostgresPro-Linuxsystem.cpu[irq]
60000077020- PostgresPro-Linuxsystem.cpu[softirq]
System up_time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.up_time[]
PostgreSQL write-ahead log generation speed9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.wal.write[]
PostgreSQL replication lag in second9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.replication_lag[sec]
PostgreSQL count of xlog files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.wal.count[]
-
\ No newline at end of file
diff --git a/packaging/conf/old_templates/template_2.7.1_agent.xml b/packaging/conf/old_templates/template_2.7.1_agent.xml
deleted file mode 100644
index 86e29a4f..00000000
--- a/packaging/conf/old_templates/template_2.7.1_agent.xml
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-2.0
-
-
- Templates
-
-
-
-
- PostgresPro-Linux
- PostgresPro-Linux
-
-
- Templates
-
-
-
-
- App-PostgresPro-Linux
-
-
- - PostgreSQL archive command count files in archive_status need to archive000pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command size of files need to archive000pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL archive command count archived files000pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL archive command count attempts to archive files000pgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written during checkpoints000pgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written000pgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: number of bgwriter stopped by max write count000pgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers written directly by a backend000pgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: times a backend execute its own fsync000pgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL bgwriter: buffers allocated000pgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]736506032000100App-PostgresPro-Linux
- PostgreSQL checkpoints: by timeout (in hour)000pgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]7365030001000100App-PostgresPro-Linux
- PostgreSQL checkpoints: by wal (in hour)000pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]7365030001000100App-PostgresPro-Linux
- PostgreSQL checkpoint: write time000pgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100App-PostgresPro-Linux
- PostgreSQL checkpoint: sync time000pgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100App-PostgresPro-Linux
- PostgreSQL: number of total connections000pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of waiting connections000pgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: max connections000pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of active connections000pgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle connections000pgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle in transaction connections000pgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of idle in transaction (aborted)000pgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of fastpath function call000pgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of disabled000pgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: count of autovacuum workers000pgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-Linux
- Block devices: read requests000system.disk.all_read736506001000100App-PostgresPro-Linux
- Block devices: write requests000system.disk.all_write736506001000100App-PostgresPro-Linux
- Block devices: read byte/s000system.disk.all_read_b736506001000100App-PostgresPro-Linux
- Block devices: write byte/s000system.disk.all_write_b736506001000100App-PostgresPro-Linux
- Mamonsu: plugin keep alive000mamonsu.plugin.keepalive736506000000100App-PostgresPro-Linux
- PostgreSQL transactions: total000pgsql.transactions.total[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL blocks: hit000pgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL blocks: read000pgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL event: conflicts000pgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- PostgreSQL event: deadlocks000pgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- PostgreSQL event: rollbacks000pgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- PostgreSQL temp: bytes written000pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b2000100App-PostgresPro-Linux
- PostgreSQL temp: files created000pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- PostgreSQL tuples: deleted000pgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL tuples: fetched000pgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL tuples: inserted000pgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL tuples: returned000pgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL tuples: updated000pgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL event: checksum_failures000pgsql.events.checksum_failures[{$PG_CONNINFO},{$PG_PATH}]736506002000100App-PostgresPro-Linux
- System load average over 1 minute000system.la.1736506000000100App-PostgresPro-Linux
- Apps: User-space applications000system.memory.apps73650603b0000100App-PostgresPro-Linux
- Buffers: Block device cache and dirty000system.memory.buffers73650603b0000100App-PostgresPro-Linux
- Swap: Swap space used000system.memory.swap73650603b0000100App-PostgresPro-Linux
- Cached: Parked file data (file content) cache000system.memory.cached73650603b0000100App-PostgresPro-Linux
- Free: Wasted memory000system.memory.unused73650603b0000100App-PostgresPro-Linux
- Slab: Kernel used memory (inode cache)000system.memory.slab73650603b0000100App-PostgresPro-Linux
- SwapCached: Fetched unmod yet swap pages000system.memory.swap_cache73650603b0000100App-PostgresPro-Linux
- PageTables: Map bt virtual and physical000system.memory.page_tables73650603b0000100App-PostgresPro-Linux
- VMallocUsed: vmaloc() allocated by kernel000system.memory.vmalloc_used73650603b0000100App-PostgresPro-Linux
- Committed_AS: Total committed memory000system.memory.committed73650603b0000100App-PostgresPro-Linux
- Mapped: All mmap()ed pages000system.memory.mapped73650603b0000100App-PostgresPro-Linux
- Active: Memory recently used000system.memory.active73650603b0000100App-PostgresPro-Linux
- Inactive: Memory not currently used000system.memory.inactive73650603b0000100App-PostgresPro-Linux
- PostgreSQL: number of pids which private anonymous memory exceeds private_anon_mem_threshold000pgsql.memory_leak_diagnostic.count_diff[]736506000000100App-PostgresPro-Linux
- PostgreSQL: number of pids which private anonymous memory exceeds private_anon_mem_threshold, text of message000pgsql.memory_leak_diagnostic.msg_text[]736506040000100App-PostgresPro-Linux
- PostgreSQL: age of oldest xid000pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL: oldest transaction running time in sec000pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}]73650600s0000100App-PostgresPro-Linux
- PostgreSQL: number of parallel queries being executed now000pgsql.parallel.queries[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- Opened files000system.open_files736506030000100App-PostgresPro-Linux
- PostgreSQL: shared buffer size000pgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: shared buffer twice used size000pgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: shared buffer dirty size000pgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100App-PostgresPro-Linux
- PostgreSQL: ping000pgsql.ping[{$PG_CONNINFO},{$PG_PATH}]7365050ms0000100App-PostgresPro-Linux
- PostgreSQL: cache hit ratio000pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]73650600%0000100App-PostgresPro-Linux
- PostgreSQL: service uptime000pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]73650600uptime0000100App-PostgresPro-Linux
- PostgreSQL locks: Read only queries000pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: SELECT FOR SHARE and SELECT FOR UPDATE000pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Write queries000pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY000pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: CREATE INDEX000pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Locks from application000pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: Locks from application or some operation on system catalogs000pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE000pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- PostgreSQL statements: read bytes/s000pgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux
- PostgreSQL statements: write bytes/s000pgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux
- PostgreSQL statements: dirty bytes/s000pgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux
- PostgreSQL statements: read io time000pgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux
- PostgreSQL statements: write io time000pgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux
- PostgreSQL statements: other (mostly cpu) time000pgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100App-PostgresPro-Linux
- PostgreSQL statements: amount of wal files000pgsql.stat.wal_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux
- PostgreSQL statements: amount of wal records000pgsql.stat.wal_records[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL statements: full page writes000pgsql.stat.wal_fpi[{$PG_CONNINFO},{$PG_PATH}]736506001000100App-PostgresPro-Linux
- PostgreSQL: number of prepared transactions000pgsql.prepared.count736506000000100App-PostgresPro-Linux
- PostgreSQL: oldest prepared transaction time in sec000pgsql.prepared.oldest736506000000100App-PostgresPro-Linux
- Processes: in state running000system.processes.running736506000000100App-PostgresPro-Linux
- Processes: in state blocked000system.processes.blocked736506000000100App-PostgresPro-Linux
- Processes: forkrate000system.processes.forkrate736506001000100App-PostgresPro-Linux
- CPU time spent by normal programs and daemons000system.cpu.user736506001000100App-PostgresPro-Linux
- CPU time spent by nice(1)d programs000system.cpu.nice736506001000100App-PostgresPro-Linux
- CPU time spent by the kernel in system activities000system.cpu.system736506001000100App-PostgresPro-Linux
- CPU time spent Idle CPU time000system.cpu.idle736506001000100App-PostgresPro-Linux
- CPU time spent waiting for I/O operations000system.cpu.iowait736506001000100App-PostgresPro-Linux
- CPU time spent handling interrupts000system.cpu.irq736506001000100App-PostgresPro-Linux
- CPU time spent handling batched interrupts000system.cpu.softirq736506001000100App-PostgresPro-Linux
- System up_time000system.up_time73650603uptime0000100App-PostgresPro-Linux
- PostgreSQL: wal write speed000pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]73650600b1000100App-PostgresPro-Linux
- PostgreSQL: streaming replication lag000pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: count of xlog files000pgsql.wal.count[{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-Linux
- PostgreSQL: count non-active replication slots000pgsql.replication.non_active_slots[{$PG_CONNINFO},{$PG_PATH}]736506030000100App-PostgresPro-Linux
- Database discovery060000007pgsql.database.discovery[{$PG_CONNINFO},{$PG_PATH}]{#DATABASE}.*A0Database {#DATABASE}: size000pgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]736503003b0000100App-PostgresPro-LinuxMax age (datfrozenxid) in: {#DATABASE}000pgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-LinuxCount of bloating tables in database: {#DATABASE}000pgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100App-PostgresPro-LinuxDatabase: {#DATABASE} size9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
Database bloating overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
1000CC00120- PostgresPro-Linuxpgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
Database max age overview: {#DATABASE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
1000CC00120- PostgresPro-Linuxpgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
VFS discovery060000007system.vfs.discovery{#MOUNTPOINT}.*A0Mount point {#MOUNTPOINT}: used000system.vfs.used[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free000system.vfs.free[{#MOUNTPOINT}]73650603b0000100App-PostgresPro-LinuxMount point {#MOUNTPOINT}: free in percents000system.vfs.percent_free[{#MOUNTPOINT}]73650600%0000100App-PostgresPro-Linux{PostgresPro-Linux:system.vfs.percent_free[{#MOUNTPOINT}].last()}<10Free disk space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030Mount point overview: {#MOUNTPOINT}9002000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxsystem.vfs.used[{#MOUNTPOINT}]
100000CC020- PostgresPro-Linuxsystem.vfs.free[{#MOUNTPOINT}]
Block device discovery060000007system.disk.discovery{#BLOCKDEVICE}.*A0Block device {#BLOCKDEVICE}: utilization000system.disk.utilization[{#BLOCKDEVICE}]73650600%1000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: read operations000system.disk.read[{#BLOCKDEVICE}]736506001000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: write operations000system.disk.write[{#BLOCKDEVICE}]736506001000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: read byte/s000system.disk.read_b[{#BLOCKDEVICE}]73650600b1000100App-PostgresPro-LinuxBlock device {#BLOCKDEVICE}: write byte/s000system.disk.write_b[{#BLOCKDEVICE}]73650600b1000100App-PostgresPro-LinuxBlock device overview: {#BLOCKDEVICE} operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.read[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linuxsystem.disk.write[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Block device overview: {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.read_b[{#BLOCKDEVICE}]
100000CC020- PostgresPro-Linuxsystem.disk.write_b[{#BLOCKDEVICE}]
2000CC00120- PostgresPro-Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Net iface discovery060000007system.net.discovery{#NETDEVICE}.*A0Network device {#NETDEVICE}: RX bytes/s000system.net.rx_bytes[{#NETDEVICE}]73650600b1000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: RX errors/s000system.net.rx_errs[{#NETDEVICE}]736506001000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: RX drops/s000system.net.rx_drop[{#NETDEVICE}]736506001000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX bytes/s000system.net.tx_bytes[{#NETDEVICE}]73650600b1000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX errors/s000system.net.tx_errs[{#NETDEVICE}]736506001000100App-PostgresPro-LinuxNetwork device {#NETDEVICE}: TX drops/s000system.net.tx_drop[{#NETDEVICE}]736506001000100App-PostgresPro-LinuxNetwork device: {#NETDEVICE}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.net.rx_bytes[{#NETDEVICE}]
100000CC020- PostgresPro-Linuxsystem.net.tx_bytes[{#NETDEVICE}]
Pg_probackup discovery060000007pg_probackup.discovery[]{#BACKUPDIR}.*A0Pg_probackup dir {#BACKUPDIR}: size000pg_probackup.dir.size[{#BACKUPDIR}]736503003b0000100App-PostgresPro-LinuxPg_probackup dir {#BACKUPDIR}: error000pg_probackup.dir.error[{#BACKUPDIR}]7365030040000100App-PostgresPro-Linux{PostgresPro-Linux:pg_probackup.dir.error[{#BACKUPDIR}].str(ok)}<>1Error in pg_probackup dir {#BACKUPDIR} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030Pg_probackup: backup dir: {#BACKUPDIR} size9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpg_probackup.dir.size[{#BACKUPDIR}]
Relation size discovery060000007pgsql.relation.size[{$PG_CONNINFO},{$PG_PATH}]{#RELATIONNAME}.*A0Relation size: {#RELATIONNAME}000pgsql.relation.size[{#RELATIONNAME},{$PG_CONNINFO},{$PG_PATH}]736503003b0000100App-PostgresPro-LinuxPostgreSQL relation size: {#RELATIONNAME}9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.relation.size[{#RELATIONNAME},{$PG_CONNINFO},{$PG_PATH}]
Replication lag discovery060000007pgsql.replication.discovery[{$PG_CONNINFO},{$PG_PATH}]{#APPLICATION_NAME}.*A0Time elapsed between flushing recent WAL locally and receiving notification that this standby server {#APPLICATION_NAME} has written and flushed it000pgsql.replication.flush_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506040000100App-PostgresPro-LinuxTime elapsed between flushing recent WAL locally and receiving notification that this standby server {#APPLICATION_NAME} has written, flushed and applied000pgsql.replication.replay_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506040000100App-PostgresPro-LinuxTime elapsed between flushing recent WAL locally and receiving notification that this standby server {#APPLICATION_NAME} has written it000pgsql.replication.write_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506040000100App-PostgresPro-LinuxDelta of total lag for {#APPLICATION_NAME}000pgsql.replication.total_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100App-PostgresPro-LinuxDelta of total lag for {#APPLICATION_NAME}9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.replication.total_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]
- {$PG_CONNINFO}-qAt -p 5433 -U postgres {$PG_PATH}/opt/pgpro/std-10/bin/psql
-
-
- {PostgresPro-Linux:pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}].last()}>2PostgreSQL count files in ./archive_status on {HOSTNAME} more than 2030{PostgresPro-Linux:pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}].last()}>12PostgreSQL required checkpoints occurs to frequently on {HOSTNAME}030 {PostgresPro-Linux:pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}].last()}/{PostgresPro-Linux:pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}].last()}*100 >90PostgreSQL many connections on {HOSTNAME} (total connections more than 90% max connections)030{PostgresPro-Linux:mamonsu.plugin.keepalive.nodata(180)}=1Mamonsu nodata from {HOSTNAME}030{PostgresPro-Linux:pgsql.memory_leak_diagnostic.msg_text[].strlen()}>1PostgreSQL: number of pids which private anonymous memory exceeds private_anon_mem_threshold on {HOSTNAME}. {ITEM.LASTVALUE}030{PostgresPro-Linux:pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}].last()}>18000000PostgreSQL oldest xid is too big on {HOSTNAME}030{PostgresPro-Linux:pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}].last()}>18000PostgreSQL query running is too old on {HOSTNAME}030{PostgresPro-Linux:pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}].last()}<600PostgreSQL service was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}].last()}<80PostgreSQL cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.ping[{$PG_CONNINFO},{$PG_PATH}].nodata(180)}=1PostgreSQL no ping from PostgreSQL for 3 minutes {HOSTNAME} 030{PostgresPro-Linux:pgsql.prepared.oldest.last()}>60PostgreSQL prepared transaction is too old on {HOSTNAME}030{PostgresPro-Linux:system.processes.forkrate.min(5m)}>500Process fork-rate to frequently on {HOSTNAME}030{PostgresPro-Linux:system.up_time.last()}<300System was restarted on {HOSTNAME} (up_time={ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}].last()}>300PostgreSQL streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})030{PostgresPro-Linux:pgsql.replication.non_active_slots[{$PG_CONNINFO},{$PG_PATH}].last()}#0PostgreSQL number of non-active replication slots on {HOSTNAME} (value={ITEM.LASTVALUE})030
- PostgreSQL archive command archive_status 9002000.0100.0110100.00.0000000FF0000020- PostgresPro-Linuxpgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]
1000FF00120- PostgresPro-Linuxpgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL archive command trying_to_archive 9002000.0100.0110100.00.000000000F000020- PostgresPro-Linuxpgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]
10FF0000120- PostgresPro-Linuxpgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL bgwriter9002000.0100.0110100.00.0000000CCCC00120- PostgresPro-Linuxpgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]
100000CC120- PostgresPro-Linuxpgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]
20777777020- PostgresPro-Linuxpgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]
30CC0000120- PostgresPro-Linuxpgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]
40CC00CC020- PostgresPro-Linuxpgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]
5000CC00120- PostgresPro-Linuxpgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL checkpoints9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]
10CC0000020- PostgresPro-Linuxpgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]
200000CC120- PostgresPro-Linuxpgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]
30000000120- PostgresPro-Linuxpgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL connections9002000.0100.0110100.00.000000000BB00020- PostgresPro-Linuxpgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]
100000BB020- PostgresPro-Linuxpgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]
20CC00CC020- PostgresPro-Linuxpgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]
30CCCCCC020- PostgresPro-Linuxpgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]
40CCCC00020- PostgresPro-Linuxpgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]
5000CCCC020- PostgresPro-Linuxpgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]
60EEEEEE020- PostgresPro-Linuxpgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]
70BB0000020- PostgresPro-Linuxpgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]
8000BB00020- PostgresPro-Linuxpgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]
Block devices: read/write operations9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.all_read
100000CC020- PostgresPro-Linuxsystem.disk.all_write
Block devices: read/write bytes9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.disk.all_read_b
100000CC020- PostgresPro-Linuxsystem.disk.all_write_b
PostgreSQL instance: rate9002000.0100.0110100.00.00000000000CC120- PostgresPro-Linuxpgsql.transactions.total[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linuxpgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linuxpgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: events9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]
10000000020- PostgresPro-Linuxpgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linuxpgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]
3000FF00020- PostgresPro-Linuxpgsql.events.checksum_failures[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: temp files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]
100000CC120- PostgresPro-Linuxpgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL instance: tuples9002000.0100.0110100.00.0000000000000020- PostgresPro-Linuxpgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]
100000CC020- PostgresPro-Linuxpgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]
2000CC00020- PostgresPro-Linuxpgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]
30CC00CC120- PostgresPro-Linuxpgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]
40CC0000020- PostgresPro-Linuxpgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]
System load average9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.la.1
Memory overview9004000.0100.0111100.00.0000000CC0000020- PostgresPro-Linuxsystem.memory.apps
1000CC00020- PostgresPro-Linuxsystem.memory.buffers
200000CC020- PostgresPro-Linuxsystem.memory.swap
30CC00CC020- PostgresPro-Linuxsystem.memory.cached
40000000020- PostgresPro-Linuxsystem.memory.unused
50CCCC00020- PostgresPro-Linuxsystem.memory.slab
60777777020- PostgresPro-Linuxsystem.memory.swap_cache
70770000020- PostgresPro-Linuxsystem.memory.page_tables
80000077020- PostgresPro-Linuxsystem.memory.vmalloc_used
90007700020- PostgresPro-Linuxsystem.memory.committed
100DF0000020- PostgresPro-Linuxsystem.memory.mapped
11000DF00020- PostgresPro-Linuxsystem.memory.active
1200000DF020- PostgresPro-Linuxsystem.memory.inactive
PostgreSQL: number of pids which private anonymous memory exceeds private_anon_mem_threshold9002000.0100.0110100.00.0000000FF0000020- PostgresPro-Linuxpgsql.memory_leak_diagnostic.count_diff[]
PostgreSQL oldest transaction running time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL age of oldest xid9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL number of parallel queries being executed now9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.parallel.queries[{$PG_CONNINFO},{$PG_PATH}]
System: count of opened files9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.open_files
PostgreSQL: shared buffer9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]
10CC0000020- PostgresPro-Linuxpgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]
2000CC00020- PostgresPro-Linuxpgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL uptime9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxpgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]
10DF0101120- PostgresPro-Linuxpgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL locks sampling9002000.0100.0110100.00.00000000000CC020- PostgresPro-Linuxpgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linuxpgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]
20CC0000020- PostgresPro-Linuxpgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]
30CC00CC020- PostgresPro-Linuxpgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]
40777777020- PostgresPro-Linuxpgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]
50CCCCCC020- PostgresPro-Linuxpgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]
60CCCC00020- PostgresPro-Linuxpgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]
7000CCCC020- PostgresPro-Linuxpgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL statements: bytes9002000.0100.0110100.00.0000000BBBB00020- PostgresPro-Linuxpgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]
1000CC00020- PostgresPro-Linuxpgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]
200000CC020- PostgresPro-Linuxpgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL statements: spend time9002000.0100.0111100.00.000000000CC00020- PostgresPro-Linuxpgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]
100000CC020- PostgresPro-Linuxpgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]
20BBBB00020- PostgresPro-Linuxpgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL statements: wal statistics9002000.0100.0110100.00.0000000BCC000020- PostgresPro-Linuxpgsql.stat.wal_bytes[{$PG_CONNINFO},{$PG_PATH}]
10CC6600020- PostgresPro-Linuxpgsql.stat.wal_records[{$PG_CONNINFO},{$PG_PATH}]
2000CCCC020- PostgresPro-Linuxpgsql.stat.wal_fpi[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL prepared transaction9002000.0100.0110100.00.000000000BB00020- PostgresPro-Linuxpgsql.prepared.count
100000BB120- PostgresPro-Linuxpgsql.prepared.oldest
Processes overview9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxsystem.processes.running
1000CC00020- PostgresPro-Linuxsystem.processes.blocked
200000CC120- PostgresPro-Linuxsystem.processes.forkrate
CPU time spent9002000.0100.0111100.00.00000000000CC020- PostgresPro-Linuxsystem.cpu.user
10CC00CC020- PostgresPro-Linuxsystem.cpu.nice
20CC0000020- PostgresPro-Linuxsystem.cpu.system
3000CC00020- PostgresPro-Linuxsystem.cpu.idle
40CCCC00020- PostgresPro-Linuxsystem.cpu.iowait
50777777020- PostgresPro-Linuxsystem.cpu.irq
60000077020- PostgresPro-Linuxsystem.cpu.softirq
System up_time9002000.0100.0110100.00.000000000CC00020- PostgresPro-Linuxsystem.up_time
PostgreSQL write-ahead log generation speed9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL replication lag in second9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL count of xlog files9002000.0100.0110100.00.0000000CC0000020- PostgresPro-Linuxpgsql.wal.count[{$PG_CONNINFO},{$PG_PATH}]
-
\ No newline at end of file
diff --git a/packaging/conf/old_templates/template_3.5.1_agent.xml b/packaging/conf/old_templates/template_3.5.1_agent.xml
new file mode 100644
index 00000000..81d0fadb
--- /dev/null
+++ b/packaging/conf/old_templates/template_3.5.1_agent.xml
@@ -0,0 +1,32 @@
+
+
+ 3.0
+
+
+ Templates
+
+
+
+
+ Mamonsu PostgreSQL Linux
+ Mamonsu PostgreSQL Linux
+
+
+
+ Templates
+
+
+
+
+ Mamonsu PostgreSQL Linux
+
+
+ - PostgreSQL Archiver: Files in archive_status Need to Archive Count000pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Files Need to Archive Size000pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]73650153b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Archived Files Count000pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Attempts to Archive Files Count000pgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written During Checkpoints000pgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written000pgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Number of bgwriter Stopped by Max Write Count000pgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written Directly by a Backend000pgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Times a Backend Execute Its Own Fsync000pgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Allocated000pgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by Timeout (in hour)000pgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by WAL (in hour)000pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Write Time000pgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]73650150ms1000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Sync Time000pgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]73650150ms1000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Total User Connections000pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Waiting User Connections000pgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Max Connections000pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Active User Connections000pgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle User Connections000pgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction User Connections000pgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction (Aborted) User Connections000pgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Fastpath Function Call User Connections000pgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Disabled User Connections000pgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Other Connections000pgsql.connections.other[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Count of Autovacuum Workers000pgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- System: Block Devices Read Requests000system.disk.all_read736501501000100Mamonsu PostgreSQL Linux
- System: Block Devices Write Requests000system.disk.all_write736501501000100Mamonsu PostgreSQL Linux
- System: Block Devices Read byte/s000system.disk.all_read_b736501501000100Mamonsu PostgreSQL Linux
- System: Block Devices Write byte/s000system.disk.all_write_b736501501000100Mamonsu PostgreSQL Linux
- Mamonsu: Plugin Keep Alive000mamonsu.plugin.keepalive736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Transactions Committed000pgsql.transactions.committed[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Rollback Events000pgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Hit000pgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Read000pgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Conflict Events000pgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]736501502000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Deadlock Events000pgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]736501502000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Bytes Written000pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]73650150b2000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Files Created000pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]736501502000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Deleted000pgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Fetched000pgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Inserted000pgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Returned000pgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Updated000pgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: checksum_failures Events000pgsql.events.checksum_failures[{$PG_CONNINFO},{$PG_PATH}]736501502000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- System: Load Average Over 1 Minute000system.la.1736501500000100Mamonsu PostgreSQL Linux
- System: Active - Memory Recently Used000system.memory.active73650153b0000100Mamonsu PostgreSQL Linux
- System: Available - Free Memory000system.memory.available73650153b0000100Mamonsu PostgreSQL Linux
- System: Buffers - Block Device Cache and Dirty000system.memory.buffers73650153b0000100Mamonsu PostgreSQL Linux
- System: Cached - Parked File Data (file content) Cache000system.memory.cached73650153b0000100Mamonsu PostgreSQL Linux
- System: Committed AS - Total Committed Memory000system.memory.committed73650153b0000100Mamonsu PostgreSQL Linux
- System: Inactive - Memory Not Currently Used000system.memory.inactive73650153b0000100Mamonsu PostgreSQL Linux
- System: Mapped - All mmap()ed Pages000system.memory.mapped73650153b0000100Mamonsu PostgreSQL Linux
- System: PageTables - Map bt Virtual and Physical000system.memory.page_tables73650153b0000100Mamonsu PostgreSQL Linux
- System: Slab - Kernel Used Memory (inode cache)000system.memory.slab73650153b0000100Mamonsu PostgreSQL Linux
- System: Swap - Swap Space Used000system.memory.swap73650153b0000100Mamonsu PostgreSQL Linux
- System: SwapCached - Fetched unmod Yet Swap Pages000system.memory.swap_cache73650153b0000100Mamonsu PostgreSQL Linux
- System: Total - All Memory000system.memory.total73650153b0000100Mamonsu PostgreSQL Linux
- System: Unused - Wasted Memory000system.memory.unused73650153b0000100Mamonsu PostgreSQL Linux
- System: Used - User-Space Applications000system.memory.used73650153b0000100Mamonsu PostgreSQL Linux
- System: VMallocUsed - vmaloc() Allocated by Kernel000system.memory.vmalloc_used73650153b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold000pgsql.memory_leak_diagnostic.count_diff[]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold, text of message000pgsql.memory_leak_diagnostic.msg_text[]736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Age of the Oldest XID000pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: the Oldest Transaction Running Time in sec000pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}]73650150s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Number of Parallel Queries Being Executed Now000pgsql.parallel.queries[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- System: Opened Files000system.open_files736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Size000pgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]73650150b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Twice Used Size000pgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]73650150b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Dirty Size000pgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]73650150b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Ping000pgsql.ping[{$PG_CONNINFO},{$PG_PATH}]7365050ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Cache Hit Ratio1500pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]73650600%00001last(pgsql.blocks[hit])*100/(last(pgsql.blocks[hit])+last(pgsql.blocks[read]))00Mamonsu PostgreSQL Linux
- PostgreSQL Health: Service Uptime000pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]7365050unixtime0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Server Version000pgsql.version[{$PG_CONNINFO},{$PG_PATH}]73650540000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Read Only Queries000pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: SELECT FOR SHARE and SELECT FOR UPDATE000pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Write Queries000pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY000pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: CREATE INDEX000pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application000pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application or Some Operations on System Catalogs000pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE000pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: Number of Prepared Transactions000pgsql.prepared.count736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: the Oldest Prepared Transaction Running Time in sec000pgsql.prepared.oldest736501500000100Mamonsu PostgreSQL Linux
- System: Processes in State Running000system.processes.running736501500000100Mamonsu PostgreSQL Linux
- System: Processes in State Blocked000system.processes.blocked736501500000100Mamonsu PostgreSQL Linux
- System: Processes Forkrate000system.processes.forkrate736501501000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by Normal Programs and Daemons000system.cpu.user736501501000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by nice(1)d Programs000system.cpu.nice736501501000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by the Kernel in System Activities000system.cpu.system736501501000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Idle000system.cpu.idle736501501000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Waiting for I/O Operations000system.cpu.iowait736501501000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Interrupts000system.cpu.irq736501501000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Batched Interrupts000system.cpu.softirq736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Streaming Replication Lag000pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Count Non-Active Replication Slots000pgsql.replication.non_active_slots[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read bytes/s000pgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]73650150Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write bytes/s000pgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]73650150Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Dirty bytes/s000pgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]73650150Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read IO Time000pgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]73650150s1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write IO Time000pgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]73650150s1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Other (mostly CPU) Time000pgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]73650150s1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Files000pgsql.stat.wal_bytes[{$PG_CONNINFO},{$PG_PATH}]73650150Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Records000pgsql.stat.wal_records[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Full Page Writes000pgsql.stat.wal_fpi[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Nnumber of Times pg_stat_statements.max Was Exceeded000pgsql.stat_info.dealloc[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Last Statistics Reset Time000pgsql.stat_info.stats_reset[{$PG_CONNINFO},{$PG_PATH}]73650150unixtime1000100Mamonsu PostgreSQL Linux
- System: Uptime000system.uptime73650153uptime0000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Speed000pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Count of WAL Files000pgsql.wal.count[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Records Generated000pgsql.wal.records.count[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Full Page Images Generated000pgsql.wal.fpi.count[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Buffers Full000pgsql.wal.buffers_full736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Time (ms)000pgsql.wal.write_time736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Time (ms)000pgsql.wal.sync_time736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Duty (%)1500pgsql.wal.sync_duty73650600%00001last(pgsql.wal.sync_time)/1000Mamonsu PostgreSQL Linux
+ PostgreSQL Databases Discovery060000007pgsql.database.discovery[{$PG_CONNINFO},{$PG_PATH}]{#DATABASE}.*8A0PostgreSQL Databases {#DATABASE}: size000pgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]73650153b0000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Max datfrozenxid Age in: {#DATABASE}000pgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Bloating Tables in {#DATABASE}000pgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Invalid Indexes in {#DATABASE}000pgsql.database.invalid_indexes[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pgsql.database.invalid_indexes[{#DATABASE}].last()}>0PostgreSQL Databases: invalid indexes in {#DATABASE} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030PostgreSQL Databases: {#DATABASE} size9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Databases: {#DATABASE} Bloating Overview9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Databases: {#DATABASE} Max age(datfrozenxid)9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
VFS Discovery060000007system.vfs.discovery{#MOUNTPOINT}.*8A0System: Mount Point {#MOUNTPOINT} Used000system.vfs.used[{#MOUNTPOINT}]73650153b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free000system.vfs.free[{#MOUNTPOINT}]73650153b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free in Percents000system.vfs.percent_free[{#MOUNTPOINT}]73650150%0000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:system.vfs.percent_free[{#MOUNTPOINT}].last()}<10Free disk space less than 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030System: Mount Point Overview {#MOUNTPOINT}9002000.0100.0111100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxsystem.vfs.used[{#MOUNTPOINT}]
1200CC00020- Mamonsu PostgreSQL Linuxsystem.vfs.free[{#MOUNTPOINT}]
System: Block Devices Discovery060000007system.disk.discovery{#BLOCKDEVICE}.*8A0System: Block Device {#BLOCKDEVICE} Utilization000system.disk.utilization[{#BLOCKDEVICE}]73650150%1000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read Operations000system.disk.read[{#BLOCKDEVICE}]736501501000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write Operations000system.disk.write[{#BLOCKDEVICE}]736501501000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read byte/s000system.disk.read_b[{#BLOCKDEVICE}]73650150b1000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write byte/s000system.disk.write_b[{#BLOCKDEVICE}]73650150b1000100Mamonsu PostgreSQL LinuxSystem: Block Device Overview {#BLOCKDEVICE} operations9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.read[{#BLOCKDEVICE}]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.write[{#BLOCKDEVICE}]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
System: Block Device Overview {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.read_b[{#BLOCKDEVICE}]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.write_b[{#BLOCKDEVICE}]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Net Iface Discovery060000007system.net.discovery{#NETDEVICE}.*8A0System: Network Device {#NETDEVICE} RX bytes/s000system.net.rx_bytes[{#NETDEVICE}]73650150b1000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX errors/s000system.net.rx_errs[{#NETDEVICE}]736501501000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX drops/s000system.net.rx_drop[{#NETDEVICE}]736501501000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX bytes/s000system.net.tx_bytes[{#NETDEVICE}]73650150b1000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX errors/s000system.net.tx_errs[{#NETDEVICE}]736501501000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX drops/s000system.net.tx_drop[{#NETDEVICE}]736501501000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE}9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxsystem.net.rx_bytes[{#NETDEVICE}]
12793F5D020- Mamonsu PostgreSQL Linuxsystem.net.tx_bytes[{#NETDEVICE}]
pg_probackup discovery060000007pg_probackup.discovery[]{#BACKUPDIR}.*8A0pg_probackup dir {#BACKUPDIR}: size000pg_probackup.dir.size[{#BACKUPDIR}]736503003b0000100Mamonsu PostgreSQL Linuxpg_probackup dir {#BACKUPDIR}: error000pg_probackup.dir.error[{#BACKUPDIR}]7365030040000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pg_probackup.dir.error[{#BACKUPDIR}].str(ok)}<>1Error in pg_probackup dir {#BACKUPDIR} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030pg_probackup backup dir: {#BACKUPDIR} size9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpg_probackup.dir.size[{#BACKUPDIR}]
PostgreSQL Relations Sizes Discovery060000007pgsql.relation.size[{$PG_CONNINFO},{$PG_PATH}]{#RELATIONNAME}.*8A0PostgreSQL Relation Size: {#RELATIONNAME}000pgsql.relation.size[{#RELATIONNAME},{$PG_CONNINFO},{$PG_PATH}]73650153b0000100Mamonsu PostgreSQL LinuxPostgreSQL Relation Size: {#RELATIONNAME}9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.relation.size[{#RELATIONNAME},{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Replication Lag Discovery060000007pgsql.replication.discovery[{$PG_CONNINFO},{$PG_PATH}]{#APPLICATION_NAME}.*8A0PostgreSQL Replication: {#APPLICATION_NAME} Send Lag - Time elapsed sending recent WAL locally000pgsql.replication.send_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Receive Lag - Time elapsed between receiving recent WAL locally and receiving notification that this standby server has flushed it000pgsql.replication.receive_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Write Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written it000pgsql.replication.write_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Flush Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written and flushed it000pgsql.replication.flush_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Replay Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written, flushed and applied000pgsql.replication.replay_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Delta of Total Lag000pgsql.replication.total_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: Delta of Total Lag for {#APPLICATION_NAME}9002000.0100.0110100.00.0000000A39B98020- Mamonsu PostgreSQL Linuxpgsql.replication.total_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]
+ Mamonsu Overview2505001500011010003PostgreSQL Connections: OverviewMamonsu PostgreSQL Linux05001501011010003PostgreSQL Instance: Transactions RateMamonsu PostgreSQL Linux05001500111010003System: CPU Time SpentMamonsu PostgreSQL Linux05001501111010003System: Server Free/Used Memory OverviewMamonsu PostgreSQL Linux05001500211010003PostgreSQL Autovacuum: Count of Autovacuum WorkersMamonsu PostgreSQL Linux05001501211010003PostgreSQL Instance: TuplesMamonsu PostgreSQL Linux05001500311010003PostgreSQL bgwriter: BuffersMamonsu PostgreSQL Linux05001501311010003PostgreSQL bgwriter: EventsMamonsu PostgreSQL Linux05001500411010003PostgreSQL Checkpoints: Count (in hour)Mamonsu PostgreSQL Linux05001501411010003PostgreSQL Checkpoints: Write/SyncMamonsu PostgreSQL LinuxMamonsu PostgreSQL Instance2515001500011010003pgsql.ping[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501011010003pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500111010003pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux05001501111010003PostgreSQL Instance: EventsMamonsu PostgreSQL Linux15001500211010003pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501211010003pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL WAL2505001500011010003PostgreSQL Archiver: Archive StatusMamonsu PostgreSQL Linux15001501011010003pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500111010003pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501111010003pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500211010003pgsql.wal.write_timeMamonsu PostgreSQL Linux15001501211010003pgsql.wal.sync_timeMamonsu PostgreSQL LinuxMamonsu PostgreSQL Locks3513301000011010003pgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301001011010003pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301002011010003pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301000111010003pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301001111010003pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301002111010003pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301000211010003pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301001211010003pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301002211010003pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL Transactions2515001500011010003pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501011010003pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500111010003pgsql.prepared.countMamonsu PostgreSQL Linux15001501111010003pgsql.prepared.oldestMamonsu PostgreSQL LinuxMamonsu System (Linux)2505001500011010003System: Block Devices Read/Write BytesMamonsu PostgreSQL Linux05001501011010003System: Block Devices Read/Write OperationsMamonsu PostgreSQL Linux05001500111010003System: Processes OverviewMamonsu PostgreSQL Linux
+ {$PG_CONNINFO}-qAt -p 5433 -U postgres {$PG_PATH}/opt/pgpro/std-10/bin/psql
+
+
+ {Mamonsu PostgreSQL Linux:pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}].last()}>2PostgreSQL Archiver: count files need to archive on {HOSTNAME} more than 2030{Mamonsu PostgreSQL Linux:pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}].last()}>12PostgreSQL Checkpoints: required checkpoints occurs too frequently on {HOSTNAME}030 {Mamonsu PostgreSQL Linux:pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}].last()}/{Mamonsu PostgreSQL Linux:pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}].last()}*100 >90PostgreSQL Connections: too many connections on {HOSTNAME} (total connections more than 90% of max_connections)030{Mamonsu PostgreSQL Linux:mamonsu.plugin.keepalive.nodata(180)}=1Mamonsu nodata from {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.server_mode.change()}>0PostgreSQL Instance: server mode has been changed on {HOSTNAME} to {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.memory_leak_diagnostic.msg_text[].strlen()}>1PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold on {HOSTNAME}. {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}].last()}>18000000PostgreSQL Transactions: the oldest XID is too big on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}].last()}>18000PostgreSQL Transactions: running transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}].change()}>600PostgreSQL Health: service has been restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}].last()}<80PostgreSQL Health: cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.ping[{$PG_CONNINFO},{$PG_PATH}].nodata(180)}=1PostgreSQL Health: no ping from PostgreSQL for 3 minutes on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.prepared.oldest.last()}>60PostgreSQL Prepared Transactions: prepared transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:system.processes.forkrate.min(5m)}>500Process fork-rate too frequently on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}].last()}>300PostgreSQL streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.replication.non_active_slots[{$PG_CONNINFO},{$PG_PATH}].last()}>0PostgreSQL number of non-active replication slots on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:system.uptime.last()}<300System was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030
+ PostgreSQL Archiver: Archive Status9002000.0100.0110100.00.0000002006AAE020- Mamonsu PostgreSQL Linuxpgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL bgwriter: Buffers9002000.0100.0110100.00.0000002006AAE020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]
32FF5656020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL bgwriter: Events9002000.0100.0110100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Checkpoints: Count (in hour)9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Checkpoints: Write/Sync9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Connections: Overview9002000.0100.0111100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]
12A39B98020- Mamonsu PostgreSQL Linuxpgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]
4200B0B8020- Mamonsu PostgreSQL Linuxpgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]
523B415A020- Mamonsu PostgreSQL Linuxpgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]
62FF5656020- Mamonsu PostgreSQL Linuxpgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]
72006AAE020- Mamonsu PostgreSQL Linuxpgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]
8287C2B9020- Mamonsu PostgreSQL Linuxpgsql.connections.other[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Autovacuum: Count of Autovacuum Workers9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
System: Block Devices Read/Write Operations9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.all_read
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.all_write
System: Block Devices Read/Write Bytes9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.all_read_b
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.all_write_b
PostgreSQL Instance: Blocks Rate9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Transactions Rate9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.transactions.committed[{$PG_CONNINFO},{$PG_PATH}]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Events9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]
22006AAE020- Mamonsu PostgreSQL Linuxpgsql.events.checksum_failures[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Temp Files9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]
12006AAE120- Mamonsu PostgreSQL Linuxpgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Tuples9002000.0100.0110100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxpgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]
2200CC00020- Mamonsu PostgreSQL Linuxpgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]
32001219120- Mamonsu PostgreSQL Linuxpgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]
429C8A4E020- Mamonsu PostgreSQL Linuxpgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]
System: Server Memory Detailed Overview9004000.0100.0111100.00.0000000BAEB6B020- Mamonsu PostgreSQL Linuxsystem.memory.active
1000CC00020- Mamonsu PostgreSQL Linuxsystem.memory.available
2000B0B8020- Mamonsu PostgreSQL Linuxsystem.memory.buffers
3052768F020- Mamonsu PostgreSQL Linuxsystem.memory.cached
409C8A4E020- Mamonsu PostgreSQL Linuxsystem.memory.committed
50A39B98020- Mamonsu PostgreSQL Linuxsystem.memory.inactive
609F1E28020- Mamonsu PostgreSQL Linuxsystem.memory.mapped
70793F5D020- Mamonsu PostgreSQL Linuxsystem.memory.page_tables
80F6CB93020- Mamonsu PostgreSQL Linuxsystem.memory.slab
90006AAE020- Mamonsu PostgreSQL Linuxsystem.memory.swap
10087C2B9020- Mamonsu PostgreSQL Linuxsystem.memory.swap_cache
1103B415A020- Mamonsu PostgreSQL Linuxsystem.memory.unused
120001219020- Mamonsu PostgreSQL Linuxsystem.memory.used
130CF6518020- Mamonsu PostgreSQL Linuxsystem.memory.vmalloc_used
System: Server Free/Used Memory Overview9004000.0100.0110100.00.0000001001219020- Mamonsu PostgreSQL Linuxsystem.memory.used
1152768F020- Mamonsu PostgreSQL Linuxsystem.memory.cached
2100CC00020- Mamonsu PostgreSQL Linuxsystem.memory.available
34FF5656020- Mamonsu PostgreSQL Linuxsystem.memory.total
PostgreSQL pg_buffercache: Shared Buffer9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL: Locks Sampling9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]
42006AAE020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]
5200B0B8020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]
629C8A4E020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]
72793F5D020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Prepared Transactions: Overview9002000.0100.0110100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.prepared.count
129C8A4E120- Mamonsu PostgreSQL Linuxpgsql.prepared.oldest
System: Processes Overview9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.processes.running
12FF5656020- Mamonsu PostgreSQL Linuxsystem.processes.blocked
22006AAE120- Mamonsu PostgreSQL Linuxsystem.processes.forkrate
System: CPU Time Spent9002000.0100.0111100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.cpu.user
12793F5D020- Mamonsu PostgreSQL Linuxsystem.cpu.nice
229C8A4E020- Mamonsu PostgreSQL Linuxsystem.cpu.system
32A39B98020- Mamonsu PostgreSQL Linuxsystem.cpu.idle
42006AAE020- Mamonsu PostgreSQL Linuxsystem.cpu.iowait
52FF5656020- Mamonsu PostgreSQL Linuxsystem.cpu.irq
62F6CB93020- Mamonsu PostgreSQL Linuxsystem.cpu.softirq
PostgreSQL Statements: Bytes9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Statements: Spent Time9002000.0100.0111100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Statements: WAL Statistics9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.stat.wal_bytes[{$PG_CONNINFO},{$PG_PATH}]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.stat.wal_records[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat.wal_fpi[{$PG_CONNINFO},{$PG_PATH}]
+
\ No newline at end of file
diff --git a/packaging/conf/old_templates/template_3.5.1_linux.xml b/packaging/conf/old_templates/template_3.5.1_linux.xml
new file mode 100644
index 00000000..dce07f0b
--- /dev/null
+++ b/packaging/conf/old_templates/template_3.5.1_linux.xml
@@ -0,0 +1,32 @@
+
+
+ 3.0
+
+
+ Templates
+
+
+
+
+ Mamonsu PostgreSQL Linux
+ Mamonsu PostgreSQL Linux
+
+
+
+ Templates
+
+
+
+
+ Mamonsu PostgreSQL Linux
+
+
+ - PostgreSQL Archiver: Files in archive_status Need to Archive Count200pgsql.archive_command[count_files_to_archive]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Files Need to Archive Size200pgsql.archive_command[size_files_to_archive]73650153b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Archived Files Count200pgsql.archive_command[archived_files]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Attempts to Archive Files Count200pgsql.archive_command[failed_trying_to_archive]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written During Checkpoints200pgsql.bgwriter[buffers_checkpoint]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written200pgsql.bgwriter[buffers_clean]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Number of bgwriter Stopped by Max Write Count200pgsql.bgwriter[maxwritten_clean]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written Directly by a Backend200pgsql.bgwriter[buffers_backend]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Times a Backend Execute Its Own Fsync200pgsql.bgwriter[buffers_backend_fsync]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Allocated200pgsql.bgwriter[buffers_alloc]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Written byte/s200pgsql.cfs.activity[written_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Scanned byte/s200pgsql.cfs.activity[scanned_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Compressed Files200pgsql.cfs.activity[compressed_files]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Scanned Files200pgsql.cfs.activity[scanned_files]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Current Ratio200pgsql.cfs.activity[current_compress_ratio]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Total Ratio200pgsql.cfs.activity[total_compress_ratio]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by Timeout (in hour)200pgsql.checkpoint[count_timed]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by WAL (in hour)200pgsql.checkpoint[count_wal]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Write Time200pgsql.checkpoint[write_time]73650150ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Sync Time200pgsql.checkpoint[checkpoint_sync_time]73650150ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Total User Connections200pgsql.connections[total]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Waiting User Connections200pgsql.connections[waiting]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Max Connections200pgsql.connections[max_connections]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Active User Connections200pgsql.connections[active]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle User Connections200pgsql.connections[idle]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction User Connections200pgsql.connections[idle_in_transaction]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction (Aborted) User Connections200pgsql.connections[idle_in_transaction_aborted]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Fastpath Function Call User Connections200pgsql.connections[fastpath_function_call]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Disabled User Connections200pgsql.connections[disabled]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Other Connections200pgsql.connections[other]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Count of Autovacuum Workers200pgsql.autovacumm.count[]736501500000100Mamonsu PostgreSQL Linux
- System: Block Devices Read Requests200system.disk.all_read[]736501500000100Mamonsu PostgreSQL Linux
- System: Block Devices Write Requests200system.disk.all_write[]736501500000100Mamonsu PostgreSQL Linux
- System: Block Devices Read byte/s200system.disk.all_read_b[]736501500000100Mamonsu PostgreSQL Linux
- System: Block Devices Write byte/s200system.disk.all_write_b[]736501500000100Mamonsu PostgreSQL Linux
- Mamonsu: Plugin Errors200mamonsu.plugin.errors[]736506040000100Mamonsu PostgreSQL Linux
- Mamonsu: Plugin Keep Alive200mamonsu.plugin.keepalive[]736506000000100Mamonsu PostgreSQL Linux
- Mamonsu: RSS Memory Max Usage200mamonsu.memory.rss[max]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Transactions Committed200pgsql.transactions[committed]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Rollback Events200pgsql.events[xact_rollback]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Hit200pgsql.blocks[hit]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Read200pgsql.blocks[read]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Conflict Events200pgsql.events[conflicts]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Deadlock Events200pgsql.events[deadlocks]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Bytes Written200pgsql.temp[bytes]73650150b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Files Created200pgsql.temp[files]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Deleted200pgsql.tuples[deleted]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Fetched200pgsql.tuples[fetched]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Inserted200pgsql.tuples[inserted]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Returned200pgsql.tuples[returned]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Updated200pgsql.tuples[updated]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: checksum_failures Events200pgsql.events[checksum_failures]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- System: Load Average Over 1 Minute200system.la[1]736501500000100Mamonsu PostgreSQL Linux
- System: Active - Memory Recently Used200system.memory[active]73650153b0000100Mamonsu PostgreSQL Linux
- System: Available - Free Memory200system.memory[available]73650153b0000100Mamonsu PostgreSQL Linux
- System: Buffers - Block Device Cache and Dirty200system.memory[buffers]73650153b0000100Mamonsu PostgreSQL Linux
- System: Cached - Parked File Data (file content) Cache200system.memory[cached]73650153b0000100Mamonsu PostgreSQL Linux
- System: Committed AS - Total Committed Memory200system.memory[committed]73650153b0000100Mamonsu PostgreSQL Linux
- System: Inactive - Memory Not Currently Used200system.memory[inactive]73650153b0000100Mamonsu PostgreSQL Linux
- System: Mapped - All mmap()ed Pages200system.memory[mapped]73650153b0000100Mamonsu PostgreSQL Linux
- System: PageTables - Map bt Virtual and Physical200system.memory[page_tables]73650153b0000100Mamonsu PostgreSQL Linux
- System: Slab - Kernel Used Memory (inode cache)200system.memory[slab]73650153b0000100Mamonsu PostgreSQL Linux
- System: Swap - Swap Space Used200system.memory[swap]73650153b0000100Mamonsu PostgreSQL Linux
- System: SwapCached - Fetched unmod Yet Swap Pages200system.memory[swap_cache]73650153b0000100Mamonsu PostgreSQL Linux
- System: Total - All Memory200system.memory[total]73650153b0000100Mamonsu PostgreSQL Linux
- System: Unused - Wasted Memory200system.memory[unused]73650153b0000100Mamonsu PostgreSQL Linux
- System: Used - User-Space Applications200system.memory[used]73650153b0000100Mamonsu PostgreSQL Linux
- System: VMallocUsed - vmaloc() Allocated by Kernel200system.memory[vmalloc_used]73650153b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold200pgsql.memory_leak_diagnostic.count_diff[]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold, text of message200pgsql.memory_leak_diagnostic.msg_text[]736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Age of the Oldest XID200pgsql.oldest[xid_age]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: the Oldest Transaction Running Time in sec200pgsql.oldest[transaction_time]73650150s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Number of Parallel Queries Being Executed Now200pgsql.parallel[queries]736501530000100Mamonsu PostgreSQL Linux
- System: Opened Files200system.open_files[]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Size200pgsql.buffers[size]73650150b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Twice Used Size200pgsql.buffers[twice_used]73650150b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Dirty Size200pgsql.buffers[dirty]73650150b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Ping200pgsql.ping[]73650150ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Cache Hit Ratio1500pgsql.cache[hit]73650600%00001last(pgsql.blocks[hit])*100/(last(pgsql.blocks[hit])+last(pgsql.blocks[read]))00Mamonsu PostgreSQL Linux
- PostgreSQL Health: Service Uptime200pgsql.uptime[]73650153unixtime0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Server Version200pgsql.version[]736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Read Only Queries200pgsql.pg_locks[accessshare]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: SELECT FOR SHARE and SELECT FOR UPDATE200pgsql.pg_locks[rowshare]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Write Queries200pgsql.pg_locks[rowexclusive]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY200pgsql.pg_locks[shareupdateexclusive]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: CREATE INDEX200pgsql.pg_locks[share]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application200pgsql.pg_locks[sharerowexclusive]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application or Some Operations on System Catalogs200pgsql.pg_locks[exclusive]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE200pgsql.pg_locks[accessexclusive]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: Number of Prepared Transactions200pgsql.prepared.count736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: the Oldest Prepared Transaction Running Time in sec200pgsql.prepared.oldest736501500000100Mamonsu PostgreSQL Linux
- System: Processes in State Running200system.processes[running]736501500000100Mamonsu PostgreSQL Linux
- System: Processes in State Blocked200system.processes[blocked]736501500000100Mamonsu PostgreSQL Linux
- System: Processes Forkrate200system.processes[forkrate]736501500000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by Normal Programs and Daemons200system.cpu[user]736501500000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by nice(1)d Programs200system.cpu[nice]736501500000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by the Kernel in System Activities200system.cpu[system]736501500000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Idle200system.cpu[idle]736501500000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Waiting for I/O Operations200system.cpu[iowait]736501500000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Interrupts200system.cpu[irq]736501500000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Batched Interrupts200system.cpu[softirq]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Streaming Replication Lag200pgsql.replication_lag[sec]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Count Non-Active Replication Slots200pgsql.replication.non_active_slots[]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read bytes/s200pgsql.stat[read_bytes]73650150Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write bytes/s200pgsql.stat[write_bytes]73650150Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Dirty bytes/s200pgsql.stat[dirty_bytes]73650150Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read IO Time200pgsql.stat[read_time]73650150s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write IO Time200pgsql.stat[write_time]73650150s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Other (mostly CPU) Time200pgsql.stat[other_time]73650150s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Files200pgsql.stat[wal_bytes]73650150Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Records200pgsql.stat[wal_records]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Full Page Writes200pgsql.stat[wal_fpi]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Nnumber of Times pg_stat_statements.max Was Exceeded200pgsql.stat_info[dealloc]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Last Statistics Reset Time200pgsql.stat_info[stats_reset]73650150unixtime0000100Mamonsu PostgreSQL Linux
- System: Uptime200system.uptime[]73650153uptime0000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Lightweight Locks200pgsql.all_lock[lwlock]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Heavyweight Locks200pgsql.all_lock[hwlock]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Buffer Locks200pgsql.all_lock[buffer]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Extension Locks200pgsql.all_lock[extension]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Client Locks200pgsql.all_lock[client]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Other Locks (e.g. IPC, Timeout, IO)200pgsql.all_lock[other]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: XID Access Locks200pgsql.lwlock[xid]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Autovacuum Locks200pgsql.lwlock[autovacuum]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: WAL Access Locks200pgsql.lwlock[wal]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: CLOG Access Locks200pgsql.lwlock[clog]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Replication Locks200pgsql.lwlock[replication]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Logical Replication Locks200pgsql.lwlock[logical_replication]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Buffer Operations Locks200pgsql.lwlock[buffer]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Other Operations Lightweight Locks200pgsql.lwlock[other]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Relation200pgsql.hwlock[relation]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Extend a Relation Locks200pgsql.hwlock[extend]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Page200pgsql.hwlock[page]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Tuple200pgsql.hwlock[tuple]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Transaction to Finish Locks200pgsql.hwlock[transactionid]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Virtual XID Locks200pgsql.hwlock[virtualxid]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Speculative Insertion Locks200pgsql.hwlock[speculative_token]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on Database Object200pgsql.hwlock[object]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Userlocks200pgsql.hwlock[userlock]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Advisory User Locks200pgsql.hwlock[advisory]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Speed200pgsql.wal.write[]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Count of WAL Files200pgsql.wal.count[]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Records Generated200pgsql.wal.records.count[]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Full Page Images Generated200pgsql.wal.fpi.count[]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Buffers Full200pgsql.wal.buffers_full736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Time (ms)200pgsql.wal.write_time736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Time (ms)200pgsql.wal.sync_time736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Duty (%)1500pgsql.wal.sync_duty73650600%00001last(pgsql.wal.sync_time)/1000Mamonsu PostgreSQL Linux
+ PostgreSQL CFS Discovery260000007pgsql.cfs.discovery_compressed_relations[]{#COMPRESSED_RELATION}.*8A0PostgreSQL CFS: Relation {#COMPRESSED_RELATION} Compress Ratio200pgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]7365060000000100Mamonsu PostgreSQL LinuxPostgreSQL CFS: Relation {#COMPRESSED_RELATION} Compress Ratio9002000.0100.0110100.00.0000000A39B98020- Mamonsu PostgreSQL Linuxpgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]
PostgreSQL Databases Discovery260000007pgsql.database.discovery[]{#DATABASE}.*8A0PostgreSQL Databases {#DATABASE}: size200pgsql.database.size[{#DATABASE}]73650153b0000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Max datfrozenxid Age in: {#DATABASE}200pgsql.database.max_age[{#DATABASE}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Bloating Tables in {#DATABASE}200pgsql.database.bloating_tables[{#DATABASE}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Invalid Indexes in {#DATABASE}200pgsql.database.invalid_indexes[{#DATABASE}]736501500000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pgsql.database.invalid_indexes[{#DATABASE}].last()}>0PostgreSQL Databases: invalid indexes in {#DATABASE} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030PostgreSQL Databases: {#DATABASE} size9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.database.size[{#DATABASE}]
PostgreSQL Databases: {#DATABASE} Bloating Overview9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.database.bloating_tables[{#DATABASE}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacumm.count[]
PostgreSQL Databases: {#DATABASE} Max age(datfrozenxid)9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.database.max_age[{#DATABASE}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacumm.count[]
VFS Discovery260000007system.vfs.discovery[]{#MOUNTPOINT}.*8A0System: Mount Point {#MOUNTPOINT} Used200system.vfs.used[{#MOUNTPOINT}]73650153b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free200system.vfs.free[{#MOUNTPOINT}]73650153b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free in Percents200system.vfs.percent_free[{#MOUNTPOINT}]73650150%0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free Inodes in Percent200system.vfs.percent_inode_free[{#MOUNTPOINT}]73650150%0000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:system.vfs.percent_free[{#MOUNTPOINT}].last()}<10Free disk space less than 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:system.vfs.percent_inode_free[{#MOUNTPOINT}].last()}<10Free inode space less than 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030System: Mount Point Overview {#MOUNTPOINT}9002000.0100.0111100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxsystem.vfs.used[{#MOUNTPOINT}]
1200CC00020- Mamonsu PostgreSQL Linuxsystem.vfs.free[{#MOUNTPOINT}]
System: Block Devices Discovery260000007system.disk.discovery[]{#BLOCKDEVICE}.*8A0System: Block Device {#BLOCKDEVICE} Utilization200system.disk.utilization[{#BLOCKDEVICE}]73650150%0000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read Operations200system.disk.read[{#BLOCKDEVICE}]736501500000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write Operations200system.disk.write[{#BLOCKDEVICE}]736501500000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read byte/s200system.disk.read_b[{#BLOCKDEVICE}]73650150b0000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write byte/s200system.disk.write_b[{#BLOCKDEVICE}]73650150b0000100Mamonsu PostgreSQL LinuxSystem: Block Device Overview {#BLOCKDEVICE} operations9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.read[{#BLOCKDEVICE}]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.write[{#BLOCKDEVICE}]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
System: Block Device Overview {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.read_b[{#BLOCKDEVICE}]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.write_b[{#BLOCKDEVICE}]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Net Iface Discovery260000007system.net.discovery[]{#NETDEVICE}.*8A0System: Network Device {#NETDEVICE} RX bytes/s200system.net.rx_bytes[{#NETDEVICE}]73650150b0000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX errors/s200system.net.rx_errs[{#NETDEVICE}]736501500000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX drops/s200system.net.rx_drop[{#NETDEVICE}]736501500000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX bytes/s200system.net.tx_bytes[{#NETDEVICE}]73650150b0000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX errors/s200system.net.tx_errs[{#NETDEVICE}]736501500000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX drops/s200system.net.tx_drop[{#NETDEVICE}]736501500000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE}9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxsystem.net.rx_bytes[{#NETDEVICE}]
12793F5D020- Mamonsu PostgreSQL Linuxsystem.net.tx_bytes[{#NETDEVICE}]
pg_probackup discovery260000007pg_probackup.discovery[]{#BACKUPDIR}.*8A0pg_probackup dir {#BACKUPDIR}: size200pg_probackup.dir.size[{#BACKUPDIR}]736503003b0000100Mamonsu PostgreSQL Linuxpg_probackup dir {#BACKUPDIR}: error200pg_probackup.dir.error[{#BACKUPDIR}]7365030040000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pg_probackup.dir.error[{#BACKUPDIR}].str(ok)}<>1Error in pg_probackup dir {#BACKUPDIR} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030pg_probackup backup dir: {#BACKUPDIR} size9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpg_probackup.dir.size[{#BACKUPDIR}]
PostgreSQL Relations Sizes Discovery260000007pgsql.relation.size[]{#RELATIONNAME}.*8A0PostgreSQL Relation Size: {#RELATIONNAME}200pgsql.relation.size[{#RELATIONNAME}]73650153b0000100Mamonsu PostgreSQL LinuxPostgreSQL Relation Size: {#RELATIONNAME}9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.relation.size[{#RELATIONNAME}]
PostgreSQL Replication Lag Discovery260000007pgsql.replication.discovery[]{#APPLICATION_NAME}.*8A0PostgreSQL Replication: {#APPLICATION_NAME} Send Lag - Time elapsed sending recent WAL locally200pgsql.replication.send_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Receive Lag - Time elapsed between receiving recent WAL locally and receiving notification that this standby server has flushed it200pgsql.replication.receive_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Write Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written it200pgsql.replication.write_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Flush Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written and flushed it200pgsql.replication.flush_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Replay Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written, flushed and applied200pgsql.replication.replay_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Delta of Total Lag200pgsql.replication.total_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: Delta of Total Lag for {#APPLICATION_NAME}9002000.0100.0110100.00.0000000A39B98020- Mamonsu PostgreSQL Linuxpgsql.replication.total_lag[{#APPLICATION_NAME}]
+ Mamonsu Overview2505001500011010003PostgreSQL Connections: OverviewMamonsu PostgreSQL Linux05001501011010003PostgreSQL Instance: Transactions RateMamonsu PostgreSQL Linux05001500111010003System: CPU Time SpentMamonsu PostgreSQL Linux05001501111010003System: Server Free/Used Memory OverviewMamonsu PostgreSQL Linux05001500211010003PostgreSQL Autovacuum: Count of Autovacuum WorkersMamonsu PostgreSQL Linux05001501211010003PostgreSQL Instance: TuplesMamonsu PostgreSQL Linux05001500311010003PostgreSQL bgwriter: BuffersMamonsu PostgreSQL Linux05001501311010003PostgreSQL bgwriter: EventsMamonsu PostgreSQL Linux05001500411010003PostgreSQL Checkpoints: Count (in hour)Mamonsu PostgreSQL Linux05001501411010003PostgreSQL Checkpoints: Write/SyncMamonsu PostgreSQL LinuxMamonsu PostgreSQL Instance2515001500011010003pgsql.ping[]Mamonsu PostgreSQL Linux15001501011010003pgsql.uptime[]Mamonsu PostgreSQL Linux15001500111010003pgsql.cache[hit]Mamonsu PostgreSQL Linux05001501111010003PostgreSQL Instance: EventsMamonsu PostgreSQL Linux15001500211010003pgsql.temp[bytes]Mamonsu PostgreSQL Linux15001501211010003pgsql.temp[files]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL WAL2505001500011010003PostgreSQL Archiver: Archive StatusMamonsu PostgreSQL Linux15001501011010003pgsql.wal.write[]Mamonsu PostgreSQL Linux15001500111010003pgsql.archive_command[size_files_to_archive]Mamonsu PostgreSQL Linux15001501111010003pgsql.archive_command[archived_files]Mamonsu PostgreSQL Linux15001500211010003pgsql.wal.write_timeMamonsu PostgreSQL Linux15001501211010003pgsql.wal.sync_timeMamonsu PostgreSQL LinuxMamonsu PostgreSQL Locks3513301000011010003pgsql.events[conflicts]Mamonsu PostgreSQL Linux13301001011010003pgsql.pg_locks[accessshare]Mamonsu PostgreSQL Linux13301002011010003pgsql.pg_locks[rowshare]Mamonsu PostgreSQL Linux13301000111010003pgsql.pg_locks[rowexclusive]Mamonsu PostgreSQL Linux13301001111010003pgsql.pg_locks[shareupdateexclusive]Mamonsu PostgreSQL Linux13301002111010003pgsql.pg_locks[share]Mamonsu PostgreSQL Linux13301000211010003pgsql.pg_locks[sharerowexclusive]Mamonsu PostgreSQL Linux13301001211010003pgsql.pg_locks[exclusive]Mamonsu PostgreSQL Linux13301002211010003pgsql.pg_locks[accessexclusive]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL Transactions2515001500011010003pgsql.oldest[xid_age]Mamonsu PostgreSQL Linux15001501011010003pgsql.oldest[transaction_time]Mamonsu PostgreSQL Linux15001500111010003pgsql.prepared.countMamonsu PostgreSQL Linux15001501111010003pgsql.prepared.oldestMamonsu PostgreSQL LinuxMamonsu System (Linux)2505001500011010003System: Block Devices Read/Write BytesMamonsu PostgreSQL Linux05001501011010003System: Block Devices Read/Write OperationsMamonsu PostgreSQL Linux05001500111010003System: Processes OverviewMamonsu PostgreSQL Linux
+
+
+
+ {Mamonsu PostgreSQL Linux:pgsql.archive_command[count_files_to_archive].last()}>2PostgreSQL Archiver: count files need to archive on {HOSTNAME} more than 2030{Mamonsu PostgreSQL Linux:pgsql.checkpoint[count_wal].last()}>12PostgreSQL Checkpoints: required checkpoints occurs too frequently on {HOSTNAME}030 {Mamonsu PostgreSQL Linux:pgsql.connections[total].last()}/{Mamonsu PostgreSQL Linux:pgsql.connections[max_connections].last()}*100 >90PostgreSQL Connections: too many connections on {HOSTNAME} (total connections more than 90% of max_connections)030{Mamonsu PostgreSQL Linux:mamonsu.plugin.errors[].strlen()}>1Mamonsu plugin errors on {HOSTNAME}. {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:mamonsu.plugin.keepalive[].nodata(180)}=1Mamonsu nodata from {HOSTNAME}030{Mamonsu PostgreSQL Linux:mamonsu.memory.rss[max].last()}>41943040Mamonsu agent memory usage alert on {HOSTNAME}: {ITEM.LASTVALUE} bytes030{Mamonsu PostgreSQL Linux:pgsql.server_mode.change()}>0PostgreSQL Instance: server mode has been changed on {HOSTNAME} to {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.memory_leak_diagnostic.msg_text[].strlen()}>1PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold on {HOSTNAME}. {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.oldest[xid_age].last()}>18000000PostgreSQL Transactions: the oldest XID is too big on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.oldest[transaction_time].last()}>18000PostgreSQL Transactions: running transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.uptime[].change()}>600PostgreSQL Health: service has been restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.cache[hit].last()}<80PostgreSQL Health: cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.ping[].nodata(180)}=1PostgreSQL Health: no ping from PostgreSQL for 3 minutes on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.prepared.oldest.last()}>60PostgreSQL Prepared Transactions: prepared transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:system.processes[forkrate].min(5m)}>500Process fork-rate too frequently on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.replication_lag[sec].last()}>300PostgreSQL streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.replication.non_active_slots[].last()}>0PostgreSQL number of non-active replication slots on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:system.uptime[].last()}<300System was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030
+ PostgreSQL Archiver: Archive Status9002000.0100.0110100.00.0000002006AAE020- Mamonsu PostgreSQL Linuxpgsql.archive_command[count_files_to_archive]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.archive_command[archived_files]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.archive_command[failed_trying_to_archive]
PostgreSQL bgwriter: Buffers9002000.0100.0110100.00.0000002006AAE020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_checkpoint]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_clean]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_backend]
32FF5656020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_alloc]
PostgreSQL bgwriter: Events9002000.0100.0110100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[maxwritten_clean]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_backend_fsync]
PostgreSQL Checkpoints: Count (in hour)9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[count_timed]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[count_wal]
PostgreSQL Checkpoints: Write/Sync9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[write_time]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[checkpoint_sync_time]
PostgreSQL Connections: Overview9002000.0100.0111100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.connections[active]
12A39B98020- Mamonsu PostgreSQL Linuxpgsql.connections[idle]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.connections[idle_in_transaction]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.connections[idle_in_transaction_aborted]
4200B0B8020- Mamonsu PostgreSQL Linuxpgsql.connections[fastpath_function_call]
523B415A020- Mamonsu PostgreSQL Linuxpgsql.connections[disabled]
62FF5656020- Mamonsu PostgreSQL Linuxpgsql.connections[total]
72006AAE020- Mamonsu PostgreSQL Linuxpgsql.connections[waiting]
8287C2B9020- Mamonsu PostgreSQL Linuxpgsql.connections[other]
PostgreSQL Autovacuum: Count of Autovacuum Workers9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.autovacumm.count[]
System: Block Devices Read/Write Operations9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.all_read[]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.all_write[]
System: Block Devices Read/Write Bytes9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.all_read_b[]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.all_write_b[]
PostgreSQL Instance: Blocks Rate9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.blocks[hit]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.blocks[read]
PostgreSQL Instance: Transactions Rate9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.transactions[committed]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.events[xact_rollback]
PostgreSQL Instance: Events9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.events[conflicts]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.events[deadlocks]
22006AAE020- Mamonsu PostgreSQL Linuxpgsql.events[checksum_failures]
PostgreSQL Instance: Temp Files9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.temp[bytes]
12006AAE120- Mamonsu PostgreSQL Linuxpgsql.temp[files]
PostgreSQL Instance: Tuples9002000.0100.0110100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxpgsql.tuples[deleted]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.tuples[fetched]
2200CC00020- Mamonsu PostgreSQL Linuxpgsql.tuples[inserted]
32001219120- Mamonsu PostgreSQL Linuxpgsql.tuples[returned]
429C8A4E020- Mamonsu PostgreSQL Linuxpgsql.tuples[updated]
System: Server Memory Detailed Overview9004000.0100.0111100.00.0000000BAEB6B020- Mamonsu PostgreSQL Linuxsystem.memory[active]
1000CC00020- Mamonsu PostgreSQL Linuxsystem.memory[available]
2000B0B8020- Mamonsu PostgreSQL Linuxsystem.memory[buffers]
3052768F020- Mamonsu PostgreSQL Linuxsystem.memory[cached]
409C8A4E020- Mamonsu PostgreSQL Linuxsystem.memory[committed]
50A39B98020- Mamonsu PostgreSQL Linuxsystem.memory[inactive]
609F1E28020- Mamonsu PostgreSQL Linuxsystem.memory[mapped]
70793F5D020- Mamonsu PostgreSQL Linuxsystem.memory[page_tables]
80F6CB93020- Mamonsu PostgreSQL Linuxsystem.memory[slab]
90006AAE020- Mamonsu PostgreSQL Linuxsystem.memory[swap]
10087C2B9020- Mamonsu PostgreSQL Linuxsystem.memory[swap_cache]
1103B415A020- Mamonsu PostgreSQL Linuxsystem.memory[unused]
120001219020- Mamonsu PostgreSQL Linuxsystem.memory[used]
130CF6518020- Mamonsu PostgreSQL Linuxsystem.memory[vmalloc_used]
System: Server Free/Used Memory Overview9004000.0100.0110100.00.0000001001219020- Mamonsu PostgreSQL Linuxsystem.memory[used]
1152768F020- Mamonsu PostgreSQL Linuxsystem.memory[cached]
2100CC00020- Mamonsu PostgreSQL Linuxsystem.memory[available]
34FF5656020- Mamonsu PostgreSQL Linuxsystem.memory[total]
PostgreSQL pg_buffercache: Shared Buffer9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.buffers[size]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.buffers[twice_used]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.buffers[dirty]
PostgreSQL: Locks Sampling9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[accessshare]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[rowshare]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[rowexclusive]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[shareupdateexclusive]
42006AAE020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[share]
5200B0B8020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[sharerowexclusive]
629C8A4E020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[exclusive]
72793F5D020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[accessexclusive]
PostgreSQL Prepared Transactions: Overview9002000.0100.0110100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.prepared.count
129C8A4E120- Mamonsu PostgreSQL Linuxpgsql.prepared.oldest
System: Processes Overview9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.processes[running]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.processes[blocked]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.processes[forkrate]
System: CPU Time Spent9002000.0100.0111100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.cpu[user]
12793F5D020- Mamonsu PostgreSQL Linuxsystem.cpu[nice]
229C8A4E020- Mamonsu PostgreSQL Linuxsystem.cpu[system]
32A39B98020- Mamonsu PostgreSQL Linuxsystem.cpu[idle]
42006AAE020- Mamonsu PostgreSQL Linuxsystem.cpu[iowait]
52FF5656020- Mamonsu PostgreSQL Linuxsystem.cpu[irq]
62F6CB93020- Mamonsu PostgreSQL Linuxsystem.cpu[softirq]
PostgreSQL Statements: Bytes9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.stat[read_bytes]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat[write_bytes]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat[dirty_bytes]
PostgreSQL Statements: Spent Time9002000.0100.0111100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.stat[read_time]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat[write_time]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat[other_time]
PostgreSQL Statements: WAL Statistics9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.stat[wal_bytes]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.stat[wal_records]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat[wal_fpi]
PostgreSQL Wait Sampling: Locks by Type9002000.0100.0111100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.all_lock[lwlock]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.all_lock[hwlock]
2200B0B8020- Mamonsu PostgreSQL Linuxpgsql.all_lock[buffer]
329C8A4E020- Mamonsu PostgreSQL Linuxpgsql.all_lock[extension]
42F6CB93020- Mamonsu PostgreSQL Linuxpgsql.all_lock[client]
523B415A020- Mamonsu PostgreSQL Linuxpgsql.all_lock[other]
PostgreSQL Wait Sampling: Heavyweight Locks9002000.0100.0111100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.hwlock[relation]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.hwlock[extend]
22F6CB93020- Mamonsu PostgreSQL Linuxpgsql.hwlock[page]
32006AAE020- Mamonsu PostgreSQL Linuxpgsql.hwlock[tuple]
4200B0B8020- Mamonsu PostgreSQL Linuxpgsql.hwlock[transactionid]
52793F5D020- Mamonsu PostgreSQL Linuxpgsql.hwlock[virtualxid]
629C8A4E020- Mamonsu PostgreSQL Linuxpgsql.hwlock[speculative_token]
72A39B98020- Mamonsu PostgreSQL Linuxpgsql.hwlock[object]
8252768F020- Mamonsu PostgreSQL Linuxpgsql.hwlock[userlock]
92FE9430020- Mamonsu PostgreSQL Linuxpgsql.hwlock[advisory]
PostgreSQL Wait Sampling: Lightweight Locks9002000.0100.0111100.00.0000002793F5D020- Mamonsu PostgreSQL Linuxpgsql.lwlock[xid]
1200B0B8020- Mamonsu PostgreSQL Linuxpgsql.lwlock[autovacuum]
2287C2B9020- Mamonsu PostgreSQL Linuxpgsql.lwlock[wal]
32006AAE020- Mamonsu PostgreSQL Linuxpgsql.lwlock[clog]
423B415A020- Mamonsu PostgreSQL Linuxpgsql.lwlock[replication]
529C8A4E020- Mamonsu PostgreSQL Linuxpgsql.lwlock[logical_replication]
62F6CB93020- Mamonsu PostgreSQL Linuxpgsql.lwlock[buffer]
72A39B98020- Mamonsu PostgreSQL Linuxpgsql.lwlock[other]
+
\ No newline at end of file
diff --git a/packaging/conf/old_templates/template_3.5.2_agent.xml b/packaging/conf/old_templates/template_3.5.2_agent.xml
new file mode 100644
index 00000000..5d61f5ac
--- /dev/null
+++ b/packaging/conf/old_templates/template_3.5.2_agent.xml
@@ -0,0 +1,32 @@
+
+
+ 3.0
+
+
+ Templates
+
+
+
+
+ Mamonsu PostgreSQL Linux
+ Mamonsu PostgreSQL Linux
+
+
+
+ Templates
+
+
+
+
+ Mamonsu PostgreSQL Linux
+
+
+ - PostgreSQL Archiver: Files in archive_status Need to Archive Count000pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Files Need to Archive Size000pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]73650603b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Archived Files Count000pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Attempts to Archive Files Count000pgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Count of Autovacuum Workers000pgsql.autovacuum.count[{$PG_CONNINFO},{$PG_PATH}]736503000000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Utilization per 30 seconds000pgsql.autovacuum.utilization[{$PG_CONNINFO},{$PG_PATH}]73650300%0000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Average Utilization per 5 minutes1500pgsql.autovacuum.utilization.avg5[{$PG_CONNINFO},{$PG_PATH}]73650300%00001avg(pgsql.autovacuum.utilization[], 5m)00Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Average Utilization per 15 minutes1500pgsql.autovacuum.utilization.avg15[{$PG_CONNINFO},{$PG_PATH}]73650300%00001avg(pgsql.autovacuum.utilization[], 15m)00Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Average Utilization per 30 minutes1500pgsql.autovacuum.utilization.avg30[{$PG_CONNINFO},{$PG_PATH}]73650300%00001avg(pgsql.autovacuum.utilization[], 30m)00Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written During Checkpoints000pgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written000pgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Number of bgwriter Stopped by Max Write Count000pgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written Directly by a Backend000pgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Times a Backend Execute Its Own Fsync000pgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Allocated000pgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by Timeout (in hour)000pgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]7365030001000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by WAL (in hour)000pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]7365030001000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Write Time000pgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Sync Time000pgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Total User Connections000pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Waiting User Connections000pgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Max Connections000pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Active User Connections000pgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle User Connections000pgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction User Connections000pgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction (Aborted) User Connections000pgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Fastpath Function Call User Connections000pgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Disabled User Connections000pgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Other Connections000pgsql.connections.other[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- System: Block Devices Read Requests000system.disk.all_read736506001000100Mamonsu PostgreSQL Linux
- System: Block Devices Write Requests000system.disk.all_write736506001000100Mamonsu PostgreSQL Linux
- System: Block Devices Read byte/s000system.disk.all_read_b736506001000100Mamonsu PostgreSQL Linux
- System: Block Devices Write byte/s000system.disk.all_write_b736506001000100Mamonsu PostgreSQL Linux
- Mamonsu: Plugin Keep Alive000mamonsu.plugin.keepalive736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Transactions Committed000pgsql.transactions.committed[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Rollback Events000pgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Hit000pgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Read000pgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Conflict Events000pgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]736506002000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Deadlock Events000pgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]736506002000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Bytes Written000pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b2000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Files Created000pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]736506002000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Deleted000pgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Fetched000pgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Inserted000pgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Returned000pgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Updated000pgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: checksum_failures Events000pgsql.events.checksum_failures[{$PG_CONNINFO},{$PG_PATH}]736506002000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- System: Load Average Over 1 Minute000system.la.1736506000000100Mamonsu PostgreSQL Linux
- System: Active - Memory Recently Used000system.memory.active73650603b0000100Mamonsu PostgreSQL Linux
- System: Available - Free Memory000system.memory.available73650603b0000100Mamonsu PostgreSQL Linux
- System: Buffers - Block Device Cache and Dirty000system.memory.buffers73650603b0000100Mamonsu PostgreSQL Linux
- System: Cached - Parked File Data (file content) Cache000system.memory.cached73650603b0000100Mamonsu PostgreSQL Linux
- System: Committed AS - Total Committed Memory000system.memory.committed73650603b0000100Mamonsu PostgreSQL Linux
- System: Inactive - Memory Not Currently Used000system.memory.inactive73650603b0000100Mamonsu PostgreSQL Linux
- System: Mapped - All mmap()ed Pages000system.memory.mapped73650603b0000100Mamonsu PostgreSQL Linux
- System: PageTables - Map bt Virtual and Physical000system.memory.page_tables73650603b0000100Mamonsu PostgreSQL Linux
- System: Slab - Kernel Used Memory (inode cache)000system.memory.slab73650603b0000100Mamonsu PostgreSQL Linux
- System: Swap - Swap Space Used000system.memory.swap73650603b0000100Mamonsu PostgreSQL Linux
- System: SwapCached - Fetched unmod Yet Swap Pages000system.memory.swap_cache73650603b0000100Mamonsu PostgreSQL Linux
- System: Total - All Memory000system.memory.total73650603b0000100Mamonsu PostgreSQL Linux
- System: Unused - Wasted Memory000system.memory.unused73650603b0000100Mamonsu PostgreSQL Linux
- System: Used - User-Space Applications000system.memory.used73650603b0000100Mamonsu PostgreSQL Linux
- System: VMallocUsed - vmaloc() Allocated by Kernel000system.memory.vmalloc_used73650603b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold000pgsql.memory_leak_diagnostic.count_diff[]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold, text of message000pgsql.memory_leak_diagnostic.msg_text[]736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Age of the Oldest XID000pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: the Oldest Transaction Running Time in sec000pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}]73650600s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Number of Parallel Queries Being Executed Now000pgsql.parallel.queries[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- System: Opened Files000system.open_files736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Size000pgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Twice Used Size000pgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Dirty Size000pgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Ping000pgsql.ping[{$PG_CONNINFO},{$PG_PATH}]7365050ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Cache Hit Ratio1500pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]73650600%00001last(pgsql.blocks[hit])*100/(last(pgsql.blocks[hit])+last(pgsql.blocks[read]))00Mamonsu PostgreSQL Linux
- PostgreSQL Health: Service Uptime000pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]7365050unixtime0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Server Version000pgsql.version[{$PG_CONNINFO},{$PG_PATH}]73650540000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Read Only Queries000pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: SELECT FOR SHARE and SELECT FOR UPDATE000pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Write Queries000pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY000pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: CREATE INDEX000pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application000pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application or Some Operations on System Catalogs000pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE000pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: Number of Prepared Transactions000pgsql.prepared.count736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: the Oldest Prepared Transaction Running Time in sec000pgsql.prepared.oldest736506000000100Mamonsu PostgreSQL Linux
- System: Processes in State Running000system.processes.running736506000000100Mamonsu PostgreSQL Linux
- System: Processes in State Blocked000system.processes.blocked736506000000100Mamonsu PostgreSQL Linux
- System: Processes Forkrate000system.processes.forkrate736506001000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by Normal Programs and Daemons000system.cpu.user736506001000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by nice(1)d Programs000system.cpu.nice736506001000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by the Kernel in System Activities000system.cpu.system736506001000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Idle000system.cpu.idle736506001000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Waiting for I/O Operations000system.cpu.iowait736506001000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Interrupts000system.cpu.irq736506001000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Batched Interrupts000system.cpu.softirq736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Streaming Replication Lag000pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Count Non-Active Replication Slots000pgsql.replication.non_active_slots[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read bytes/s000pgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write bytes/s000pgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Dirty bytes/s000pgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read IO Time000pgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write IO Time000pgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Other (mostly CPU) Time000pgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Files000pgsql.stat.wal_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Records000pgsql.stat.wal_records[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Full Page Writes000pgsql.stat.wal_fpi[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Nnumber of Times pg_stat_statements.max Was Exceeded000pgsql.stat_info.dealloc[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Last Statistics Reset Time000pgsql.stat_info.stats_reset[{$PG_CONNINFO},{$PG_PATH}]73650600unixtime1000100Mamonsu PostgreSQL Linux
- System: Uptime000system.uptime73650603uptime0000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Speed000pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Count of WAL Files000pgsql.wal.count[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Records Generated000pgsql.wal.records.count[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Full Page Images Generated000pgsql.wal.fpi.count[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Buffers Full000pgsql.wal.buffers_full736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Time (ms)000pgsql.wal.write_time736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Time (ms)000pgsql.wal.sync_time736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Duty (%)1500pgsql.wal.sync_duty73650600%00001last(pgsql.wal.sync_time)/1000Mamonsu PostgreSQL Linux
+ PostgreSQL Databases Discovery060000007pgsql.database.discovery[{$PG_CONNINFO},{$PG_PATH}]{#DATABASE}.*8A0PostgreSQL Databases: {#DATABASE} size000pgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]736503003b0000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Max datfrozenxid Age in: {#DATABASE}000pgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Bloating Tables in {#DATABASE}000pgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Invalid Indexes in {#DATABASE}000pgsql.database.invalid_indexes[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pgsql.database.invalid_indexes[{#DATABASE}].last()}>0PostgreSQL Databases: invalid indexes in {#DATABASE} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030PostgreSQL Databases: {#DATABASE} size9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Databases: {#DATABASE} Bloating Overview9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacuum.count[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Databases: {#DATABASE} Max age(datfrozenxid)9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacuum.count[{$PG_CONNINFO},{$PG_PATH}]
System: VFS Discovery060000007system.vfs.discovery{#MOUNTPOINT}.*8A0System: Mount Point {#MOUNTPOINT} Used000system.vfs.used[{#MOUNTPOINT}]73650603b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free000system.vfs.free[{#MOUNTPOINT}]73650603b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free in Percents000system.vfs.percent_free[{#MOUNTPOINT}]73650600%0000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:system.vfs.percent_free[{#MOUNTPOINT}].last()}<{$VFS_PERCENT_FREE}System: free disk space less than 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030System: Mount Point Overview {#MOUNTPOINT}9002000.0100.0111100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxsystem.vfs.used[{#MOUNTPOINT}]
1200CC00020- Mamonsu PostgreSQL Linuxsystem.vfs.free[{#MOUNTPOINT}]
System: Block Devices Discovery060000007system.disk.discovery{#BLOCKDEVICE}.*8A0System: Block Device {#BLOCKDEVICE} Utilization000system.disk.utilization[{#BLOCKDEVICE}]73650600%1000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read Operations000system.disk.read[{#BLOCKDEVICE}]736506001000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write Operations000system.disk.write[{#BLOCKDEVICE}]736506001000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read byte/s000system.disk.read_b[{#BLOCKDEVICE}]73650600b1000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write byte/s000system.disk.write_b[{#BLOCKDEVICE}]73650600b1000100Mamonsu PostgreSQL LinuxSystem: Block Device Overview {#BLOCKDEVICE} operations9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.read[{#BLOCKDEVICE}]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.write[{#BLOCKDEVICE}]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
System: Block Device Overview {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.read_b[{#BLOCKDEVICE}]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.write_b[{#BLOCKDEVICE}]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
System: net Iface Discovery060000007system.net.discovery{#NETDEVICE}.*8A0System: Network Device {#NETDEVICE} RX bytes/s000system.net.rx_bytes[{#NETDEVICE}]73650600b1000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX errors/s000system.net.rx_errs[{#NETDEVICE}]736506001000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX drops/s000system.net.rx_drop[{#NETDEVICE}]736506001000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX bytes/s000system.net.tx_bytes[{#NETDEVICE}]73650600b1000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX errors/s000system.net.tx_errs[{#NETDEVICE}]736506001000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX drops/s000system.net.tx_drop[{#NETDEVICE}]736506001000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE}9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxsystem.net.rx_bytes[{#NETDEVICE}]
12793F5D020- Mamonsu PostgreSQL Linuxsystem.net.tx_bytes[{#NETDEVICE}]
pg_probackup Discovery060000007pg_probackup.discovery[]{#BACKUPDIR}.*8A0pg_probackup dir {#BACKUPDIR}: Size000pg_probackup.dir.size[{#BACKUPDIR}]736503003b0000100Mamonsu PostgreSQL Linuxpg_probackup dir {#BACKUPDIR}: Error000pg_probackup.dir.error[{#BACKUPDIR}]7365030040000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pg_probackup.dir.error[{#BACKUPDIR}].str(ok)}<>1pg_probackup: error in dir {#BACKUPDIR} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030pg_probackup Backup dir: {#BACKUPDIR} Size9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpg_probackup.dir.size[{#BACKUPDIR}]
PostgreSQL Relations Sizes Discovery060000007pgsql.relation.size[{$PG_CONNINFO},{$PG_PATH}]{#RELATIONNAME}.*8A0PostgreSQL Relation Size: {#RELATIONNAME}000pgsql.relation.size[{#RELATIONNAME},{$PG_CONNINFO},{$PG_PATH}]73650153b0000100Mamonsu PostgreSQL LinuxPostgreSQL Relation Size: {#RELATIONNAME}9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.relation.size[{#RELATIONNAME},{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Replication Lag Discovery060000007pgsql.replication.discovery[{$PG_CONNINFO},{$PG_PATH}]{#APPLICATION_NAME}.*8A0PostgreSQL Replication: {#APPLICATION_NAME} Send Lag - Time elapsed sending recent WAL locally000pgsql.replication.send_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Receive Lag - Time elapsed between receiving recent WAL locally and receiving notification that this standby server has flushed it000pgsql.replication.receive_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Write Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written it000pgsql.replication.write_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Flush Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written and flushed it000pgsql.replication.flush_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Replay Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written, flushed and applied000pgsql.replication.replay_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Delta of Total Lag000pgsql.replication.total_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: Delta of Total Lag for {#APPLICATION_NAME}9002000.0100.0110100.00.0000000A39B98020- Mamonsu PostgreSQL Linuxpgsql.replication.total_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]
+ {$ARCHIVE_QUEUE_FILES}2{$MAX_CHECKPOINT_BY_WAL_IN_HOUR}12{$CONNECTIONS_PERCENT}90{$VFS_PERCENT_FREE}10{$VFS_INODE_PERCENT_FREE}10{$MAMONSU_MAX_MEMORY_USAGE}41943040{$MAX_XID_AGE}18000000{$MAX_TRANSACTION_TIME}18000{$PG_UPTIME}600{$CACHE_HIT_RATIO_PERCENT}80{$MAX_PREPARED_TRANSACTION_TIME}18000{$CRITICAL_LAG_SECONDS}300{$SYSTEM_UPTIME}300
+ Mamonsu Overview2505001500011010003PostgreSQL Connections: OverviewMamonsu PostgreSQL Linux05001501011010003PostgreSQL Instance: Transactions RateMamonsu PostgreSQL Linux05001500111010003System: CPU Time SpentMamonsu PostgreSQL Linux05001501111010003System: Server Free/Used Memory OverviewMamonsu PostgreSQL Linux05001500211010003PostgreSQL Autovacuum: Count of Autovacuum WorkersMamonsu PostgreSQL Linux05001501211010003PostgreSQL Instance: TuplesMamonsu PostgreSQL Linux05001500311010003PostgreSQL bgwriter: BuffersMamonsu PostgreSQL Linux05001501311010003PostgreSQL bgwriter: EventsMamonsu PostgreSQL Linux05001500411010003PostgreSQL Checkpoints: Count (in hour)Mamonsu PostgreSQL Linux05001501411010003PostgreSQL Checkpoints: Write/SyncMamonsu PostgreSQL LinuxMamonsu PostgreSQL Instance2515001500011010003pgsql.ping[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501011010003pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500111010003pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux05001501111010003PostgreSQL Instance: EventsMamonsu PostgreSQL Linux15001500211010003pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501211010003pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL WAL2505001500011010003PostgreSQL Archiver: Archive StatusMamonsu PostgreSQL Linux15001501011010003pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500111010003pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501111010003pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500211010003pgsql.wal.write_timeMamonsu PostgreSQL Linux15001501211010003pgsql.wal.sync_timeMamonsu PostgreSQL LinuxMamonsu PostgreSQL Locks3513301000011010003pgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301001011010003pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301002011010003pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301000111010003pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301001111010003pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301002111010003pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301000211010003pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301001211010003pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301002211010003pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL Transactions2515001500011010003pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501011010003pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500111010003pgsql.prepared.countMamonsu PostgreSQL Linux15001501111010003pgsql.prepared.oldestMamonsu PostgreSQL LinuxMamonsu System (Linux)2505001500011010003System: Block Devices Read/Write BytesMamonsu PostgreSQL Linux05001501011010003System: Block Devices Read/Write OperationsMamonsu PostgreSQL Linux05001500111010003System: Processes OverviewMamonsu PostgreSQL Linux
+
+
+ {Mamonsu PostgreSQL Linux:pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}].last()}>{$ARCHIVE_QUEUE_FILES}PostgreSQL Archiver: count files need to archive on {HOSTNAME} more than 2030{Mamonsu PostgreSQL Linux:pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}].last()}>{$MAX_CHECKPOINT_BY_WAL_IN_HOUR}PostgreSQL Checkpoints: required checkpoints occurs too frequently on {HOSTNAME}030 {Mamonsu PostgreSQL Linux:pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}].last()}/{Mamonsu PostgreSQL Linux:pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}].last()}*100 >{$CONNECTIONS_PERCENT}PostgreSQL Connections: too many connections on {HOSTNAME} (total connections more than {$CONNECTIONS_PERCENT}% of max_connections)030{Mamonsu PostgreSQL Linux:mamonsu.plugin.keepalive.nodata(180)}=1Mamonsu health: nodata from {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.server_mode.change()}>0PostgreSQL Instance: server mode has been changed on {HOSTNAME} to {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.memory_leak_diagnostic.msg_text[].strlen()}>1PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold on {HOSTNAME}. {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}].last()}>{$MAX_XID_AGE}PostgreSQL Transactions: the oldest XID is too big on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}].last()}>{$MAX_TRANSACTION_TIME}PostgreSQL Transactions: running transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}].change()}>{$PG_UPTIME}PostgreSQL Health: service has been restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}].last()}<{$CACHE_HIT_RATIO_PERCENT}PostgreSQL Health: cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.ping[{$PG_CONNINFO},{$PG_PATH}].nodata(180)}=1PostgreSQL Health: no ping from PostgreSQL for 3 minutes on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.prepared.oldest.last()}>{$MAX_PREPARED_TRANSACTION_TIME}PostgreSQL Prepared Transactions: prepared transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:system.processes.forkrate.min(5m)}>500System: process fork-rate too frequently on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}].last()}>{$CRITICAL_LAG_SECONDS}PostgreSQL Replication: streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.replication.non_active_slots[{$PG_CONNINFO},{$PG_PATH}].last()}>0PostgreSQL Replication: number of non-active replication slots on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:system.uptime.last()}<{$SYSTEM_UPTIME}System: {HOSTNAME} was restarted (start time={ITEM.LASTVALUE})030
+ PostgreSQL Archiver: Archive Status9002000.0100.0110100.00.0000002006AAE020- Mamonsu PostgreSQL Linuxpgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Autovacuum: Count of Autovacuum Workers9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.autovacuum.count[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL bgwriter: Buffers9002000.0100.0110100.00.0000002006AAE020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]
32FF5656020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL bgwriter: Events9002000.0100.0110100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Checkpoints: Count (in hour)9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Checkpoints: Write/Sync9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Connections: Overview9002000.0100.0111100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]
12A39B98020- Mamonsu PostgreSQL Linuxpgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]
4200B0B8020- Mamonsu PostgreSQL Linuxpgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]
523B415A020- Mamonsu PostgreSQL Linuxpgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]
62FF5656020- Mamonsu PostgreSQL Linuxpgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]
72006AAE020- Mamonsu PostgreSQL Linuxpgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]
8287C2B9020- Mamonsu PostgreSQL Linuxpgsql.connections.other[{$PG_CONNINFO},{$PG_PATH}]
System: Block Devices Read/Write Operations9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.all_read
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.all_write
System: Block Devices Read/Write Bytes9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.all_read_b
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.all_write_b
PostgreSQL Instance: Blocks Rate9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Transactions Rate9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.transactions.committed[{$PG_CONNINFO},{$PG_PATH}]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Events9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]
22006AAE020- Mamonsu PostgreSQL Linuxpgsql.events.checksum_failures[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Temp Files9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]
12006AAE120- Mamonsu PostgreSQL Linuxpgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Tuples9002000.0100.0110100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxpgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]
2200CC00020- Mamonsu PostgreSQL Linuxpgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]
32001219120- Mamonsu PostgreSQL Linuxpgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]
429C8A4E020- Mamonsu PostgreSQL Linuxpgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]
System: Server Memory Detailed Overview9004000.0100.0111100.00.0000000BAEB6B020- Mamonsu PostgreSQL Linuxsystem.memory.active
1000CC00020- Mamonsu PostgreSQL Linuxsystem.memory.available
2000B0B8020- Mamonsu PostgreSQL Linuxsystem.memory.buffers
3052768F020- Mamonsu PostgreSQL Linuxsystem.memory.cached
409C8A4E020- Mamonsu PostgreSQL Linuxsystem.memory.committed
50A39B98020- Mamonsu PostgreSQL Linuxsystem.memory.inactive
609F1E28020- Mamonsu PostgreSQL Linuxsystem.memory.mapped
70793F5D020- Mamonsu PostgreSQL Linuxsystem.memory.page_tables
80F6CB93020- Mamonsu PostgreSQL Linuxsystem.memory.slab
90006AAE020- Mamonsu PostgreSQL Linuxsystem.memory.swap
10087C2B9020- Mamonsu PostgreSQL Linuxsystem.memory.swap_cache
1103B415A020- Mamonsu PostgreSQL Linuxsystem.memory.unused
120001219020- Mamonsu PostgreSQL Linuxsystem.memory.used
130CF6518020- Mamonsu PostgreSQL Linuxsystem.memory.vmalloc_used
System: Server Free/Used Memory Overview9004000.0100.0110100.00.0000001001219020- Mamonsu PostgreSQL Linuxsystem.memory.used
1152768F020- Mamonsu PostgreSQL Linuxsystem.memory.cached
2100CC00020- Mamonsu PostgreSQL Linuxsystem.memory.available
34FF5656020- Mamonsu PostgreSQL Linuxsystem.memory.total
PostgreSQL pg_buffercache: Shared Buffer9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL: Locks Sampling9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]
42006AAE020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]
5200B0B8020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]
629C8A4E020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]
72793F5D020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Prepared Transactions: Overview9002000.0100.0110100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.prepared.count
129C8A4E120- Mamonsu PostgreSQL Linuxpgsql.prepared.oldest
System: Processes Overview9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.processes.running
12FF5656020- Mamonsu PostgreSQL Linuxsystem.processes.blocked
22006AAE120- Mamonsu PostgreSQL Linuxsystem.processes.forkrate
System: CPU Time Spent9002000.0100.0111100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.cpu.user
12793F5D020- Mamonsu PostgreSQL Linuxsystem.cpu.nice
229C8A4E020- Mamonsu PostgreSQL Linuxsystem.cpu.system
32A39B98020- Mamonsu PostgreSQL Linuxsystem.cpu.idle
42006AAE020- Mamonsu PostgreSQL Linuxsystem.cpu.iowait
52FF5656020- Mamonsu PostgreSQL Linuxsystem.cpu.irq
62F6CB93020- Mamonsu PostgreSQL Linuxsystem.cpu.softirq
PostgreSQL Statements: Bytes9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Statements: Spent Time9002000.0100.0111100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Statements: WAL Statistics9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.stat.wal_bytes[{$PG_CONNINFO},{$PG_PATH}]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.stat.wal_records[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat.wal_fpi[{$PG_CONNINFO},{$PG_PATH}]
+
\ No newline at end of file
diff --git a/packaging/conf/old_templates/template_3.5.2_linux.xml b/packaging/conf/old_templates/template_3.5.2_linux.xml
new file mode 100644
index 00000000..d8b75f56
--- /dev/null
+++ b/packaging/conf/old_templates/template_3.5.2_linux.xml
@@ -0,0 +1,32 @@
+
+
+ 3.0
+
+
+ Templates
+
+
+
+
+ Mamonsu PostgreSQL Linux
+ Mamonsu PostgreSQL Linux
+
+
+
+ Templates
+
+
+
+
+ Mamonsu PostgreSQL Linux
+
+
+ - PostgreSQL Archiver: Files in archive_status Need to Archive Count200pgsql.archive_command[count_files_to_archive]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Files Need to Archive Size200pgsql.archive_command[size_files_to_archive]73650603b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Archived Files Count200pgsql.archive_command[archived_files]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Attempts to Archive Files Count200pgsql.archive_command[failed_trying_to_archive]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Count of Autovacuum Workers200pgsql.autovacuum.count[]736503000000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Utilization per 30 seconds200pgsql.autovacuum.utilization[]73650300%0000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Average Utilization per 5 minutes1500pgsql.autovacuum.utilization.avg5[]73650300%00001avg(pgsql.autovacuum.utilization[], 5m)00Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Average Utilization per 15 minutes1500pgsql.autovacuum.utilization.avg15[]73650300%00001avg(pgsql.autovacuum.utilization[], 15m)00Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Average Utilization per 30 minutes1500pgsql.autovacuum.utilization.avg30[]73650300%00001avg(pgsql.autovacuum.utilization[], 30m)00Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written During Checkpoints200pgsql.bgwriter[buffers_checkpoint]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written200pgsql.bgwriter[buffers_clean]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Number of bgwriter Stopped by Max Write Count200pgsql.bgwriter[maxwritten_clean]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written Directly by a Backend200pgsql.bgwriter[buffers_backend]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Times a Backend Execute Its Own Fsync200pgsql.bgwriter[buffers_backend_fsync]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Allocated200pgsql.bgwriter[buffers_alloc]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Written byte/s200pgsql.cfs.activity[written_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Scanned byte/s200pgsql.cfs.activity[scanned_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Compressed Files200pgsql.cfs.activity[compressed_files]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Scanned Files200pgsql.cfs.activity[scanned_files]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Current Ratio200pgsql.cfs.activity[current_compress_ratio]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Total Ratio200pgsql.cfs.activity[total_compress_ratio]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by Timeout (in hour)200pgsql.checkpoint[count_timed]7365030000000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by WAL (in hour)200pgsql.checkpoint[count_wal]7365030000000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Write Time200pgsql.checkpoint[write_time]736503000ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Sync Time200pgsql.checkpoint[checkpoint_sync_time]736503000ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Total User Connections200pgsql.connections[total]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Waiting User Connections200pgsql.connections[waiting]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Max Connections200pgsql.connections[max_connections]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Active User Connections200pgsql.connections[active]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle User Connections200pgsql.connections[idle]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction User Connections200pgsql.connections[idle_in_transaction]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction (Aborted) User Connections200pgsql.connections[idle_in_transaction_aborted]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Fastpath Function Call User Connections200pgsql.connections[fastpath_function_call]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Disabled User Connections200pgsql.connections[disabled]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Other Connections200pgsql.connections[other]736506000000100Mamonsu PostgreSQL Linux
- System: Block Devices Read Requests200system.disk.all_read[]736506000000100Mamonsu PostgreSQL Linux
- System: Block Devices Write Requests200system.disk.all_write[]736506000000100Mamonsu PostgreSQL Linux
- System: Block Devices Read byte/s200system.disk.all_read_b[]736506000000100Mamonsu PostgreSQL Linux
- System: Block Devices Write byte/s200system.disk.all_write_b[]736506000000100Mamonsu PostgreSQL Linux
- Mamonsu: Plugin Errors200mamonsu.plugin.errors[]736506040000100Mamonsu PostgreSQL Linux
- Mamonsu: Plugin Keep Alive200mamonsu.plugin.keepalive[]736506000000100Mamonsu PostgreSQL Linux
- Mamonsu: RSS Memory Max Usage200mamonsu.memory.rss[max]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Transactions Committed200pgsql.transactions[committed]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Rollback Events200pgsql.events[xact_rollback]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Hit200pgsql.blocks[hit]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Read200pgsql.blocks[read]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Conflict Events200pgsql.events[conflicts]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Deadlock Events200pgsql.events[deadlocks]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Bytes Written200pgsql.temp[bytes]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Files Created200pgsql.temp[files]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Deleted200pgsql.tuples[deleted]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Fetched200pgsql.tuples[fetched]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Inserted200pgsql.tuples[inserted]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Returned200pgsql.tuples[returned]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Updated200pgsql.tuples[updated]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: checksum_failures Events200pgsql.events[checksum_failures]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- System: Load Average Over 1 Minute200system.la[1]736506000000100Mamonsu PostgreSQL Linux
- System: Active - Memory Recently Used200system.memory[active]73650603b0000100Mamonsu PostgreSQL Linux
- System: Available - Free Memory200system.memory[available]73650603b0000100Mamonsu PostgreSQL Linux
- System: Buffers - Block Device Cache and Dirty200system.memory[buffers]73650603b0000100Mamonsu PostgreSQL Linux
- System: Cached - Parked File Data (file content) Cache200system.memory[cached]73650603b0000100Mamonsu PostgreSQL Linux
- System: Committed AS - Total Committed Memory200system.memory[committed]73650603b0000100Mamonsu PostgreSQL Linux
- System: Inactive - Memory Not Currently Used200system.memory[inactive]73650603b0000100Mamonsu PostgreSQL Linux
- System: Mapped - All mmap()ed Pages200system.memory[mapped]73650603b0000100Mamonsu PostgreSQL Linux
- System: PageTables - Map bt Virtual and Physical200system.memory[page_tables]73650603b0000100Mamonsu PostgreSQL Linux
- System: Slab - Kernel Used Memory (inode cache)200system.memory[slab]73650603b0000100Mamonsu PostgreSQL Linux
- System: Swap - Swap Space Used200system.memory[swap]73650603b0000100Mamonsu PostgreSQL Linux
- System: SwapCached - Fetched unmod Yet Swap Pages200system.memory[swap_cache]73650603b0000100Mamonsu PostgreSQL Linux
- System: Total - All Memory200system.memory[total]73650603b0000100Mamonsu PostgreSQL Linux
- System: Unused - Wasted Memory200system.memory[unused]73650603b0000100Mamonsu PostgreSQL Linux
- System: Used - User-Space Applications200system.memory[used]73650603b0000100Mamonsu PostgreSQL Linux
- System: VMallocUsed - vmaloc() Allocated by Kernel200system.memory[vmalloc_used]73650603b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold200pgsql.memory_leak_diagnostic.count_diff[]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold, text of message200pgsql.memory_leak_diagnostic.msg_text[]736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Age of the Oldest XID200pgsql.oldest[xid_age]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: the Oldest Transaction Running Time in sec200pgsql.oldest[transaction_time]73650600s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Number of Parallel Queries Being Executed Now200pgsql.parallel[queries]736506030000100Mamonsu PostgreSQL Linux
- System: Opened Files200system.open_files[]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Size200pgsql.buffers[size]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Twice Used Size200pgsql.buffers[twice_used]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Dirty Size200pgsql.buffers[dirty]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Ping200pgsql.ping[]73650600ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Cache Hit Ratio1500pgsql.cache[hit]73650600%00001last(pgsql.blocks[hit])*100/(last(pgsql.blocks[hit])+last(pgsql.blocks[read]))00Mamonsu PostgreSQL Linux
- PostgreSQL Health: Service Uptime200pgsql.uptime[]73650603unixtime0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Server Version200pgsql.version[]736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Read Only Queries200pgsql.pg_locks[accessshare]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: SELECT FOR SHARE and SELECT FOR UPDATE200pgsql.pg_locks[rowshare]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Write Queries200pgsql.pg_locks[rowexclusive]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY200pgsql.pg_locks[shareupdateexclusive]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: CREATE INDEX200pgsql.pg_locks[share]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application200pgsql.pg_locks[sharerowexclusive]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application or Some Operations on System Catalogs200pgsql.pg_locks[exclusive]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE200pgsql.pg_locks[accessexclusive]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: Number of Prepared Transactions200pgsql.prepared.count736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: the Oldest Prepared Transaction Running Time in sec200pgsql.prepared.oldest736506000000100Mamonsu PostgreSQL Linux
- System: Processes in State Running200system.processes[running]736506000000100Mamonsu PostgreSQL Linux
- System: Processes in State Blocked200system.processes[blocked]736506000000100Mamonsu PostgreSQL Linux
- System: Processes Forkrate200system.processes[forkrate]736506000000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by Normal Programs and Daemons200system.cpu[user]736506000000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by nice(1)d Programs200system.cpu[nice]736506000000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by the Kernel in System Activities200system.cpu[system]736506000000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Idle200system.cpu[idle]736506000000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Waiting for I/O Operations200system.cpu[iowait]736506000000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Interrupts200system.cpu[irq]736506000000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Batched Interrupts200system.cpu[softirq]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Streaming Replication Lag200pgsql.replication_lag[sec]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Count Non-Active Replication Slots200pgsql.replication.non_active_slots[]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read bytes/s200pgsql.stat[read_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write bytes/s200pgsql.stat[write_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Dirty bytes/s200pgsql.stat[dirty_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read IO Time200pgsql.stat[read_time]73650600s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write IO Time200pgsql.stat[write_time]73650600s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Other (mostly CPU) Time200pgsql.stat[other_time]73650600s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Files200pgsql.stat[wal_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Records200pgsql.stat[wal_records]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Full Page Writes200pgsql.stat[wal_fpi]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Nnumber of Times pg_stat_statements.max Was Exceeded200pgsql.stat_info[dealloc]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Last Statistics Reset Time200pgsql.stat_info[stats_reset]73650600unixtime0000100Mamonsu PostgreSQL Linux
- System: Uptime200system.uptime[]73650603uptime0000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Lightweight Locks200pgsql.all_lock[lwlock]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Heavyweight Locks200pgsql.all_lock[hwlock]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Buffer Locks200pgsql.all_lock[buffer]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Extension Locks200pgsql.all_lock[extension]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Client Locks200pgsql.all_lock[client]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Other Locks (e.g. IPC, Timeout, IO)200pgsql.all_lock[other]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: XID Access Locks200pgsql.lwlock[xid]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Autovacuum Locks200pgsql.lwlock[autovacuum]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: WAL Access Locks200pgsql.lwlock[wal]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: CLOG Access Locks200pgsql.lwlock[clog]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Replication Locks200pgsql.lwlock[replication]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Logical Replication Locks200pgsql.lwlock[logical_replication]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Buffer Operations Locks200pgsql.lwlock[buffer]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Other Operations Lightweight Locks200pgsql.lwlock[other]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Relation200pgsql.hwlock[relation]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Extend a Relation Locks200pgsql.hwlock[extend]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Page200pgsql.hwlock[page]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Tuple200pgsql.hwlock[tuple]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Transaction to Finish Locks200pgsql.hwlock[transactionid]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Virtual XID Locks200pgsql.hwlock[virtualxid]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Speculative Insertion Locks200pgsql.hwlock[speculative_token]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on Database Object200pgsql.hwlock[object]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Userlocks200pgsql.hwlock[userlock]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Advisory User Locks200pgsql.hwlock[advisory]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Speed200pgsql.wal.write[]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Count of WAL Files200pgsql.wal.count[]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Records Generated200pgsql.wal.records.count[]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Full Page Images Generated200pgsql.wal.fpi.count[]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Buffers Full200pgsql.wal.buffers_full736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Time (ms)200pgsql.wal.write_time736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Time (ms)200pgsql.wal.sync_time736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Duty (%)1500pgsql.wal.sync_duty73650600%00001last(pgsql.wal.sync_time)/1000Mamonsu PostgreSQL Linux
+ PostgreSQL CFS Discovery260000007pgsql.cfs.discovery_compressed_relations[]{#COMPRESSED_RELATION}.*8A0PostgreSQL CFS: Relation {#COMPRESSED_RELATION} Compress Ratio200pgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]7365060000000100Mamonsu PostgreSQL LinuxPostgreSQL CFS: Relation {#COMPRESSED_RELATION} Compress Ratio9002000.0100.0110100.00.0000000A39B98020- Mamonsu PostgreSQL Linuxpgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]
PostgreSQL Databases Discovery260000007pgsql.database.discovery[]{#DATABASE}.*8A0PostgreSQL Databases: {#DATABASE} size200pgsql.database.size[{#DATABASE}]736503003b0000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Max datfrozenxid Age in: {#DATABASE}200pgsql.database.max_age[{#DATABASE}]7365030000000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Bloating Tables in {#DATABASE}200pgsql.database.bloating_tables[{#DATABASE}]7365030000000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Invalid Indexes in {#DATABASE}200pgsql.database.invalid_indexes[{#DATABASE}]7365030000000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pgsql.database.invalid_indexes[{#DATABASE}].last()}>0PostgreSQL Databases: invalid indexes in {#DATABASE} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030PostgreSQL Databases: {#DATABASE} size9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.database.size[{#DATABASE}]
PostgreSQL Databases: {#DATABASE} Bloating Overview9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.database.bloating_tables[{#DATABASE}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacuum.count[]
PostgreSQL Databases: {#DATABASE} Max age(datfrozenxid)9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.database.max_age[{#DATABASE}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacuum.count[]
System: VFS Discovery260000007system.vfs.discovery[]{#MOUNTPOINT}.*8A0System: Mount Point {#MOUNTPOINT} Used200system.vfs.used[{#MOUNTPOINT}]73650603b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free200system.vfs.free[{#MOUNTPOINT}]73650603b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free in Percents200system.vfs.percent_free[{#MOUNTPOINT}]73650600%0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free Inodes in Percent200system.vfs.percent_inode_free[{#MOUNTPOINT}]73650600%0000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:system.vfs.percent_free[{#MOUNTPOINT}].last()}<{$VFS_PERCENT_FREE}System: free disk space less than 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:system.vfs.percent_inode_free[{#MOUNTPOINT}].last()}<{$VFS_INODE_PERCENT_FREE}System: free inode space less than 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030System: Mount Point Overview {#MOUNTPOINT}9002000.0100.0111100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxsystem.vfs.used[{#MOUNTPOINT}]
1200CC00020- Mamonsu PostgreSQL Linuxsystem.vfs.free[{#MOUNTPOINT}]
System: Block Devices Discovery260000007system.disk.discovery[]{#BLOCKDEVICE}.*8A0System: Block Device {#BLOCKDEVICE} Utilization200system.disk.utilization[{#BLOCKDEVICE}]73650600%0000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read Operations200system.disk.read[{#BLOCKDEVICE}]736506000000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write Operations200system.disk.write[{#BLOCKDEVICE}]736506000000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read byte/s200system.disk.read_b[{#BLOCKDEVICE}]73650600b0000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write byte/s200system.disk.write_b[{#BLOCKDEVICE}]73650600b0000100Mamonsu PostgreSQL LinuxSystem: Block Device Overview {#BLOCKDEVICE} operations9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.read[{#BLOCKDEVICE}]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.write[{#BLOCKDEVICE}]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
System: Block Device Overview {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.read_b[{#BLOCKDEVICE}]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.write_b[{#BLOCKDEVICE}]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
System: net Iface Discovery260000007system.net.discovery[]{#NETDEVICE}.*8A0System: Network Device {#NETDEVICE} RX bytes/s200system.net.rx_bytes[{#NETDEVICE}]73650600b0000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX errors/s200system.net.rx_errs[{#NETDEVICE}]736506000000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX drops/s200system.net.rx_drop[{#NETDEVICE}]736506000000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX bytes/s200system.net.tx_bytes[{#NETDEVICE}]73650600b0000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX errors/s200system.net.tx_errs[{#NETDEVICE}]736506000000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX drops/s200system.net.tx_drop[{#NETDEVICE}]736506000000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE}9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxsystem.net.rx_bytes[{#NETDEVICE}]
12793F5D020- Mamonsu PostgreSQL Linuxsystem.net.tx_bytes[{#NETDEVICE}]
pg_probackup Discovery260000007pg_probackup.discovery[]{#BACKUPDIR}.*8A0pg_probackup dir {#BACKUPDIR}: Size200pg_probackup.dir.size[{#BACKUPDIR}]736503003b0000100Mamonsu PostgreSQL Linuxpg_probackup dir {#BACKUPDIR}: Error200pg_probackup.dir.error[{#BACKUPDIR}]7365030040000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pg_probackup.dir.error[{#BACKUPDIR}].str(ok)}<>1pg_probackup: error in dir {#BACKUPDIR} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030pg_probackup Backup dir: {#BACKUPDIR} Size9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpg_probackup.dir.size[{#BACKUPDIR}]
PostgreSQL Relations Sizes Discovery260000007pgsql.relation.size[]{#RELATIONNAME}.*8A0PostgreSQL Relation Size: {#RELATIONNAME}200pgsql.relation.size[{#RELATIONNAME}]73650153b0000100Mamonsu PostgreSQL LinuxPostgreSQL Relation Size: {#RELATIONNAME}9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.relation.size[{#RELATIONNAME}]
PostgreSQL Replication Lag Discovery260000007pgsql.replication.discovery[]{#APPLICATION_NAME}.*8A0PostgreSQL Replication: {#APPLICATION_NAME} Send Lag - Time elapsed sending recent WAL locally200pgsql.replication.send_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Receive Lag - Time elapsed between receiving recent WAL locally and receiving notification that this standby server has flushed it200pgsql.replication.receive_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Write Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written it200pgsql.replication.write_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Flush Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written and flushed it200pgsql.replication.flush_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Replay Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written, flushed and applied200pgsql.replication.replay_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Delta of Total Lag200pgsql.replication.total_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: Delta of Total Lag for {#APPLICATION_NAME}9002000.0100.0110100.00.0000000A39B98020- Mamonsu PostgreSQL Linuxpgsql.replication.total_lag[{#APPLICATION_NAME}]
+ {$ARCHIVE_QUEUE_FILES}2{$MAX_CHECKPOINT_BY_WAL_IN_HOUR}12{$CONNECTIONS_PERCENT}90{$VFS_PERCENT_FREE}10{$VFS_INODE_PERCENT_FREE}10{$MAMONSU_MAX_MEMORY_USAGE}41943040{$MAX_XID_AGE}18000000{$MAX_TRANSACTION_TIME}18000{$PG_UPTIME}600{$CACHE_HIT_RATIO_PERCENT}80{$MAX_PREPARED_TRANSACTION_TIME}18000{$CRITICAL_LAG_SECONDS}300{$SYSTEM_UPTIME}300
+ Mamonsu Overview2505001500011010003PostgreSQL Connections: OverviewMamonsu PostgreSQL Linux05001501011010003PostgreSQL Instance: Transactions RateMamonsu PostgreSQL Linux05001500111010003System: CPU Time SpentMamonsu PostgreSQL Linux05001501111010003System: Server Free/Used Memory OverviewMamonsu PostgreSQL Linux05001500211010003PostgreSQL Autovacuum: Count of Autovacuum WorkersMamonsu PostgreSQL Linux05001501211010003PostgreSQL Instance: TuplesMamonsu PostgreSQL Linux05001500311010003PostgreSQL bgwriter: BuffersMamonsu PostgreSQL Linux05001501311010003PostgreSQL bgwriter: EventsMamonsu PostgreSQL Linux05001500411010003PostgreSQL Checkpoints: Count (in hour)Mamonsu PostgreSQL Linux05001501411010003PostgreSQL Checkpoints: Write/SyncMamonsu PostgreSQL LinuxMamonsu PostgreSQL Instance2515001500011010003pgsql.ping[]Mamonsu PostgreSQL Linux15001501011010003pgsql.uptime[]Mamonsu PostgreSQL Linux15001500111010003pgsql.cache[hit]Mamonsu PostgreSQL Linux05001501111010003PostgreSQL Instance: EventsMamonsu PostgreSQL Linux15001500211010003pgsql.temp[bytes]Mamonsu PostgreSQL Linux15001501211010003pgsql.temp[files]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL WAL2505001500011010003PostgreSQL Archiver: Archive StatusMamonsu PostgreSQL Linux15001501011010003pgsql.wal.write[]Mamonsu PostgreSQL Linux15001500111010003pgsql.archive_command[size_files_to_archive]Mamonsu PostgreSQL Linux15001501111010003pgsql.archive_command[archived_files]Mamonsu PostgreSQL Linux15001500211010003pgsql.wal.write_timeMamonsu PostgreSQL Linux15001501211010003pgsql.wal.sync_timeMamonsu PostgreSQL LinuxMamonsu PostgreSQL Locks3513301000011010003pgsql.events[conflicts]Mamonsu PostgreSQL Linux13301001011010003pgsql.pg_locks[accessshare]Mamonsu PostgreSQL Linux13301002011010003pgsql.pg_locks[rowshare]Mamonsu PostgreSQL Linux13301000111010003pgsql.pg_locks[rowexclusive]Mamonsu PostgreSQL Linux13301001111010003pgsql.pg_locks[shareupdateexclusive]Mamonsu PostgreSQL Linux13301002111010003pgsql.pg_locks[share]Mamonsu PostgreSQL Linux13301000211010003pgsql.pg_locks[sharerowexclusive]Mamonsu PostgreSQL Linux13301001211010003pgsql.pg_locks[exclusive]Mamonsu PostgreSQL Linux13301002211010003pgsql.pg_locks[accessexclusive]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL Transactions2515001500011010003pgsql.oldest[xid_age]Mamonsu PostgreSQL Linux15001501011010003pgsql.oldest[transaction_time]Mamonsu PostgreSQL Linux15001500111010003pgsql.prepared.countMamonsu PostgreSQL Linux15001501111010003pgsql.prepared.oldestMamonsu PostgreSQL LinuxMamonsu System (Linux)2505001500011010003System: Block Devices Read/Write BytesMamonsu PostgreSQL Linux05001501011010003System: Block Devices Read/Write OperationsMamonsu PostgreSQL Linux05001500111010003System: Processes OverviewMamonsu PostgreSQL Linux
+
+
+ {Mamonsu PostgreSQL Linux:pgsql.archive_command[count_files_to_archive].last()}>{$ARCHIVE_QUEUE_FILES}PostgreSQL Archiver: count files need to archive on {HOSTNAME} more than 2030{Mamonsu PostgreSQL Linux:pgsql.checkpoint[count_wal].last()}>{$MAX_CHECKPOINT_BY_WAL_IN_HOUR}PostgreSQL Checkpoints: required checkpoints occurs too frequently on {HOSTNAME}030 {Mamonsu PostgreSQL Linux:pgsql.connections[total].last()}/{Mamonsu PostgreSQL Linux:pgsql.connections[max_connections].last()}*100 >{$CONNECTIONS_PERCENT}PostgreSQL Connections: too many connections on {HOSTNAME} (total connections more than {$CONNECTIONS_PERCENT}% of max_connections)030{Mamonsu PostgreSQL Linux:mamonsu.plugin.errors[].strlen()}>1Mamonsu health: plugin errors on {HOSTNAME}. {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:mamonsu.plugin.keepalive[].nodata(180)}=1Mamonsu health: nodata from {HOSTNAME}030{Mamonsu PostgreSQL Linux:mamonsu.memory.rss[max].last()}>{$MAMONSU_MAX_MEMORY_USAGE}Mamonsu health: agent memory usage alert on {HOSTNAME}: {ITEM.LASTVALUE} bytes030{Mamonsu PostgreSQL Linux:pgsql.server_mode.change()}>0PostgreSQL Instance: server mode has been changed on {HOSTNAME} to {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.memory_leak_diagnostic.msg_text[].strlen()}>1PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold on {HOSTNAME}. {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.oldest[xid_age].last()}>{$MAX_XID_AGE}PostgreSQL Transactions: the oldest XID is too big on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.oldest[transaction_time].last()}>{$MAX_TRANSACTION_TIME}PostgreSQL Transactions: running transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.uptime[].change()}>{$PG_UPTIME}PostgreSQL Health: service has been restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.cache[hit].last()}<{$CACHE_HIT_RATIO_PERCENT}PostgreSQL Health: cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.ping[].nodata(180)}=1PostgreSQL Health: no ping from PostgreSQL for 3 minutes on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.prepared.oldest.last()}>{$MAX_PREPARED_TRANSACTION_TIME}PostgreSQL Prepared Transactions: prepared transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:system.processes[forkrate].min(5m)}>500System: process fork-rate too frequently on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.replication_lag[sec].last()}>{$CRITICAL_LAG_SECONDS}PostgreSQL Replication: streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.replication.non_active_slots[].last()}>0PostgreSQL Replication: number of non-active replication slots on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:system.uptime[].last()}<{$SYSTEM_UPTIME}System: {HOSTNAME} was restarted (start time={ITEM.LASTVALUE})030
+ PostgreSQL Archiver: Archive Status9002000.0100.0110100.00.0000002006AAE020- Mamonsu PostgreSQL Linuxpgsql.archive_command[count_files_to_archive]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.archive_command[archived_files]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.archive_command[failed_trying_to_archive]
PostgreSQL Autovacuum: Count of Autovacuum Workers9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.autovacuum.count[]
PostgreSQL bgwriter: Buffers9002000.0100.0110100.00.0000002006AAE020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_checkpoint]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_clean]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_backend]
32FF5656020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_alloc]
PostgreSQL bgwriter: Events9002000.0100.0110100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[maxwritten_clean]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_backend_fsync]
PostgreSQL Checkpoints: Count (in hour)9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[count_timed]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[count_wal]
PostgreSQL Checkpoints: Write/Sync9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[write_time]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[checkpoint_sync_time]
PostgreSQL Connections: Overview9002000.0100.0111100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.connections[active]
12A39B98020- Mamonsu PostgreSQL Linuxpgsql.connections[idle]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.connections[idle_in_transaction]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.connections[idle_in_transaction_aborted]
4200B0B8020- Mamonsu PostgreSQL Linuxpgsql.connections[fastpath_function_call]
523B415A020- Mamonsu PostgreSQL Linuxpgsql.connections[disabled]
62FF5656020- Mamonsu PostgreSQL Linuxpgsql.connections[total]
72006AAE020- Mamonsu PostgreSQL Linuxpgsql.connections[waiting]
8287C2B9020- Mamonsu PostgreSQL Linuxpgsql.connections[other]
System: Block Devices Read/Write Operations9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.all_read[]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.all_write[]
System: Block Devices Read/Write Bytes9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.all_read_b[]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.all_write_b[]
PostgreSQL Instance: Blocks Rate9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.blocks[hit]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.blocks[read]
PostgreSQL Instance: Transactions Rate9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.transactions[committed]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.events[xact_rollback]
PostgreSQL Instance: Events9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.events[conflicts]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.events[deadlocks]
22006AAE020- Mamonsu PostgreSQL Linuxpgsql.events[checksum_failures]
PostgreSQL Instance: Temp Files9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.temp[bytes]
12006AAE120- Mamonsu PostgreSQL Linuxpgsql.temp[files]
PostgreSQL Instance: Tuples9002000.0100.0110100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxpgsql.tuples[deleted]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.tuples[fetched]
2200CC00020- Mamonsu PostgreSQL Linuxpgsql.tuples[inserted]
32001219120- Mamonsu PostgreSQL Linuxpgsql.tuples[returned]
429C8A4E020- Mamonsu PostgreSQL Linuxpgsql.tuples[updated]
System: Server Memory Detailed Overview9004000.0100.0111100.00.0000000BAEB6B020- Mamonsu PostgreSQL Linuxsystem.memory[active]
1000CC00020- Mamonsu PostgreSQL Linuxsystem.memory[available]
2000B0B8020- Mamonsu PostgreSQL Linuxsystem.memory[buffers]
3052768F020- Mamonsu PostgreSQL Linuxsystem.memory[cached]
409C8A4E020- Mamonsu PostgreSQL Linuxsystem.memory[committed]
50A39B98020- Mamonsu PostgreSQL Linuxsystem.memory[inactive]
609F1E28020- Mamonsu PostgreSQL Linuxsystem.memory[mapped]
70793F5D020- Mamonsu PostgreSQL Linuxsystem.memory[page_tables]
80F6CB93020- Mamonsu PostgreSQL Linuxsystem.memory[slab]
90006AAE020- Mamonsu PostgreSQL Linuxsystem.memory[swap]
10087C2B9020- Mamonsu PostgreSQL Linuxsystem.memory[swap_cache]
1103B415A020- Mamonsu PostgreSQL Linuxsystem.memory[unused]
120001219020- Mamonsu PostgreSQL Linuxsystem.memory[used]
130CF6518020- Mamonsu PostgreSQL Linuxsystem.memory[vmalloc_used]
System: Server Free/Used Memory Overview9004000.0100.0110100.00.0000001001219020- Mamonsu PostgreSQL Linuxsystem.memory[used]
1152768F020- Mamonsu PostgreSQL Linuxsystem.memory[cached]
2100CC00020- Mamonsu PostgreSQL Linuxsystem.memory[available]
34FF5656020- Mamonsu PostgreSQL Linuxsystem.memory[total]
PostgreSQL pg_buffercache: Shared Buffer9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.buffers[size]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.buffers[twice_used]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.buffers[dirty]
PostgreSQL: Locks Sampling9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[accessshare]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[rowshare]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[rowexclusive]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[shareupdateexclusive]
42006AAE020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[share]
5200B0B8020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[sharerowexclusive]
629C8A4E020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[exclusive]
72793F5D020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[accessexclusive]
PostgreSQL Prepared Transactions: Overview9002000.0100.0110100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.prepared.count
129C8A4E120- Mamonsu PostgreSQL Linuxpgsql.prepared.oldest
System: Processes Overview9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.processes[running]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.processes[blocked]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.processes[forkrate]
System: CPU Time Spent9002000.0100.0111100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.cpu[user]
12793F5D020- Mamonsu PostgreSQL Linuxsystem.cpu[nice]
229C8A4E020- Mamonsu PostgreSQL Linuxsystem.cpu[system]
32A39B98020- Mamonsu PostgreSQL Linuxsystem.cpu[idle]
42006AAE020- Mamonsu PostgreSQL Linuxsystem.cpu[iowait]
52FF5656020- Mamonsu PostgreSQL Linuxsystem.cpu[irq]
62F6CB93020- Mamonsu PostgreSQL Linuxsystem.cpu[softirq]
PostgreSQL Statements: Bytes9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.stat[read_bytes]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat[write_bytes]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat[dirty_bytes]
PostgreSQL Statements: Spent Time9002000.0100.0111100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.stat[read_time]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat[write_time]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat[other_time]
PostgreSQL Statements: WAL Statistics9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.stat[wal_bytes]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.stat[wal_records]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat[wal_fpi]
PostgreSQL Wait Sampling: Locks by Type9002000.0100.0111100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.all_lock[lwlock]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.all_lock[hwlock]
2200B0B8020- Mamonsu PostgreSQL Linuxpgsql.all_lock[buffer]
329C8A4E020- Mamonsu PostgreSQL Linuxpgsql.all_lock[extension]
42F6CB93020- Mamonsu PostgreSQL Linuxpgsql.all_lock[client]
523B415A020- Mamonsu PostgreSQL Linuxpgsql.all_lock[other]
PostgreSQL Wait Sampling: Heavyweight Locks9002000.0100.0111100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.hwlock[relation]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.hwlock[extend]
22F6CB93020- Mamonsu PostgreSQL Linuxpgsql.hwlock[page]
32006AAE020- Mamonsu PostgreSQL Linuxpgsql.hwlock[tuple]
4200B0B8020- Mamonsu PostgreSQL Linuxpgsql.hwlock[transactionid]
52793F5D020- Mamonsu PostgreSQL Linuxpgsql.hwlock[virtualxid]
629C8A4E020- Mamonsu PostgreSQL Linuxpgsql.hwlock[speculative_token]
72A39B98020- Mamonsu PostgreSQL Linuxpgsql.hwlock[object]
8252768F020- Mamonsu PostgreSQL Linuxpgsql.hwlock[userlock]
92FE9430020- Mamonsu PostgreSQL Linuxpgsql.hwlock[advisory]
PostgreSQL Wait Sampling: Lightweight Locks9002000.0100.0111100.00.0000002793F5D020- Mamonsu PostgreSQL Linuxpgsql.lwlock[xid]
1200B0B8020- Mamonsu PostgreSQL Linuxpgsql.lwlock[autovacuum]
2287C2B9020- Mamonsu PostgreSQL Linuxpgsql.lwlock[wal]
32006AAE020- Mamonsu PostgreSQL Linuxpgsql.lwlock[clog]
423B415A020- Mamonsu PostgreSQL Linuxpgsql.lwlock[replication]
529C8A4E020- Mamonsu PostgreSQL Linuxpgsql.lwlock[logical_replication]
62F6CB93020- Mamonsu PostgreSQL Linuxpgsql.lwlock[buffer]
72A39B98020- Mamonsu PostgreSQL Linuxpgsql.lwlock[other]
+
\ No newline at end of file
diff --git a/packaging/conf/template_agent.xml b/packaging/conf/template_agent.xml
index 93fa3aca..5d61f5ac 100644
--- a/packaging/conf/template_agent.xml
+++ b/packaging/conf/template_agent.xml
@@ -21,12 +21,12 @@
Mamonsu PostgreSQL Linux
- - PostgreSQL Archiver: Files in archive_status Need to Archive Count000pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Files Need to Archive Size000pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]73650153b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Archived Files Count000pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Attempts to Archive Files Count000pgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written During Checkpoints000pgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written000pgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Number of bgwriter Stopped by Max Write Count000pgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written Directly by a Backend000pgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Times a Backend Execute Its Own Fsync000pgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Allocated000pgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by Timeout (in hour)000pgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]7365030001000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by WAL (in hour)000pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]7365030001000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Write Time000pgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Sync Time000pgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Total User Connections000pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Waiting User Connections000pgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Max Connections000pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Active User Connections000pgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle User Connections000pgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction User Connections000pgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction (Aborted) User Connections000pgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Fastpath Function Call User Connections000pgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Disabled User Connections000pgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Other Connections000pgsql.connections.other[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Count of Autovacuum Workers000pgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]7365030000000100Mamonsu PostgreSQL Linux
- System: Block Devices Read Requests000system.disk.all_read736501501000100Mamonsu PostgreSQL Linux
- System: Block Devices Write Requests000system.disk.all_write736501501000100Mamonsu PostgreSQL Linux
- System: Block Devices Read byte/s000system.disk.all_read_b736501501000100Mamonsu PostgreSQL Linux
- System: Block Devices Write byte/s000system.disk.all_write_b736501501000100Mamonsu PostgreSQL Linux
- Mamonsu: Plugin Keep Alive000mamonsu.plugin.keepalive736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Transactions Committed000pgsql.transactions.committed[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Hit000pgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Read000pgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Conflict Events000pgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]736501502000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Deadlock Events000pgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]736501502000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Rollback Events000pgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Bytes Written000pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]73650150b2000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Files Created000pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]736501502000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Deleted000pgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Fetched000pgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Inserted000pgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Returned000pgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Updated000pgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: checksum_failures Events000pgsql.events.checksum_failures[{$PG_CONNINFO},{$PG_PATH}]736501502000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- System: Load Average Over 1 Minute000system.la.1736501500000100Mamonsu PostgreSQL Linux
- System: Active - Memory Recently Used000system.memory.active73650153b0000100Mamonsu PostgreSQL Linux
- System: Available - Free Memory000system.memory.available73650153b0000100Mamonsu PostgreSQL Linux
- System: Buffers - Block Device Cache and Dirty000system.memory.buffers73650153b0000100Mamonsu PostgreSQL Linux
- System: Cached - Parked File Data (file content) Cache000system.memory.cached73650153b0000100Mamonsu PostgreSQL Linux
- System: Committed AS - Total Committed Memory000system.memory.committed73650153b0000100Mamonsu PostgreSQL Linux
- System: Inactive - Memory Not Currently Used000system.memory.inactive73650153b0000100Mamonsu PostgreSQL Linux
- System: Mapped - All mmap()ed Pages000system.memory.mapped73650153b0000100Mamonsu PostgreSQL Linux
- System: PageTables - Map bt Virtual and Physical000system.memory.page_tables73650153b0000100Mamonsu PostgreSQL Linux
- System: Slab - Kernel Used Memory (inode cache)000system.memory.slab73650153b0000100Mamonsu PostgreSQL Linux
- System: Swap - Swap Space Used000system.memory.swap73650153b0000100Mamonsu PostgreSQL Linux
- System: SwapCached - Fetched unmod Yet Swap Pages000system.memory.swap_cache73650153b0000100Mamonsu PostgreSQL Linux
- System: Total - All Memory000system.memory.total73650153b0000100Mamonsu PostgreSQL Linux
- System: Unused - Wasted Memory000system.memory.unused73650153b0000100Mamonsu PostgreSQL Linux
- System: Used - User-Space Applications000system.memory.used73650153b0000100Mamonsu PostgreSQL Linux
- System: VMallocUsed - vmaloc() Allocated by Kernel000system.memory.vmalloc_used73650153b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold000pgsql.memory_leak_diagnostic.count_diff[]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold, text of message000pgsql.memory_leak_diagnostic.msg_text[]736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Age of the Oldest XID000pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: the Oldest Transaction Running Time in sec000pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}]73650150s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Number of Parallel Queries Being Executed Now000pgsql.parallel.queries[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- System: Opened Files000system.open_files736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Size000pgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]73650150b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Twice Used Size000pgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]73650150b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Dirty Size000pgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]73650150b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Ping000pgsql.ping[{$PG_CONNINFO},{$PG_PATH}]7365050ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Cache Hit Ratio1500pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]73650600%00001last(pgsql.blocks[hit])*100/(last(pgsql.blocks[hit])+last(pgsql.blocks[read]))00Mamonsu PostgreSQL Linux
- PostgreSQL Health: Service Uptime000pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]7365050unixtime0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Server Version000pgsql.version[{$PG_CONNINFO},{$PG_PATH}]73650540000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Read Only Queries000pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: SELECT FOR SHARE and SELECT FOR UPDATE000pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Write Queries000pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY000pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: CREATE INDEX000pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application000pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application or Some Operations on System Catalogs000pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE000pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: Number of Prepared Transactions000pgsql.prepared.count736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: the Oldest Prepared Transaction Running Time in sec000pgsql.prepared.oldest736501500000100Mamonsu PostgreSQL Linux
- System: Processes in State Running000system.processes.running736501500000100Mamonsu PostgreSQL Linux
- System: Processes in State Blocked000system.processes.blocked736501500000100Mamonsu PostgreSQL Linux
- System: Processes Forkrate000system.processes.forkrate736501501000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by Normal Programs and Daemons000system.cpu.user736501501000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by nice(1)d Programs000system.cpu.nice736501501000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by the Kernel in System Activities000system.cpu.system736501501000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Idle000system.cpu.idle736501501000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Waiting for I/O Operations000system.cpu.iowait736501501000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Interrupts000system.cpu.irq736501501000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Batched Interrupts000system.cpu.softirq736501501000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Streaming Replication Lag000pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Count Non-Active Replication Slots000pgsql.replication.non_active_slots[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read bytes/s000pgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write bytes/s000pgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Dirty bytes/s000pgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read IO Time000pgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write IO Time000pgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Other (mostly CPU) Time000pgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Files000pgsql.stat.wal_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Records000pgsql.stat.wal_records[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Full Page Writes000pgsql.stat.wal_fpi[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Nnumber of Times pg_stat_statements.max Was Exceeded000pgsql.stat_info.dealloc[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Last Statistics Reset Time000pgsql.stat_info.stats_reset[{$PG_CONNINFO},{$PG_PATH}]73650600unixtime1000100Mamonsu PostgreSQL Linux
- System: Uptime000system.uptime73650153uptime0000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Lightweight Locks000pgsql.all_lock[lwlock]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Heavyweight Locks000pgsql.all_lock[hwlock]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Buffer Locks000pgsql.all_lock[buffer]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Extension Locks000pgsql.all_lock[extension]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Client Locks000pgsql.all_lock[client]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Other Locks (e.g. IPC, Timeout, IO)000pgsql.all_lock[other]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: XID Access Locks000pgsql.lwlock[xid]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Autovacuum Locks000pgsql.lwlock[autovacuum]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: WAL Access Locks000pgsql.lwlock[wal]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: CLOG Access Locks000pgsql.lwlock[clog]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Replication Locks000pgsql.lwlock[replication]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Logical Replication Locks000pgsql.lwlock[logical_replication]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Buffer Operations Locks000pgsql.lwlock[buffer]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Other Operations Lightweight Locks000pgsql.lwlock[other]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Relation000pgsql.hwlock[relation]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Extend a Relation Locks000pgsql.hwlock[extend]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Page000pgsql.hwlock[page]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Tuple000pgsql.hwlock[tuple]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Transaction to Finish Locks000pgsql.hwlock[transactionid]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Virtual XID Locks000pgsql.hwlock[virtualxid]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Speculative Insertion Locks000pgsql.hwlock[speculative_token]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on Database Object000pgsql.hwlock[object]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Userlocks000pgsql.hwlock[userlock]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Advisory User Locks000pgsql.hwlock[advisory]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Speed000pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]73650150Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Count of WAL Files000pgsql.wal.count[{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Records Generated000pgsql.wal.records.count[{$PG_CONNINFO},{$PG_PATH}]736506031000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Full Page Images Generated000pgsql.wal.fpi.count[{$PG_CONNINFO},{$PG_PATH}]736506031000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Buffers Full000pgsql.wal.buffers_full736506031000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Time (ms)000pgsql.wal.write_time736506031000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Time (ms)000pgsql.wal.sync_time736506031000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Duty (%)1500pgsql.wal.sync_duty73650600%00001last(pgsql.wal.sync_time)/10/1500Mamonsu PostgreSQL Linux
- PostgreSQL Databases Discovery060000007pgsql.database.discovery[{$PG_CONNINFO},{$PG_PATH}]{#DATABASE}.*8A0PostgreSQL Databases {#DATABASE}: size000pgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]736503003b0000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Max datfrozenxid Age in: {#DATABASE}000pgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Bloating Tables in {#DATABASE}000pgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Invalid Indexes in {#DATABASE}000pgsql.database.invalid_indexes[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pgsql.database.invalid_indexes[{#DATABASE}].last()}>0PostgreSQL Databases: invalid indexes in {#DATABASE} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030PostgreSQL Databases: {#DATABASE} size9002000.0100.0111100.00.00000028B817C020- Mamonsu PostgreSQL Linuxpgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Databases: {#DATABASE} Bloating Overview9002000.0100.0110100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Databases: {#DATABASE} Max age(datfrozenxid)9002000.0100.0110100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
VFS Discovery060000007system.vfs.discovery{#MOUNTPOINT}.*8A0System: Mount Point {#MOUNTPOINT}: Used000system.vfs.used[{#MOUNTPOINT}]73650153b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT}: Free000system.vfs.free[{#MOUNTPOINT}]73650153b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT}: Free in Percents000system.vfs.percent_free[{#MOUNTPOINT}]73650150%0000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:system.vfs.percent_free[{#MOUNTPOINT}].last()}<10Free disk space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030System: Mount Point Overview {#MOUNTPOINT}9002000.0100.0111100.00.0000000E57862020- Mamonsu PostgreSQL Linuxsystem.vfs.used[{#MOUNTPOINT}]
10578159020- Mamonsu PostgreSQL Linuxsystem.vfs.free[{#MOUNTPOINT}]
System: Block Devices Discovery060000007system.disk.discovery{#BLOCKDEVICE}.*8A0System: Block Device {#BLOCKDEVICE} Utilization000system.disk.utilization[{#BLOCKDEVICE}]73650150%1000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read Operations000system.disk.read[{#BLOCKDEVICE}]736501501000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write Operations000system.disk.write[{#BLOCKDEVICE}]736501501000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read byte/s000system.disk.read_b[{#BLOCKDEVICE}]73650150b1000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write byte/s000system.disk.write_b[{#BLOCKDEVICE}]73650150b1000100Mamonsu PostgreSQL LinuxSystem: Block Device Overview {#BLOCKDEVICE} operations9002000.0100.0110100.00.00000007EB29B020- Mamonsu PostgreSQL Linuxsystem.disk.read[{#BLOCKDEVICE}]
10793F5D020- Mamonsu PostgreSQL Linuxsystem.disk.write[{#BLOCKDEVICE}]
20F6CB93120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
System: Block Device Overview {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.00000007EB29B020- Mamonsu PostgreSQL Linuxsystem.disk.read_b[{#BLOCKDEVICE}]
10793F5D020- Mamonsu PostgreSQL Linuxsystem.disk.write_b[{#BLOCKDEVICE}]
20F6CB93120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Net Iface Discovery060000007system.net.discovery{#NETDEVICE}.*8A0System: Network Device {#NETDEVICE} RX bytes/s000system.net.rx_bytes[{#NETDEVICE}]73650150b1000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX errors/s000system.net.rx_errs[{#NETDEVICE}]736501501000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX drops/s000system.net.rx_drop[{#NETDEVICE}]736501501000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX bytes/s000system.net.tx_bytes[{#NETDEVICE}]73650150b1000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX errors/s000system.net.tx_errs[{#NETDEVICE}]736501501000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX drops/s000system.net.tx_drop[{#NETDEVICE}]736501501000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE}9002000.0100.0110100.00.00000007EB29B020- Mamonsu PostgreSQL Linuxsystem.net.rx_bytes[{#NETDEVICE}]
10793F5D020- Mamonsu PostgreSQL Linuxsystem.net.tx_bytes[{#NETDEVICE}]
pg_probackup discovery060000007pg_probackup.discovery[]{#BACKUPDIR}.*8A0pg_probackup dir {#BACKUPDIR}: size000pg_probackup.dir.size[{#BACKUPDIR}]736503003b0000100Mamonsu PostgreSQL Linuxpg_probackup dir {#BACKUPDIR}: error000pg_probackup.dir.error[{#BACKUPDIR}]7365030040000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pg_probackup.dir.error[{#BACKUPDIR}].str(ok)}<>1Error in pg_probackup dir {#BACKUPDIR} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030pg_probackup backup dir: {#BACKUPDIR} size9002000.0100.0111100.00.00000008B817C020- Mamonsu PostgreSQL Linuxpg_probackup.dir.size[{#BACKUPDIR}]
PostgreSQL Relations Sizes Discovery060000007pgsql.relation.size[{$PG_CONNINFO},{$PG_PATH}]{#RELATIONNAME}.*8A0PostgreSQL Relation Size: {#RELATIONNAME}000pgsql.relation.size[{#RELATIONNAME},{$PG_CONNINFO},{$PG_PATH}]736503003b0000100Mamonsu PostgreSQL LinuxPostgreSQL Relation Size: {#RELATIONNAME}9002000.0100.0111100.00.00000028B817C020- Mamonsu PostgreSQL Linuxpgsql.relation.size[{#RELATIONNAME},{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Replication Lag Discovery060000007pgsql.replication.discovery[{$PG_CONNINFO},{$PG_PATH}]{#APPLICATION_NAME}.*8A0PostgreSQL Replication: {#APPLICATION_NAME} Send Lag - Time elapsed sending recent WAL locally000pgsql.replication.send_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Receive Lag - Time elapsed between receiving recent WAL locally and receiving notification that this standby server has flushed it000pgsql.replication.receive_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Write Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written it000pgsql.replication.write_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Flush Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written and flushed it000pgsql.replication.flush_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Replay Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written, flushed and applied000pgsql.replication.replay_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Delta of Total Lag000pgsql.replication.total_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: Delta of Total Lag for {#APPLICATION_NAME}9002000.0100.0110100.00.00000008B817C020- Mamonsu PostgreSQL Linuxpgsql.replication.total_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]
- Mamonsu Overview2505001500011010003PostgreSQL Connections: OverviewMamonsu PostgreSQL Linux05001501011010003PostgreSQL pg_buffercache: Shared BufferMamonsu PostgreSQL Linux05001500111010003System: CPU Time SpentMamonsu PostgreSQL Linux05001501111010003System: Server Free/Used Memory OverviewMamonsu PostgreSQL Linux05001500211010003PostgreSQL Autovacuum: Count of Autovacuum WorkersMamonsu PostgreSQL Linux05001501211010003PostgreSQL Instance: TuplesMamonsu PostgreSQL Linux05001500311010003PostgreSQL bgwriter: BuffersMamonsu PostgreSQL Linux05001501311010003PostgreSQL bgwriter: EventsMamonsu PostgreSQL Linux05001500411010003PostgreSQL Checkpoints: Count (in hour)Mamonsu PostgreSQL Linux05001501411010003PostgreSQL Checkpoints: Write/SyncMamonsu PostgreSQL LinuxMamonsu PostgreSQL Instance2515001500011010003pgsql.ping[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501011010003pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500111010003pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux05001501111010003PostgreSQL Instance: EventsMamonsu PostgreSQL Linux15001500211010003pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501211010003pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL WAL2505001500011010003PostgreSQL Archiver: Archive StatusMamonsu PostgreSQL Linux15001501011010003pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500111010003pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501111010003pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL Locks3513301000011010003pgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301001011010003pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301002011010003pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301000111010003pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301001111010003pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301002111010003pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301000211010003pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301001211010003pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301002211010003pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL Transactions2515001500011010003pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501011010003pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500111010003pgsql.prepared.countMamonsu PostgreSQL Linux15001501111010003pgsql.prepared.oldestMamonsu PostgreSQL LinuxMamonsu System (Linux)2505001500011010003System: Block Devices Read/Write BytesMamonsu PostgreSQL Linux05001501011010003System: Block Devices Read/Write OperationsMamonsu PostgreSQL Linux05001500111010003System: Processes OverviewMamonsu PostgreSQL Linux
- {$PG_CONNINFO}-qAt -p 5433 -U postgres {$PG_PATH}/opt/pgpro/std-10/bin/psql
+ - PostgreSQL Archiver: Files in archive_status Need to Archive Count000pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Files Need to Archive Size000pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]73650603b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Archived Files Count000pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Attempts to Archive Files Count000pgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Count of Autovacuum Workers000pgsql.autovacuum.count[{$PG_CONNINFO},{$PG_PATH}]736503000000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Utilization per 30 seconds000pgsql.autovacuum.utilization[{$PG_CONNINFO},{$PG_PATH}]73650300%0000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Average Utilization per 5 minutes1500pgsql.autovacuum.utilization.avg5[{$PG_CONNINFO},{$PG_PATH}]73650300%00001avg(pgsql.autovacuum.utilization[], 5m)00Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Average Utilization per 15 minutes1500pgsql.autovacuum.utilization.avg15[{$PG_CONNINFO},{$PG_PATH}]73650300%00001avg(pgsql.autovacuum.utilization[], 15m)00Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Average Utilization per 30 minutes1500pgsql.autovacuum.utilization.avg30[{$PG_CONNINFO},{$PG_PATH}]73650300%00001avg(pgsql.autovacuum.utilization[], 30m)00Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written During Checkpoints000pgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written000pgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Number of bgwriter Stopped by Max Write Count000pgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written Directly by a Backend000pgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Times a Backend Execute Its Own Fsync000pgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Allocated000pgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by Timeout (in hour)000pgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]7365030001000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by WAL (in hour)000pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]7365030001000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Write Time000pgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Sync Time000pgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]736503000ms1000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Total User Connections000pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Waiting User Connections000pgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Max Connections000pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Active User Connections000pgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle User Connections000pgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction User Connections000pgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction (Aborted) User Connections000pgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Fastpath Function Call User Connections000pgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Disabled User Connections000pgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Other Connections000pgsql.connections.other[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- System: Block Devices Read Requests000system.disk.all_read736506001000100Mamonsu PostgreSQL Linux
- System: Block Devices Write Requests000system.disk.all_write736506001000100Mamonsu PostgreSQL Linux
- System: Block Devices Read byte/s000system.disk.all_read_b736506001000100Mamonsu PostgreSQL Linux
- System: Block Devices Write byte/s000system.disk.all_write_b736506001000100Mamonsu PostgreSQL Linux
- Mamonsu: Plugin Keep Alive000mamonsu.plugin.keepalive736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Transactions Committed000pgsql.transactions.committed[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Rollback Events000pgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Hit000pgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Read000pgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Conflict Events000pgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]736506002000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Deadlock Events000pgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]736506002000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Bytes Written000pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]73650600b2000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Files Created000pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]736506002000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Deleted000pgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Fetched000pgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Inserted000pgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Returned000pgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Updated000pgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: checksum_failures Events000pgsql.events.checksum_failures[{$PG_CONNINFO},{$PG_PATH}]736506002000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode000pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- System: Load Average Over 1 Minute000system.la.1736506000000100Mamonsu PostgreSQL Linux
- System: Active - Memory Recently Used000system.memory.active73650603b0000100Mamonsu PostgreSQL Linux
- System: Available - Free Memory000system.memory.available73650603b0000100Mamonsu PostgreSQL Linux
- System: Buffers - Block Device Cache and Dirty000system.memory.buffers73650603b0000100Mamonsu PostgreSQL Linux
- System: Cached - Parked File Data (file content) Cache000system.memory.cached73650603b0000100Mamonsu PostgreSQL Linux
- System: Committed AS - Total Committed Memory000system.memory.committed73650603b0000100Mamonsu PostgreSQL Linux
- System: Inactive - Memory Not Currently Used000system.memory.inactive73650603b0000100Mamonsu PostgreSQL Linux
- System: Mapped - All mmap()ed Pages000system.memory.mapped73650603b0000100Mamonsu PostgreSQL Linux
- System: PageTables - Map bt Virtual and Physical000system.memory.page_tables73650603b0000100Mamonsu PostgreSQL Linux
- System: Slab - Kernel Used Memory (inode cache)000system.memory.slab73650603b0000100Mamonsu PostgreSQL Linux
- System: Swap - Swap Space Used000system.memory.swap73650603b0000100Mamonsu PostgreSQL Linux
- System: SwapCached - Fetched unmod Yet Swap Pages000system.memory.swap_cache73650603b0000100Mamonsu PostgreSQL Linux
- System: Total - All Memory000system.memory.total73650603b0000100Mamonsu PostgreSQL Linux
- System: Unused - Wasted Memory000system.memory.unused73650603b0000100Mamonsu PostgreSQL Linux
- System: Used - User-Space Applications000system.memory.used73650603b0000100Mamonsu PostgreSQL Linux
- System: VMallocUsed - vmaloc() Allocated by Kernel000system.memory.vmalloc_used73650603b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold000pgsql.memory_leak_diagnostic.count_diff[]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold, text of message000pgsql.memory_leak_diagnostic.msg_text[]736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Age of the Oldest XID000pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: the Oldest Transaction Running Time in sec000pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}]73650600s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Number of Parallel Queries Being Executed Now000pgsql.parallel.queries[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- System: Opened Files000system.open_files736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Size000pgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Twice Used Size000pgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Dirty Size000pgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Ping000pgsql.ping[{$PG_CONNINFO},{$PG_PATH}]7365050ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Cache Hit Ratio1500pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]73650600%00001last(pgsql.blocks[hit])*100/(last(pgsql.blocks[hit])+last(pgsql.blocks[read]))00Mamonsu PostgreSQL Linux
- PostgreSQL Health: Service Uptime000pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]7365050unixtime0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Server Version000pgsql.version[{$PG_CONNINFO},{$PG_PATH}]73650540000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Read Only Queries000pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: SELECT FOR SHARE and SELECT FOR UPDATE000pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Write Queries000pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY000pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: CREATE INDEX000pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application000pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application or Some Operations on System Catalogs000pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE000pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: Number of Prepared Transactions000pgsql.prepared.count736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: the Oldest Prepared Transaction Running Time in sec000pgsql.prepared.oldest736506000000100Mamonsu PostgreSQL Linux
- System: Processes in State Running000system.processes.running736506000000100Mamonsu PostgreSQL Linux
- System: Processes in State Blocked000system.processes.blocked736506000000100Mamonsu PostgreSQL Linux
- System: Processes Forkrate000system.processes.forkrate736506001000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by Normal Programs and Daemons000system.cpu.user736506001000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by nice(1)d Programs000system.cpu.nice736506001000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by the Kernel in System Activities000system.cpu.system736506001000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Idle000system.cpu.idle736506001000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Waiting for I/O Operations000system.cpu.iowait736506001000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Interrupts000system.cpu.irq736506001000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Batched Interrupts000system.cpu.softirq736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Streaming Replication Lag000pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Count Non-Active Replication Slots000pgsql.replication.non_active_slots[{$PG_CONNINFO},{$PG_PATH}]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read bytes/s000pgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write bytes/s000pgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Dirty bytes/s000pgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read IO Time000pgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write IO Time000pgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Other (mostly CPU) Time000pgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]73650600s1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Files000pgsql.stat.wal_bytes[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Records000pgsql.stat.wal_records[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Full Page Writes000pgsql.stat.wal_fpi[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Nnumber of Times pg_stat_statements.max Was Exceeded000pgsql.stat_info.dealloc[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Last Statistics Reset Time000pgsql.stat_info.stats_reset[{$PG_CONNINFO},{$PG_PATH}]73650600unixtime1000100Mamonsu PostgreSQL Linux
- System: Uptime000system.uptime73650603uptime0000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Speed000pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]73650600Bps1000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Count of WAL Files000pgsql.wal.count[{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Records Generated000pgsql.wal.records.count[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Full Page Images Generated000pgsql.wal.fpi.count[{$PG_CONNINFO},{$PG_PATH}]736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Buffers Full000pgsql.wal.buffers_full736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Time (ms)000pgsql.wal.write_time736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Time (ms)000pgsql.wal.sync_time736506001000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Duty (%)1500pgsql.wal.sync_duty73650600%00001last(pgsql.wal.sync_time)/1000Mamonsu PostgreSQL Linux
+ PostgreSQL Databases Discovery060000007pgsql.database.discovery[{$PG_CONNINFO},{$PG_PATH}]{#DATABASE}.*8A0PostgreSQL Databases: {#DATABASE} size000pgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]736503003b0000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Max datfrozenxid Age in: {#DATABASE}000pgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Bloating Tables in {#DATABASE}000pgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Invalid Indexes in {#DATABASE}000pgsql.database.invalid_indexes[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]7365030000000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pgsql.database.invalid_indexes[{#DATABASE}].last()}>0PostgreSQL Databases: invalid indexes in {#DATABASE} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030PostgreSQL Databases: {#DATABASE} size9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.database.size[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Databases: {#DATABASE} Bloating Overview9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.database.bloating_tables[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacuum.count[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Databases: {#DATABASE} Max age(datfrozenxid)9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.database.max_age[{#DATABASE},{$PG_CONNINFO},{$PG_PATH}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacuum.count[{$PG_CONNINFO},{$PG_PATH}]
System: VFS Discovery060000007system.vfs.discovery{#MOUNTPOINT}.*8A0System: Mount Point {#MOUNTPOINT} Used000system.vfs.used[{#MOUNTPOINT}]73650603b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free000system.vfs.free[{#MOUNTPOINT}]73650603b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free in Percents000system.vfs.percent_free[{#MOUNTPOINT}]73650600%0000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:system.vfs.percent_free[{#MOUNTPOINT}].last()}<{$VFS_PERCENT_FREE}System: free disk space less than 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030System: Mount Point Overview {#MOUNTPOINT}9002000.0100.0111100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxsystem.vfs.used[{#MOUNTPOINT}]
1200CC00020- Mamonsu PostgreSQL Linuxsystem.vfs.free[{#MOUNTPOINT}]
System: Block Devices Discovery060000007system.disk.discovery{#BLOCKDEVICE}.*8A0System: Block Device {#BLOCKDEVICE} Utilization000system.disk.utilization[{#BLOCKDEVICE}]73650600%1000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read Operations000system.disk.read[{#BLOCKDEVICE}]736506001000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write Operations000system.disk.write[{#BLOCKDEVICE}]736506001000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read byte/s000system.disk.read_b[{#BLOCKDEVICE}]73650600b1000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write byte/s000system.disk.write_b[{#BLOCKDEVICE}]73650600b1000100Mamonsu PostgreSQL LinuxSystem: Block Device Overview {#BLOCKDEVICE} operations9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.read[{#BLOCKDEVICE}]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.write[{#BLOCKDEVICE}]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
System: Block Device Overview {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.read_b[{#BLOCKDEVICE}]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.write_b[{#BLOCKDEVICE}]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
System: net Iface Discovery060000007system.net.discovery{#NETDEVICE}.*8A0System: Network Device {#NETDEVICE} RX bytes/s000system.net.rx_bytes[{#NETDEVICE}]73650600b1000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX errors/s000system.net.rx_errs[{#NETDEVICE}]736506001000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX drops/s000system.net.rx_drop[{#NETDEVICE}]736506001000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX bytes/s000system.net.tx_bytes[{#NETDEVICE}]73650600b1000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX errors/s000system.net.tx_errs[{#NETDEVICE}]736506001000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX drops/s000system.net.tx_drop[{#NETDEVICE}]736506001000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE}9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxsystem.net.rx_bytes[{#NETDEVICE}]
12793F5D020- Mamonsu PostgreSQL Linuxsystem.net.tx_bytes[{#NETDEVICE}]
pg_probackup Discovery060000007pg_probackup.discovery[]{#BACKUPDIR}.*8A0pg_probackup dir {#BACKUPDIR}: Size000pg_probackup.dir.size[{#BACKUPDIR}]736503003b0000100Mamonsu PostgreSQL Linuxpg_probackup dir {#BACKUPDIR}: Error000pg_probackup.dir.error[{#BACKUPDIR}]7365030040000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pg_probackup.dir.error[{#BACKUPDIR}].str(ok)}<>1pg_probackup: error in dir {#BACKUPDIR} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030pg_probackup Backup dir: {#BACKUPDIR} Size9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpg_probackup.dir.size[{#BACKUPDIR}]
PostgreSQL Relations Sizes Discovery060000007pgsql.relation.size[{$PG_CONNINFO},{$PG_PATH}]{#RELATIONNAME}.*8A0PostgreSQL Relation Size: {#RELATIONNAME}000pgsql.relation.size[{#RELATIONNAME},{$PG_CONNINFO},{$PG_PATH}]73650153b0000100Mamonsu PostgreSQL LinuxPostgreSQL Relation Size: {#RELATIONNAME}9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.relation.size[{#RELATIONNAME},{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Replication Lag Discovery060000007pgsql.replication.discovery[{$PG_CONNINFO},{$PG_PATH}]{#APPLICATION_NAME}.*8A0PostgreSQL Replication: {#APPLICATION_NAME} Send Lag - Time elapsed sending recent WAL locally000pgsql.replication.send_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Receive Lag - Time elapsed between receiving recent WAL locally and receiving notification that this standby server has flushed it000pgsql.replication.receive_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Write Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written it000pgsql.replication.write_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Flush Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written and flushed it000pgsql.replication.flush_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Replay Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written, flushed and applied000pgsql.replication.replay_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Delta of Total Lag000pgsql.replication.total_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: Delta of Total Lag for {#APPLICATION_NAME}9002000.0100.0110100.00.0000000A39B98020- Mamonsu PostgreSQL Linuxpgsql.replication.total_lag[{#APPLICATION_NAME},{$PG_CONNINFO},{$PG_PATH}]
+ {$ARCHIVE_QUEUE_FILES}2{$MAX_CHECKPOINT_BY_WAL_IN_HOUR}12{$CONNECTIONS_PERCENT}90{$VFS_PERCENT_FREE}10{$VFS_INODE_PERCENT_FREE}10{$MAMONSU_MAX_MEMORY_USAGE}41943040{$MAX_XID_AGE}18000000{$MAX_TRANSACTION_TIME}18000{$PG_UPTIME}600{$CACHE_HIT_RATIO_PERCENT}80{$MAX_PREPARED_TRANSACTION_TIME}18000{$CRITICAL_LAG_SECONDS}300{$SYSTEM_UPTIME}300
+ Mamonsu Overview2505001500011010003PostgreSQL Connections: OverviewMamonsu PostgreSQL Linux05001501011010003PostgreSQL Instance: Transactions RateMamonsu PostgreSQL Linux05001500111010003System: CPU Time SpentMamonsu PostgreSQL Linux05001501111010003System: Server Free/Used Memory OverviewMamonsu PostgreSQL Linux05001500211010003PostgreSQL Autovacuum: Count of Autovacuum WorkersMamonsu PostgreSQL Linux05001501211010003PostgreSQL Instance: TuplesMamonsu PostgreSQL Linux05001500311010003PostgreSQL bgwriter: BuffersMamonsu PostgreSQL Linux05001501311010003PostgreSQL bgwriter: EventsMamonsu PostgreSQL Linux05001500411010003PostgreSQL Checkpoints: Count (in hour)Mamonsu PostgreSQL Linux05001501411010003PostgreSQL Checkpoints: Write/SyncMamonsu PostgreSQL LinuxMamonsu PostgreSQL Instance2515001500011010003pgsql.ping[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501011010003pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500111010003pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux05001501111010003PostgreSQL Instance: EventsMamonsu PostgreSQL Linux15001500211010003pgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501211010003pgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL WAL2505001500011010003PostgreSQL Archiver: Archive StatusMamonsu PostgreSQL Linux15001501011010003pgsql.wal.write[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500111010003pgsql.archive_command.size_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501111010003pgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500211010003pgsql.wal.write_timeMamonsu PostgreSQL Linux15001501211010003pgsql.wal.sync_timeMamonsu PostgreSQL LinuxMamonsu PostgreSQL Locks3513301000011010003pgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301001011010003pgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301002011010003pgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301000111010003pgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301001111010003pgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301002111010003pgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301000211010003pgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301001211010003pgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux13301002211010003pgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL Transactions2515001500011010003pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001501011010003pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}]Mamonsu PostgreSQL Linux15001500111010003pgsql.prepared.countMamonsu PostgreSQL Linux15001501111010003pgsql.prepared.oldestMamonsu PostgreSQL LinuxMamonsu System (Linux)2505001500011010003System: Block Devices Read/Write BytesMamonsu PostgreSQL Linux05001501011010003System: Block Devices Read/Write OperationsMamonsu PostgreSQL Linux05001500111010003System: Processes OverviewMamonsu PostgreSQL Linux
- {Mamonsu PostgreSQL Linux:pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}].last()}>2PostgreSQL Archiver: count files need to archive on {HOSTNAME} more than 2030{Mamonsu PostgreSQL Linux:pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}].last()}>12PostgreSQL Checkpoints: required checkpoints occurs to frequently on {HOSTNAME}030 {Mamonsu PostgreSQL Linux:pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}].last()}/{Mamonsu PostgreSQL Linux:pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}].last()}*100 >90PostgreSQL Connections: too many connections on {HOSTNAME} (total connections more than 90% of max_connections)030{Mamonsu PostgreSQL Linux:mamonsu.plugin.keepalive.nodata(180)}=1Mamonsu nodata from {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.server_mode.change()}>0PostgreSQL Instance: server mode has been changed on {HOSTNAME} to {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.memory_leak_diagnostic.msg_text[].strlen()}>1PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold on {HOSTNAME}. {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}].last()}>18000000PostgreSQL Transactions: the oldest XID is too big on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}].last()}>18000PostgreSQL Transactions: running transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}].last()}<600PostgreSQL Health: service has been restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}].last()}<80PostgreSQL Health: cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.ping[{$PG_CONNINFO},{$PG_PATH}].nodata(180)}=1PostgreSQL Health: no ping from PostgreSQL for 3 minutes on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.prepared.oldest.last()}>60PostgreSQL Prepared Transactions: prepared transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:system.processes.forkrate.min(5m)}>500Process fork-rate to frequently on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}].last()}>300PostgreSQL streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.replication.non_active_slots[{$PG_CONNINFO},{$PG_PATH}].last()}>0PostgreSQL number of non-active replication slots on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:system.uptime.last()}<300System was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030
- PostgreSQL Archiver: Archive Status9002000.0100.0110100.00.00000029C8A4E020- Mamonsu PostgreSQL Linuxpgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]
12578159020- Mamonsu PostgreSQL Linuxpgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]
22E57862020- Mamonsu PostgreSQL Linuxpgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL bgwriter: Buffers9002000.0100.0110100.00.0000002793F5D020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]
129C8A4E020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]
227EB29B020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]
323B415A020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL bgwriter: Events9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]
129C8A4E020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Checkpoints: Count (in hour)9002000.0100.0110100.00.0000002578159020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Checkpoints: Write/Sync9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]
129C8A4E020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Connections: Overview9002000.0100.0110100.00.0000002578159020- Mamonsu PostgreSQL Linuxpgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]
128B817C020- Mamonsu PostgreSQL Linuxpgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]
4200B0B8020- Mamonsu PostgreSQL Linuxpgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]
523B415A020- Mamonsu PostgreSQL Linuxpgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]
62E57862020- Mamonsu PostgreSQL Linuxpgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]
720082A5020- Mamonsu PostgreSQL Linuxpgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]
82FF3C47020- Mamonsu PostgreSQL Linuxpgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}]
927EB29B020- Mamonsu PostgreSQL Linuxpgsql.connections.other[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Autovacuum: Count of Autovacuum Workers9002000.0100.0110100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.autovacumm.count[{$PG_CONNINFO},{$PG_PATH}]
System: Block Devices Read/Write Operations9002000.0100.0110100.00.00000007EB29B020- Mamonsu PostgreSQL Linuxsystem.disk.all_read
10793F5D020- Mamonsu PostgreSQL Linuxsystem.disk.all_write
System: Block Devices Read/Write Bytes9002000.0100.0110100.00.00000007EB29B020- Mamonsu PostgreSQL Linuxsystem.disk.all_read_b
10793F5D020- Mamonsu PostgreSQL Linuxsystem.disk.all_write_b
PostgreSQL Instance: Blocks Rate9002000.0100.0110100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Transactions Rate9002000.0100.0110100.00.0000002578159020- Mamonsu PostgreSQL Linuxpgsql.transactions.committed[{$PG_CONNINFO},{$PG_PATH}]
12E57862020- Mamonsu PostgreSQL Linuxpgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Events9002000.0100.0110100.00.00000029C8A4E020- Mamonsu PostgreSQL Linuxpgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]
22793F5D020- Mamonsu PostgreSQL Linuxpgsql.events.checksum_failures[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Temp Files9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]
120082A5120- Mamonsu PostgreSQL Linuxpgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Tuples9002000.0100.0110100.00.00000023B415A020- Mamonsu PostgreSQL Linuxpgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]
127EB29B020- Mamonsu PostgreSQL Linuxpgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]
2200B0B8020- Mamonsu PostgreSQL Linuxpgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]
329C8A4E120- Mamonsu PostgreSQL Linuxpgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]
426A4F5F020- Mamonsu PostgreSQL Linuxpgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]
System: Server Memory Detailed Overview9004000.0100.0111100.00.000000090BD72020- Mamonsu PostgreSQL Linuxsystem.memory.active
10578159020- Mamonsu PostgreSQL Linuxsystem.memory.available
2000B0B8020- Mamonsu PostgreSQL Linuxsystem.memory.buffers
309C8A4E020- Mamonsu PostgreSQL Linuxsystem.memory.cached
4052768F020- Mamonsu PostgreSQL Linuxsystem.memory.committed
50001219020- Mamonsu PostgreSQL Linuxsystem.memory.inactive
609F1E28020- Mamonsu PostgreSQL Linuxsystem.memory.mapped
708B817C020- Mamonsu PostgreSQL Linuxsystem.memory.page_tables
80F6CB93020- Mamonsu PostgreSQL Linuxsystem.memory.slab
900082A5020- Mamonsu PostgreSQL Linuxsystem.memory.swap
1007EB29B020- Mamonsu PostgreSQL Linuxsystem.memory.swap_cache
110E57862020- Mamonsu PostgreSQL Linuxsystem.memory.total
1203B415A020- Mamonsu PostgreSQL Linuxsystem.memory.unused
130793F5D020- Mamonsu PostgreSQL Linuxsystem.memory.used
140CF6518020- Mamonsu PostgreSQL Linuxsystem.memory.vmalloc_used
System: Server Free/Used Memory Overview9004000.0100.0111100.00.0000001578159020- Mamonsu PostgreSQL Linuxsystem.memory.available
119C8A4E020- Mamonsu PostgreSQL Linuxsystem.memory.cached
24E57862020- Mamonsu PostgreSQL Linuxsystem.memory.total
31793F5D020- Mamonsu PostgreSQL Linuxsystem.memory.used
PostgreSQL pg_buffercache: Shared Buffer9002000.0100.0110100.00.0000002E57862020- Mamonsu PostgreSQL Linuxpgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]
127EB29B020- Mamonsu PostgreSQL Linuxpgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]
22793F5D020- Mamonsu PostgreSQL Linuxpgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL: Locks Sampling9002000.0100.0110100.00.0000002578159020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]
227EB29B020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]
420082A5020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]
5200B0B8020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]
629C8A4E020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]
72793F5D020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Prepared Transactions: Overview9002000.0100.0110100.00.00000028B817C020- Mamonsu PostgreSQL Linuxpgsql.prepared.count
129C8A4E120- Mamonsu PostgreSQL Linuxpgsql.prepared.oldest
System: Processes Overview9002000.0100.0110100.00.0000000578159020- Mamonsu PostgreSQL Linuxsystem.processes.running
10E57862020- Mamonsu PostgreSQL Linuxsystem.processes.blocked
209C8A4E120- Mamonsu PostgreSQL Linuxsystem.processes.forkrate
System: CPU Time Spent9002000.0100.0111100.00.0000000578159020- Mamonsu PostgreSQL Linuxsystem.cpu.user
10793F5D020- Mamonsu PostgreSQL Linuxsystem.cpu.nice
209C8A4E020- Mamonsu PostgreSQL Linuxsystem.cpu.system
308B817C020- Mamonsu PostgreSQL Linuxsystem.cpu.idle
400082A5020- Mamonsu PostgreSQL Linuxsystem.cpu.iowait
503B415A020- Mamonsu PostgreSQL Linuxsystem.cpu.irq
60F6CB93020- Mamonsu PostgreSQL Linuxsystem.cpu.softirq
PostgreSQL Statements: Bytes9002000.0100.0110100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Statements: Spend Time9002000.0100.0111100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Statements: WAL Statistics9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.stat.wal_bytes[{$PG_CONNINFO},{$PG_PATH}]
120082A5020- Mamonsu PostgreSQL Linuxpgsql.stat.wal_records[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat.wal_fpi[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Wait Sampling: Locks by Type9002000.0100.0111100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.all_lock[lwlock]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.all_lock[hwlock]
2200B0B8020- Mamonsu PostgreSQL Linuxpgsql.all_lock[buffer]
329C8A4E020- Mamonsu PostgreSQL Linuxpgsql.all_lock[extension]
42F6CB93020- Mamonsu PostgreSQL Linuxpgsql.all_lock[client]
523B415A020- Mamonsu PostgreSQL Linuxpgsql.all_lock[other]
PostgreSQL Wait Sampling: Heavyweight Locks9002000.0100.0111100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.hwlock[relation]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.hwlock[extend]
22F6CB93020- Mamonsu PostgreSQL Linuxpgsql.hwlock[page]
320082A5020- Mamonsu PostgreSQL Linuxpgsql.hwlock[tuple]
4200B0B8020- Mamonsu PostgreSQL Linuxpgsql.hwlock[transactionid]
52793F5D020- Mamonsu PostgreSQL Linuxpgsql.hwlock[virtualxid]
629C8A4E020- Mamonsu PostgreSQL Linuxpgsql.hwlock[speculative_token]
728B817C020- Mamonsu PostgreSQL Linuxpgsql.hwlock[object]
8252768F020- Mamonsu PostgreSQL Linuxpgsql.hwlock[userlock]
92FE9430020- Mamonsu PostgreSQL Linuxpgsql.hwlock[advisory]
PostgreSQL Wait Sampling: Lightweight Locks9002000.0100.0111100.00.0000002793F5D020- Mamonsu PostgreSQL Linuxpgsql.lwlock[xid]
1200B0B8020- Mamonsu PostgreSQL Linuxpgsql.lwlock[autovacuum]
227EB29B020- Mamonsu PostgreSQL Linuxpgsql.lwlock[wal]
320082A5020- Mamonsu PostgreSQL Linuxpgsql.lwlock[clog]
423B415A020- Mamonsu PostgreSQL Linuxpgsql.lwlock[replication]
529C8A4E020- Mamonsu PostgreSQL Linuxpgsql.lwlock[logical_replication]
62F6CB93020- Mamonsu PostgreSQL Linuxpgsql.lwlock[buffer]
728B817C020- Mamonsu PostgreSQL Linuxpgsql.lwlock[other]
+ {Mamonsu PostgreSQL Linux:pgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}].last()}>{$ARCHIVE_QUEUE_FILES}PostgreSQL Archiver: count files need to archive on {HOSTNAME} more than 2030{Mamonsu PostgreSQL Linux:pgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}].last()}>{$MAX_CHECKPOINT_BY_WAL_IN_HOUR}PostgreSQL Checkpoints: required checkpoints occurs too frequently on {HOSTNAME}030 {Mamonsu PostgreSQL Linux:pgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}].last()}/{Mamonsu PostgreSQL Linux:pgsql.connections.max_connections[{$PG_CONNINFO},{$PG_PATH}].last()}*100 >{$CONNECTIONS_PERCENT}PostgreSQL Connections: too many connections on {HOSTNAME} (total connections more than {$CONNECTIONS_PERCENT}% of max_connections)030{Mamonsu PostgreSQL Linux:mamonsu.plugin.keepalive.nodata(180)}=1Mamonsu health: nodata from {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.server_mode.change()}>0PostgreSQL Instance: server mode has been changed on {HOSTNAME} to {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.memory_leak_diagnostic.msg_text[].strlen()}>1PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold on {HOSTNAME}. {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.oldest.xid_age[{$PG_CONNINFO},{$PG_PATH}].last()}>{$MAX_XID_AGE}PostgreSQL Transactions: the oldest XID is too big on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.oldest.transaction_time[{$PG_CONNINFO},{$PG_PATH}].last()}>{$MAX_TRANSACTION_TIME}PostgreSQL Transactions: running transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.uptime[{$PG_CONNINFO},{$PG_PATH}].change()}>{$PG_UPTIME}PostgreSQL Health: service has been restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.cache.hit[{$PG_CONNINFO},{$PG_PATH}].last()}<{$CACHE_HIT_RATIO_PERCENT}PostgreSQL Health: cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.ping[{$PG_CONNINFO},{$PG_PATH}].nodata(180)}=1PostgreSQL Health: no ping from PostgreSQL for 3 minutes on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.prepared.oldest.last()}>{$MAX_PREPARED_TRANSACTION_TIME}PostgreSQL Prepared Transactions: prepared transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:system.processes.forkrate.min(5m)}>500System: process fork-rate too frequently on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.replication_lag.sec[{$PG_CONNINFO},{$PG_PATH}].last()}>{$CRITICAL_LAG_SECONDS}PostgreSQL Replication: streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.replication.non_active_slots[{$PG_CONNINFO},{$PG_PATH}].last()}>0PostgreSQL Replication: number of non-active replication slots on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:system.uptime.last()}<{$SYSTEM_UPTIME}System: {HOSTNAME} was restarted (start time={ITEM.LASTVALUE})030
+ PostgreSQL Archiver: Archive Status9002000.0100.0110100.00.0000002006AAE020- Mamonsu PostgreSQL Linuxpgsql.archive_command.count_files_to_archive[{$PG_CONNINFO},{$PG_PATH}]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.archive_command.archived_files[{$PG_CONNINFO},{$PG_PATH}]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.archive_command.failed_trying_to_archive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Autovacuum: Count of Autovacuum Workers9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.autovacuum.count[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL bgwriter: Buffers9002000.0100.0110100.00.0000002006AAE020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_checkpoint[{$PG_CONNINFO},{$PG_PATH}]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_clean[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_backend[{$PG_CONNINFO},{$PG_PATH}]
32FF5656020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_alloc[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL bgwriter: Events9002000.0100.0110100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.maxwritten_clean[{$PG_CONNINFO},{$PG_PATH}]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.bgwriter.buffers_backend_fsync[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Checkpoints: Count (in hour)9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.count_timed[{$PG_CONNINFO},{$PG_PATH}]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.count_wal[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Checkpoints: Write/Sync9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.write_time[{$PG_CONNINFO},{$PG_PATH}]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.checkpoint.checkpoint_sync_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Connections: Overview9002000.0100.0111100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.connections.active[{$PG_CONNINFO},{$PG_PATH}]
12A39B98020- Mamonsu PostgreSQL Linuxpgsql.connections.idle[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.connections.idle_in_transaction[{$PG_CONNINFO},{$PG_PATH}]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.connections.idle_in_transaction_aborted[{$PG_CONNINFO},{$PG_PATH}]
4200B0B8020- Mamonsu PostgreSQL Linuxpgsql.connections.fastpath_function_call[{$PG_CONNINFO},{$PG_PATH}]
523B415A020- Mamonsu PostgreSQL Linuxpgsql.connections.disabled[{$PG_CONNINFO},{$PG_PATH}]
62FF5656020- Mamonsu PostgreSQL Linuxpgsql.connections.total[{$PG_CONNINFO},{$PG_PATH}]
72006AAE020- Mamonsu PostgreSQL Linuxpgsql.connections.waiting[{$PG_CONNINFO},{$PG_PATH}]
8287C2B9020- Mamonsu PostgreSQL Linuxpgsql.connections.other[{$PG_CONNINFO},{$PG_PATH}]
System: Block Devices Read/Write Operations9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.all_read
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.all_write
System: Block Devices Read/Write Bytes9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.all_read_b
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.all_write_b
PostgreSQL Instance: Blocks Rate9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.blocks.hit[{$PG_CONNINFO},{$PG_PATH}]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.blocks.read[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Transactions Rate9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.transactions.committed[{$PG_CONNINFO},{$PG_PATH}]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.events.xact_rollback[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Events9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.events.conflicts[{$PG_CONNINFO},{$PG_PATH}]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.events.deadlocks[{$PG_CONNINFO},{$PG_PATH}]
22006AAE020- Mamonsu PostgreSQL Linuxpgsql.events.checksum_failures[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Temp Files9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.temp.bytes[{$PG_CONNINFO},{$PG_PATH}]
12006AAE120- Mamonsu PostgreSQL Linuxpgsql.temp.files[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Instance: Tuples9002000.0100.0110100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxpgsql.tuples.deleted[{$PG_CONNINFO},{$PG_PATH}]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.tuples.fetched[{$PG_CONNINFO},{$PG_PATH}]
2200CC00020- Mamonsu PostgreSQL Linuxpgsql.tuples.inserted[{$PG_CONNINFO},{$PG_PATH}]
32001219120- Mamonsu PostgreSQL Linuxpgsql.tuples.returned[{$PG_CONNINFO},{$PG_PATH}]
429C8A4E020- Mamonsu PostgreSQL Linuxpgsql.tuples.updated[{$PG_CONNINFO},{$PG_PATH}]
System: Server Memory Detailed Overview9004000.0100.0111100.00.0000000BAEB6B020- Mamonsu PostgreSQL Linuxsystem.memory.active
1000CC00020- Mamonsu PostgreSQL Linuxsystem.memory.available
2000B0B8020- Mamonsu PostgreSQL Linuxsystem.memory.buffers
3052768F020- Mamonsu PostgreSQL Linuxsystem.memory.cached
409C8A4E020- Mamonsu PostgreSQL Linuxsystem.memory.committed
50A39B98020- Mamonsu PostgreSQL Linuxsystem.memory.inactive
609F1E28020- Mamonsu PostgreSQL Linuxsystem.memory.mapped
70793F5D020- Mamonsu PostgreSQL Linuxsystem.memory.page_tables
80F6CB93020- Mamonsu PostgreSQL Linuxsystem.memory.slab
90006AAE020- Mamonsu PostgreSQL Linuxsystem.memory.swap
10087C2B9020- Mamonsu PostgreSQL Linuxsystem.memory.swap_cache
1103B415A020- Mamonsu PostgreSQL Linuxsystem.memory.unused
120001219020- Mamonsu PostgreSQL Linuxsystem.memory.used
130CF6518020- Mamonsu PostgreSQL Linuxsystem.memory.vmalloc_used
System: Server Free/Used Memory Overview9004000.0100.0110100.00.0000001001219020- Mamonsu PostgreSQL Linuxsystem.memory.used
1152768F020- Mamonsu PostgreSQL Linuxsystem.memory.cached
2100CC00020- Mamonsu PostgreSQL Linuxsystem.memory.available
34FF5656020- Mamonsu PostgreSQL Linuxsystem.memory.total
PostgreSQL pg_buffercache: Shared Buffer9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.buffers.size[{$PG_CONNINFO},{$PG_PATH}]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.buffers.twice_used[{$PG_CONNINFO},{$PG_PATH}]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.buffers.dirty[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL: Locks Sampling9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.accessshare[{$PG_CONNINFO},{$PG_PATH}]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.rowshare[{$PG_CONNINFO},{$PG_PATH}]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.rowexclusive[{$PG_CONNINFO},{$PG_PATH}]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.shareupdateexclusive[{$PG_CONNINFO},{$PG_PATH}]
42006AAE020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.share[{$PG_CONNINFO},{$PG_PATH}]
5200B0B8020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.sharerowexclusive[{$PG_CONNINFO},{$PG_PATH}]
629C8A4E020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.exclusive[{$PG_CONNINFO},{$PG_PATH}]
72793F5D020- Mamonsu PostgreSQL Linuxpgsql.pg_locks.accessexclusive[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Prepared Transactions: Overview9002000.0100.0110100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.prepared.count
129C8A4E120- Mamonsu PostgreSQL Linuxpgsql.prepared.oldest
System: Processes Overview9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.processes.running
12FF5656020- Mamonsu PostgreSQL Linuxsystem.processes.blocked
22006AAE120- Mamonsu PostgreSQL Linuxsystem.processes.forkrate
System: CPU Time Spent9002000.0100.0111100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.cpu.user
12793F5D020- Mamonsu PostgreSQL Linuxsystem.cpu.nice
229C8A4E020- Mamonsu PostgreSQL Linuxsystem.cpu.system
32A39B98020- Mamonsu PostgreSQL Linuxsystem.cpu.idle
42006AAE020- Mamonsu PostgreSQL Linuxsystem.cpu.iowait
52FF5656020- Mamonsu PostgreSQL Linuxsystem.cpu.irq
62F6CB93020- Mamonsu PostgreSQL Linuxsystem.cpu.softirq
PostgreSQL Statements: Bytes9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.stat.read_bytes[{$PG_CONNINFO},{$PG_PATH}]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat.write_bytes[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat.dirty_bytes[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Statements: Spent Time9002000.0100.0111100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.stat.read_time[{$PG_CONNINFO},{$PG_PATH}]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat.write_time[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat.other_time[{$PG_CONNINFO},{$PG_PATH}]
PostgreSQL Statements: WAL Statistics9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.stat.wal_bytes[{$PG_CONNINFO},{$PG_PATH}]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.stat.wal_records[{$PG_CONNINFO},{$PG_PATH}]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat.wal_fpi[{$PG_CONNINFO},{$PG_PATH}]
\ No newline at end of file
diff --git a/packaging/conf/template_linux.xml b/packaging/conf/template_linux.xml
index 71383e63..d8b75f56 100644
--- a/packaging/conf/template_linux.xml
+++ b/packaging/conf/template_linux.xml
@@ -21,12 +21,12 @@
Mamonsu PostgreSQL Linux
- - PostgreSQL Archiver: Files in archive_status Need to Archive Count200pgsql.archive_command[count_files_to_archive]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Files Need to Archive Size200pgsql.archive_command[size_files_to_archive]73650153b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Archived Files Count200pgsql.archive_command[archived_files]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Attempts to Archive Files Count200pgsql.archive_command[failed_trying_to_archive]736501532000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written During Checkpoints200pgsql.bgwriter[buffers_checkpoint]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written200pgsql.bgwriter[buffers_clean]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Number of bgwriter Stopped by Max Write Count200pgsql.bgwriter[maxwritten_clean]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written Directly by a Backend200pgsql.bgwriter[buffers_backend]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Times a Backend Execute Its Own Fsync200pgsql.bgwriter[buffers_backend_fsync]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Allocated200pgsql.bgwriter[buffers_alloc]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Written byte/s200pgsql.cfs.activity[written_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Scanned byte/s200pgsql.cfs.activity[scanned_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Compressed Files200pgsql.cfs.activity[compressed_files]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Scanned Files200pgsql.cfs.activity[scanned_files]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Current Ratio200pgsql.cfs.activity[current_compress_ratio]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Total Ratio200pgsql.cfs.activity[total_compress_ratio]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by Timeout (in hour)200pgsql.checkpoint[count_timed]7365030000000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by WAL (in hour)200pgsql.checkpoint[count_wal]7365030000000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Write Time200pgsql.checkpoint[write_time]736503000ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Sync Time200pgsql.checkpoint[checkpoint_sync_time]736503000ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Total User Connections200pgsql.connections[total]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Waiting User Connections200pgsql.connections[waiting]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Max Connections200pgsql.connections[max_connections]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Active User Connections200pgsql.connections[active]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle User Connections200pgsql.connections[idle]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction User Connections200pgsql.connections[idle_in_transaction]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction (Aborted) User Connections200pgsql.connections[idle_in_transaction_aborted]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Fastpath Function Call User Connections200pgsql.connections[fastpath_function_call]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Disabled User Connections200pgsql.connections[disabled]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Other Connections200pgsql.connections[other]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Count of Autovacuum Workers200pgsql.autovacumm.count[]7365030000000100Mamonsu PostgreSQL Linux
- System: Block Devices Read Requests200system.disk.all_read[]736501500000100Mamonsu PostgreSQL Linux
- System: Block Devices Write Requests200system.disk.all_write[]736501500000100Mamonsu PostgreSQL Linux
- System: Block Devices Read byte/s200system.disk.all_read_b[]736501500000100Mamonsu PostgreSQL Linux
- System: Block Devices Write byte/s200system.disk.all_write_b[]736501500000100Mamonsu PostgreSQL Linux
- Mamonsu: Plugin Errors200mamonsu.plugin.errors[]736506040000100Mamonsu PostgreSQL Linux
- Mamonsu: Plugin Keep Alive200mamonsu.plugin.keepalive[]736506000000100Mamonsu PostgreSQL Linux
- Mamonsu: RSS Memory Max Usage200mamonsu.memory.rss[max]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Transactions Committed200pgsql.transactions[committed]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Hit200pgsql.blocks[hit]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Read200pgsql.blocks[read]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Conflict Events200pgsql.events[conflicts]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Deadlock Events200pgsql.events[deadlocks]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Rollback Events200pgsql.events[xact_rollback]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Bytes Written200pgsql.temp[bytes]73650150b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Files Created200pgsql.temp[files]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Deleted200pgsql.tuples[deleted]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Fetched200pgsql.tuples[fetched]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Inserted200pgsql.tuples[inserted]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Returned200pgsql.tuples[returned]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Updated200pgsql.tuples[updated]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: checksum_failures Events200pgsql.events[checksum_failures]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736501540000100Mamonsu PostgreSQL Linux
- System: Load Average Over 1 Minute200system.la[1]736501500000100Mamonsu PostgreSQL Linux
- System: Active - Memory Recently Used200system.memory[active]73650153b0000100Mamonsu PostgreSQL Linux
- System: Available - Free Memory200system.memory[available]73650153b0000100Mamonsu PostgreSQL Linux
- System: Buffers - Block Device Cache and Dirty200system.memory[buffers]73650153b0000100Mamonsu PostgreSQL Linux
- System: Cached - Parked File Data (file content) Cache200system.memory[cached]73650153b0000100Mamonsu PostgreSQL Linux
- System: Committed AS - Total Committed Memory200system.memory[committed]73650153b0000100Mamonsu PostgreSQL Linux
- System: Inactive - Memory Not Currently Used200system.memory[inactive]73650153b0000100Mamonsu PostgreSQL Linux
- System: Mapped - All mmap()ed Pages200system.memory[mapped]73650153b0000100Mamonsu PostgreSQL Linux
- System: PageTables - Map bt Virtual and Physical200system.memory[page_tables]73650153b0000100Mamonsu PostgreSQL Linux
- System: Slab - Kernel Used Memory (inode cache)200system.memory[slab]73650153b0000100Mamonsu PostgreSQL Linux
- System: Swap - Swap Space Used200system.memory[swap]73650153b0000100Mamonsu PostgreSQL Linux
- System: SwapCached - Fetched unmod Yet Swap Pages200system.memory[swap_cache]73650153b0000100Mamonsu PostgreSQL Linux
- System: Total - All Memory200system.memory[total]73650153b0000100Mamonsu PostgreSQL Linux
- System: Unused - Wasted Memory200system.memory[unused]73650153b0000100Mamonsu PostgreSQL Linux
- System: Used - User-Space Applications200system.memory[used]73650153b0000100Mamonsu PostgreSQL Linux
- System: VMallocUsed - vmaloc() Allocated by Kernel200system.memory[vmalloc_used]73650153b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold200pgsql.memory_leak_diagnostic.count_diff[]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold, text of message200pgsql.memory_leak_diagnostic.msg_text[]736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Age of the Oldest XID200pgsql.oldest[xid_age]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: the Oldest Transaction Running Time in sec200pgsql.oldest[transaction_time]73650150s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Number of Parallel Queries Being Executed Now200pgsql.parallel[queries]736501530000100Mamonsu PostgreSQL Linux
- System: Opened Files200system.open_files[]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Size200pgsql.buffers[size]73650150b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Twice Used Size200pgsql.buffers[twice_used]73650150b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Dirty Size200pgsql.buffers[dirty]73650150b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Ping200pgsql.ping[]73650150ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Cache Hit Ratio1500pgsql.cache[hit]73650600%00001last(pgsql.blocks[hit])*100/(last(pgsql.blocks[hit])+last(pgsql.blocks[read]))00Mamonsu PostgreSQL Linux
- PostgreSQL Health: Service Uptime200pgsql.uptime[]73650153unixtime0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Server Version200pgsql.version[]736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Read Only Queries200pgsql.pg_locks[accessshare]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: SELECT FOR SHARE and SELECT FOR UPDATE200pgsql.pg_locks[rowshare]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Write Queries200pgsql.pg_locks[rowexclusive]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY200pgsql.pg_locks[shareupdateexclusive]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: CREATE INDEX200pgsql.pg_locks[share]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application200pgsql.pg_locks[sharerowexclusive]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application or Some Operations on System Catalogs200pgsql.pg_locks[exclusive]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE200pgsql.pg_locks[accessexclusive]736501530000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: Number of Prepared Transactions200pgsql.prepared.count736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: the Oldest Prepared Transaction Running Time in sec200pgsql.prepared.oldest736501500000100Mamonsu PostgreSQL Linux
- System: Processes in State Running200system.processes[running]736501500000100Mamonsu PostgreSQL Linux
- System: Processes in State Blocked200system.processes[blocked]736501500000100Mamonsu PostgreSQL Linux
- System: Processes Forkrate200system.processes[forkrate]736501500000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by Normal Programs and Daemons200system.cpu[user]736501500000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by nice(1)d Programs200system.cpu[nice]736501500000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by the Kernel in System Activities200system.cpu[system]736501500000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Idle200system.cpu[idle]736501500000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Waiting for I/O Operations200system.cpu[iowait]736501500000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Interrupts200system.cpu[irq]736501500000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Batched Interrupts200system.cpu[softirq]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Streaming Replication Lag200pgsql.replication_lag[sec]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Count Non-Active Replication Slots200pgsql.replication.non_active_slots[]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read bytes/s200pgsql.stat[read_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write bytes/s200pgsql.stat[write_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Dirty bytes/s200pgsql.stat[dirty_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read IO Time200pgsql.stat[read_time]73650600s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write IO Time200pgsql.stat[write_time]73650600s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Other (mostly CPU) Time200pgsql.stat[other_time]73650600s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Files200pgsql.stat[wal_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Records200pgsql.stat[wal_records]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Full Page Writes200pgsql.stat[wal_fpi]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Nnumber of Times pg_stat_statements.max Was Exceeded200pgsql.stat_info[dealloc]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Last Statistics Reset Time200pgsql.stat_info[stats_reset]73650600unixtime0000100Mamonsu PostgreSQL Linux
- System: Uptime200system.uptime[]73650153uptime0000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Lightweight Locks200pgsql.all_lock[lwlock]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Heavyweight Locks200pgsql.all_lock[hwlock]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Buffer Locks200pgsql.all_lock[buffer]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Extension Locks200pgsql.all_lock[extension]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Client Locks200pgsql.all_lock[client]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Other Locks (e.g. IPC, Timeout, IO)200pgsql.all_lock[other]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: XID Access Locks200pgsql.lwlock[xid]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Autovacuum Locks200pgsql.lwlock[autovacuum]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: WAL Access Locks200pgsql.lwlock[wal]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: CLOG Access Locks200pgsql.lwlock[clog]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Replication Locks200pgsql.lwlock[replication]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Logical Replication Locks200pgsql.lwlock[logical_replication]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Buffer Operations Locks200pgsql.lwlock[buffer]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Other Operations Lightweight Locks200pgsql.lwlock[other]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Relation200pgsql.hwlock[relation]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Extend a Relation Locks200pgsql.hwlock[extend]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Page200pgsql.hwlock[page]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Tuple200pgsql.hwlock[tuple]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Transaction to Finish Locks200pgsql.hwlock[transactionid]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Virtual XID Locks200pgsql.hwlock[virtualxid]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Speculative Insertion Locks200pgsql.hwlock[speculative_token]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on Database Object200pgsql.hwlock[object]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Userlocks200pgsql.hwlock[userlock]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Advisory User Locks200pgsql.hwlock[advisory]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Speed200pgsql.wal.write[]73650150Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Count of WAL Files200pgsql.wal.count[]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Records Generated200pgsql.wal.records.count[]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Full Page Images Generated200pgsql.wal.fpi.count[]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Buffers Full200pgsql.wal.buffers_full736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Time (ms)200pgsql.wal.write_time736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Time (ms)200pgsql.wal.sync_time736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Duty (%)1500pgsql.wal.sync_duty73650600%00001last(pgsql.wal.sync_time)/10/1500Mamonsu PostgreSQL Linux
- PostgreSQL CFS Discovery260000007pgsql.cfs.discovery_compressed_relations[]{#COMPRESSED_RELATION}.*8A0PostgreSQL CFS: Relation {#COMPRESSED_RELATION} Compress Ratio200pgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]7365060000000100Mamonsu PostgreSQL LinuxPostgreSQL CFS: Relation {#COMPRESSED_RELATION} Compress Ratio9002000.0100.0110100.00.00000008B817C020- Mamonsu PostgreSQL Linuxpgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]
PostgreSQL Databases Discovery260000007pgsql.database.discovery[]{#DATABASE}.*8A0PostgreSQL Databases {#DATABASE}: size200pgsql.database.size[{#DATABASE}]736503003b0000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Max datfrozenxid Age in: {#DATABASE}200pgsql.database.max_age[{#DATABASE}]7365030000000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Bloating Tables in {#DATABASE}200pgsql.database.bloating_tables[{#DATABASE}]7365030000000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Invalid Indexes in {#DATABASE}200pgsql.database.invalid_indexes[{#DATABASE}]7365030000000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pgsql.database.invalid_indexes[{#DATABASE}].last()}>0PostgreSQL Databases: invalid indexes in {#DATABASE} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030PostgreSQL Databases: {#DATABASE} size9002000.0100.0111100.00.00000028B817C020- Mamonsu PostgreSQL Linuxpgsql.database.size[{#DATABASE}]
PostgreSQL Databases: {#DATABASE} Bloating Overview9002000.0100.0110100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.database.bloating_tables[{#DATABASE}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacumm.count[]
PostgreSQL Databases: {#DATABASE} Max age(datfrozenxid)9002000.0100.0110100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.database.max_age[{#DATABASE}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacumm.count[]
VFS Discovery260000007system.vfs.discovery[]{#MOUNTPOINT}.*8A0System: Mount Point {#MOUNTPOINT}: Used200system.vfs.used[{#MOUNTPOINT}]73650153b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT}: Free200system.vfs.free[{#MOUNTPOINT}]73650153b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT}: Free in Percents200system.vfs.percent_free[{#MOUNTPOINT}]73650150%0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free Inodes in Percent200system.vfs.percent_inode_free[{#MOUNTPOINT}]73650150%0000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:system.vfs.percent_free[{#MOUNTPOINT}].last()}<10Free disk space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:system.vfs.percent_inode_free[{#MOUNTPOINT}].last()}<10Free inode space less then 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030System: Mount Point Overview {#MOUNTPOINT}9002000.0100.0111100.00.0000000E57862020- Mamonsu PostgreSQL Linuxsystem.vfs.used[{#MOUNTPOINT}]
10578159020- Mamonsu PostgreSQL Linuxsystem.vfs.free[{#MOUNTPOINT}]
System: Block Devices Discovery260000007system.disk.discovery[]{#BLOCKDEVICE}.*8A0System: Block Device {#BLOCKDEVICE} Utilization200system.disk.utilization[{#BLOCKDEVICE}]73650150%0000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read Operations200system.disk.read[{#BLOCKDEVICE}]736501500000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write Operations200system.disk.write[{#BLOCKDEVICE}]736501500000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read byte/s200system.disk.read_b[{#BLOCKDEVICE}]73650150b0000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write byte/s200system.disk.write_b[{#BLOCKDEVICE}]73650150b0000100Mamonsu PostgreSQL LinuxSystem: Block Device Overview {#BLOCKDEVICE} operations9002000.0100.0110100.00.00000007EB29B020- Mamonsu PostgreSQL Linuxsystem.disk.read[{#BLOCKDEVICE}]
10793F5D020- Mamonsu PostgreSQL Linuxsystem.disk.write[{#BLOCKDEVICE}]
20F6CB93120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
System: Block Device Overview {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.00000007EB29B020- Mamonsu PostgreSQL Linuxsystem.disk.read_b[{#BLOCKDEVICE}]
10793F5D020- Mamonsu PostgreSQL Linuxsystem.disk.write_b[{#BLOCKDEVICE}]
20F6CB93120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
Net Iface Discovery260000007system.net.discovery[]{#NETDEVICE}.*8A0System: Network Device {#NETDEVICE} RX bytes/s200system.net.rx_bytes[{#NETDEVICE}]73650150b0000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX errors/s200system.net.rx_errs[{#NETDEVICE}]736501500000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX drops/s200system.net.rx_drop[{#NETDEVICE}]736501500000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX bytes/s200system.net.tx_bytes[{#NETDEVICE}]73650150b0000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX errors/s200system.net.tx_errs[{#NETDEVICE}]736501500000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX drops/s200system.net.tx_drop[{#NETDEVICE}]736501500000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE}9002000.0100.0110100.00.00000007EB29B020- Mamonsu PostgreSQL Linuxsystem.net.rx_bytes[{#NETDEVICE}]
10793F5D020- Mamonsu PostgreSQL Linuxsystem.net.tx_bytes[{#NETDEVICE}]
pg_probackup discovery260000007pg_probackup.discovery[]{#BACKUPDIR}.*8A0pg_probackup dir {#BACKUPDIR}: size200pg_probackup.dir.size[{#BACKUPDIR}]736503003b0000100Mamonsu PostgreSQL Linuxpg_probackup dir {#BACKUPDIR}: error200pg_probackup.dir.error[{#BACKUPDIR}]7365030040000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pg_probackup.dir.error[{#BACKUPDIR}].str(ok)}<>1Error in pg_probackup dir {#BACKUPDIR} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030pg_probackup backup dir: {#BACKUPDIR} size9002000.0100.0111100.00.00000008B817C020- Mamonsu PostgreSQL Linuxpg_probackup.dir.size[{#BACKUPDIR}]
PostgreSQL Relations Sizes Discovery260000007pgsql.relation.size[]{#RELATIONNAME}.*8A0PostgreSQL Relation Size: {#RELATIONNAME}200pgsql.relation.size[{#RELATIONNAME}]736503003b0000100Mamonsu PostgreSQL LinuxPostgreSQL Relation Size: {#RELATIONNAME}9002000.0100.0111100.00.00000028B817C020- Mamonsu PostgreSQL Linuxpgsql.relation.size[{#RELATIONNAME}]
PostgreSQL Replication Lag Discovery260000007pgsql.replication.discovery[]{#APPLICATION_NAME}.*8A0PostgreSQL Replication: {#APPLICATION_NAME} Send Lag - Time elapsed sending recent WAL locally200pgsql.replication.send_lag[{#APPLICATION_NAME}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Receive Lag - Time elapsed between receiving recent WAL locally and receiving notification that this standby server has flushed it200pgsql.replication.receive_lag[{#APPLICATION_NAME}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Write Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written it200pgsql.replication.write_lag[{#APPLICATION_NAME}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Flush Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written and flushed it200pgsql.replication.flush_lag[{#APPLICATION_NAME}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Replay Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written, flushed and applied200pgsql.replication.replay_lag[{#APPLICATION_NAME}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Delta of Total Lag200pgsql.replication.total_lag[{#APPLICATION_NAME}]736501500000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: Delta of Total Lag for {#APPLICATION_NAME}9002000.0100.0110100.00.00000008B817C020- Mamonsu PostgreSQL Linuxpgsql.replication.total_lag[{#APPLICATION_NAME}]
- Mamonsu Overview2505001500011010003PostgreSQL Connections: OverviewMamonsu PostgreSQL Linux05001501011010003PostgreSQL pg_buffercache: Shared BufferMamonsu PostgreSQL Linux05001500111010003System: CPU Time SpentMamonsu PostgreSQL Linux05001501111010003System: Server Free/Used Memory OverviewMamonsu PostgreSQL Linux05001500211010003PostgreSQL Autovacuum: Count of Autovacuum WorkersMamonsu PostgreSQL Linux05001501211010003PostgreSQL Instance: TuplesMamonsu PostgreSQL Linux05001500311010003PostgreSQL bgwriter: BuffersMamonsu PostgreSQL Linux05001501311010003PostgreSQL bgwriter: EventsMamonsu PostgreSQL Linux05001500411010003PostgreSQL Checkpoints: Count (in hour)Mamonsu PostgreSQL Linux05001501411010003PostgreSQL Checkpoints: Write/SyncMamonsu PostgreSQL LinuxMamonsu PostgreSQL Instance2515001500011010003pgsql.ping[]Mamonsu PostgreSQL Linux15001501011010003pgsql.uptime[]Mamonsu PostgreSQL Linux15001500111010003pgsql.cache[hit]Mamonsu PostgreSQL Linux05001501111010003PostgreSQL Instance: EventsMamonsu PostgreSQL Linux15001500211010003pgsql.temp[bytes]Mamonsu PostgreSQL Linux15001501211010003pgsql.temp[files]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL WAL2505001500011010003PostgreSQL Archiver: Archive StatusMamonsu PostgreSQL Linux15001501011010003pgsql.wal.write[]Mamonsu PostgreSQL Linux15001500111010003pgsql.archive_command[size_files_to_archive]Mamonsu PostgreSQL Linux15001501111010003pgsql.archive_command[archived_files]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL Locks3513301000011010003pgsql.events[deadlocks]Mamonsu PostgreSQL Linux13301001011010003pgsql.pg_locks[accessshare]Mamonsu PostgreSQL Linux13301002011010003pgsql.pg_locks[rowshare]Mamonsu PostgreSQL Linux13301000111010003pgsql.pg_locks[rowexclusive]Mamonsu PostgreSQL Linux13301001111010003pgsql.pg_locks[shareupdateexclusive]Mamonsu PostgreSQL Linux13301002111010003pgsql.pg_locks[share]Mamonsu PostgreSQL Linux13301000211010003pgsql.pg_locks[sharerowexclusive]Mamonsu PostgreSQL Linux13301001211010003pgsql.pg_locks[exclusive]Mamonsu PostgreSQL Linux13301002211010003pgsql.pg_locks[accessexclusive]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL Transactions2515001500011010003pgsql.oldest[xid_age]Mamonsu PostgreSQL Linux15001501011010003pgsql.oldest[transaction_time]Mamonsu PostgreSQL Linux15001500111010003pgsql.prepared.countMamonsu PostgreSQL Linux15001501111010003pgsql.prepared.oldestMamonsu PostgreSQL LinuxMamonsu System (Linux)2505001500011010003System: Block Devices Read/Write BytesMamonsu PostgreSQL Linux05001501011010003System: Block Devices Read/Write OperationsMamonsu PostgreSQL Linux05001500111010003System: Processes OverviewMamonsu PostgreSQL Linux
-
+ - PostgreSQL Archiver: Files in archive_status Need to Archive Count200pgsql.archive_command[count_files_to_archive]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Files Need to Archive Size200pgsql.archive_command[size_files_to_archive]73650603b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Archived Files Count200pgsql.archive_command[archived_files]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL Archiver: Attempts to Archive Files Count200pgsql.archive_command[failed_trying_to_archive]736506032000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Count of Autovacuum Workers200pgsql.autovacuum.count[]736503000000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Utilization per 30 seconds200pgsql.autovacuum.utilization[]73650300%0000100Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Average Utilization per 5 minutes1500pgsql.autovacuum.utilization.avg5[]73650300%00001avg(pgsql.autovacuum.utilization[], 5m)00Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Average Utilization per 15 minutes1500pgsql.autovacuum.utilization.avg15[]73650300%00001avg(pgsql.autovacuum.utilization[], 15m)00Mamonsu PostgreSQL Linux
- PostgreSQL Autovacuum: Average Utilization per 30 minutes1500pgsql.autovacuum.utilization.avg30[]73650300%00001avg(pgsql.autovacuum.utilization[], 30m)00Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written During Checkpoints200pgsql.bgwriter[buffers_checkpoint]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written200pgsql.bgwriter[buffers_clean]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Number of bgwriter Stopped by Max Write Count200pgsql.bgwriter[maxwritten_clean]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Written Directly by a Backend200pgsql.bgwriter[buffers_backend]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Times a Backend Execute Its Own Fsync200pgsql.bgwriter[buffers_backend_fsync]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL bgwriter: Buffers Allocated200pgsql.bgwriter[buffers_alloc]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Written byte/s200pgsql.cfs.activity[written_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Scanned byte/s200pgsql.cfs.activity[scanned_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Compressed Files200pgsql.cfs.activity[compressed_files]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Scanned Files200pgsql.cfs.activity[scanned_files]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Current Ratio200pgsql.cfs.activity[current_compress_ratio]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL CFS: Total Ratio200pgsql.cfs.activity[total_compress_ratio]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by Timeout (in hour)200pgsql.checkpoint[count_timed]7365030000000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: by WAL (in hour)200pgsql.checkpoint[count_wal]7365030000000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Write Time200pgsql.checkpoint[write_time]736503000ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Checkpoints: Sync Time200pgsql.checkpoint[checkpoint_sync_time]736503000ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Total User Connections200pgsql.connections[total]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Waiting User Connections200pgsql.connections[waiting]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Max Connections200pgsql.connections[max_connections]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Active User Connections200pgsql.connections[active]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle User Connections200pgsql.connections[idle]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction User Connections200pgsql.connections[idle_in_transaction]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Idle in Transaction (Aborted) User Connections200pgsql.connections[idle_in_transaction_aborted]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Fastpath Function Call User Connections200pgsql.connections[fastpath_function_call]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Disabled User Connections200pgsql.connections[disabled]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Connections: Number of Other Connections200pgsql.connections[other]736506000000100Mamonsu PostgreSQL Linux
- System: Block Devices Read Requests200system.disk.all_read[]736506000000100Mamonsu PostgreSQL Linux
- System: Block Devices Write Requests200system.disk.all_write[]736506000000100Mamonsu PostgreSQL Linux
- System: Block Devices Read byte/s200system.disk.all_read_b[]736506000000100Mamonsu PostgreSQL Linux
- System: Block Devices Write byte/s200system.disk.all_write_b[]736506000000100Mamonsu PostgreSQL Linux
- Mamonsu: Plugin Errors200mamonsu.plugin.errors[]736506040000100Mamonsu PostgreSQL Linux
- Mamonsu: Plugin Keep Alive200mamonsu.plugin.keepalive[]736506000000100Mamonsu PostgreSQL Linux
- Mamonsu: RSS Memory Max Usage200mamonsu.memory.rss[max]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Transactions Committed200pgsql.transactions[committed]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Rollback Events200pgsql.events[xact_rollback]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Hit200pgsql.blocks[hit]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Blocks Read200pgsql.blocks[read]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Conflict Events200pgsql.events[conflicts]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Deadlock Events200pgsql.events[deadlocks]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Bytes Written200pgsql.temp[bytes]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Temp Files Created200pgsql.temp[files]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Deleted200pgsql.tuples[deleted]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Fetched200pgsql.tuples[fetched]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Inserted200pgsql.tuples[inserted]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Returned200pgsql.tuples[returned]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Tuples Updated200pgsql.tuples[updated]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: checksum_failures Events200pgsql.events[checksum_failures]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Instance: Server Mode200pgsql.server_mode736506040000100Mamonsu PostgreSQL Linux
- System: Load Average Over 1 Minute200system.la[1]736506000000100Mamonsu PostgreSQL Linux
- System: Active - Memory Recently Used200system.memory[active]73650603b0000100Mamonsu PostgreSQL Linux
- System: Available - Free Memory200system.memory[available]73650603b0000100Mamonsu PostgreSQL Linux
- System: Buffers - Block Device Cache and Dirty200system.memory[buffers]73650603b0000100Mamonsu PostgreSQL Linux
- System: Cached - Parked File Data (file content) Cache200system.memory[cached]73650603b0000100Mamonsu PostgreSQL Linux
- System: Committed AS - Total Committed Memory200system.memory[committed]73650603b0000100Mamonsu PostgreSQL Linux
- System: Inactive - Memory Not Currently Used200system.memory[inactive]73650603b0000100Mamonsu PostgreSQL Linux
- System: Mapped - All mmap()ed Pages200system.memory[mapped]73650603b0000100Mamonsu PostgreSQL Linux
- System: PageTables - Map bt Virtual and Physical200system.memory[page_tables]73650603b0000100Mamonsu PostgreSQL Linux
- System: Slab - Kernel Used Memory (inode cache)200system.memory[slab]73650603b0000100Mamonsu PostgreSQL Linux
- System: Swap - Swap Space Used200system.memory[swap]73650603b0000100Mamonsu PostgreSQL Linux
- System: SwapCached - Fetched unmod Yet Swap Pages200system.memory[swap_cache]73650603b0000100Mamonsu PostgreSQL Linux
- System: Total - All Memory200system.memory[total]73650603b0000100Mamonsu PostgreSQL Linux
- System: Unused - Wasted Memory200system.memory[unused]73650603b0000100Mamonsu PostgreSQL Linux
- System: Used - User-Space Applications200system.memory[used]73650603b0000100Mamonsu PostgreSQL Linux
- System: VMallocUsed - vmaloc() Allocated by Kernel200system.memory[vmalloc_used]73650603b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold200pgsql.memory_leak_diagnostic.count_diff[]736501500000100Mamonsu PostgreSQL Linux
- PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold, text of message200pgsql.memory_leak_diagnostic.msg_text[]736501540000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Age of the Oldest XID200pgsql.oldest[xid_age]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: the Oldest Transaction Running Time in sec200pgsql.oldest[transaction_time]73650600s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Transactions: Number of Parallel Queries Being Executed Now200pgsql.parallel[queries]736506030000100Mamonsu PostgreSQL Linux
- System: Opened Files200system.open_files[]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Size200pgsql.buffers[size]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Twice Used Size200pgsql.buffers[twice_used]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL pg_buffercache: Shared Buffer Dirty Size200pgsql.buffers[dirty]73650600b0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Ping200pgsql.ping[]73650600ms0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Cache Hit Ratio1500pgsql.cache[hit]73650600%00001last(pgsql.blocks[hit])*100/(last(pgsql.blocks[hit])+last(pgsql.blocks[read]))00Mamonsu PostgreSQL Linux
- PostgreSQL Health: Service Uptime200pgsql.uptime[]73650603unixtime0000100Mamonsu PostgreSQL Linux
- PostgreSQL Health: Server Version200pgsql.version[]736506040000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Read Only Queries200pgsql.pg_locks[accessshare]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: SELECT FOR SHARE and SELECT FOR UPDATE200pgsql.pg_locks[rowshare]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Write Queries200pgsql.pg_locks[rowexclusive]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: VACUUM, ANALYZE, CREATE INDEX CONCURRENTLY200pgsql.pg_locks[shareupdateexclusive]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: CREATE INDEX200pgsql.pg_locks[share]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application200pgsql.pg_locks[sharerowexclusive]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: Locks from Application or Some Operations on System Catalogs200pgsql.pg_locks[exclusive]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Locks: ALTER TABLE, DROP TABLE, TRUNCATE, REINDEX, CLUSTER, VACUUM FULL, LOCK TABLE200pgsql.pg_locks[accessexclusive]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: Number of Prepared Transactions200pgsql.prepared.count736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Prepared Transactions: the Oldest Prepared Transaction Running Time in sec200pgsql.prepared.oldest736506000000100Mamonsu PostgreSQL Linux
- System: Processes in State Running200system.processes[running]736506000000100Mamonsu PostgreSQL Linux
- System: Processes in State Blocked200system.processes[blocked]736506000000100Mamonsu PostgreSQL Linux
- System: Processes Forkrate200system.processes[forkrate]736506000000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by Normal Programs and Daemons200system.cpu[user]736506000000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by nice(1)d Programs200system.cpu[nice]736506000000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent by the Kernel in System Activities200system.cpu[system]736506000000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Idle200system.cpu[idle]736506000000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Waiting for I/O Operations200system.cpu[iowait]736506000000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Interrupts200system.cpu[irq]736506000000100Mamonsu PostgreSQL Linux
- System: CPU Time Spent Handling Batched Interrupts200system.cpu[softirq]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Streaming Replication Lag200pgsql.replication_lag[sec]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Replication: Count Non-Active Replication Slots200pgsql.replication.non_active_slots[]736506030000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read bytes/s200pgsql.stat[read_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write bytes/s200pgsql.stat[write_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Dirty bytes/s200pgsql.stat[dirty_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Read IO Time200pgsql.stat[read_time]73650600s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Write IO Time200pgsql.stat[write_time]73650600s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Other (mostly CPU) Time200pgsql.stat[other_time]73650600s0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Files200pgsql.stat[wal_bytes]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Amount of WAL Records200pgsql.stat[wal_records]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Full Page Writes200pgsql.stat[wal_fpi]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Nnumber of Times pg_stat_statements.max Was Exceeded200pgsql.stat_info[dealloc]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Statements: Last Statistics Reset Time200pgsql.stat_info[stats_reset]73650600unixtime0000100Mamonsu PostgreSQL Linux
- System: Uptime200system.uptime[]73650603uptime0000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Lightweight Locks200pgsql.all_lock[lwlock]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Heavyweight Locks200pgsql.all_lock[hwlock]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Buffer Locks200pgsql.all_lock[buffer]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Extension Locks200pgsql.all_lock[extension]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Client Locks200pgsql.all_lock[client]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling: Other Locks (e.g. IPC, Timeout, IO)200pgsql.all_lock[other]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: XID Access Locks200pgsql.lwlock[xid]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Autovacuum Locks200pgsql.lwlock[autovacuum]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: WAL Access Locks200pgsql.lwlock[wal]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: CLOG Access Locks200pgsql.lwlock[clog]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Replication Locks200pgsql.lwlock[replication]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Logical Replication Locks200pgsql.lwlock[logical_replication]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Buffer Operations Locks200pgsql.lwlock[buffer]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling LWLocks: Other Operations Lightweight Locks200pgsql.lwlock[other]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Relation200pgsql.hwlock[relation]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Extend a Relation Locks200pgsql.hwlock[extend]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Page200pgsql.hwlock[page]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on a Tuple200pgsql.hwlock[tuple]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Transaction to Finish Locks200pgsql.hwlock[transactionid]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Virtual XID Locks200pgsql.hwlock[virtualxid]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Speculative Insertion Locks200pgsql.hwlock[speculative_token]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Locks on Database Object200pgsql.hwlock[object]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Userlocks200pgsql.hwlock[userlock]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL Wait Sampling HWLocks: Advisory User Locks200pgsql.hwlock[advisory]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Speed200pgsql.wal.write[]73650600Bps0000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Count of WAL Files200pgsql.wal.count[]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Records Generated200pgsql.wal.records.count[]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Full Page Images Generated200pgsql.wal.fpi.count[]736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Buffers Full200pgsql.wal.buffers_full736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Write Time (ms)200pgsql.wal.write_time736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Time (ms)200pgsql.wal.sync_time736506000000100Mamonsu PostgreSQL Linux
- PostgreSQL WAL: Sync Duty (%)1500pgsql.wal.sync_duty73650600%00001last(pgsql.wal.sync_time)/1000Mamonsu PostgreSQL Linux
+ PostgreSQL CFS Discovery260000007pgsql.cfs.discovery_compressed_relations[]{#COMPRESSED_RELATION}.*8A0PostgreSQL CFS: Relation {#COMPRESSED_RELATION} Compress Ratio200pgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]7365060000000100Mamonsu PostgreSQL LinuxPostgreSQL CFS: Relation {#COMPRESSED_RELATION} Compress Ratio9002000.0100.0110100.00.0000000A39B98020- Mamonsu PostgreSQL Linuxpgsql.cfs.compress_ratio[{#COMPRESSED_RELATION}]
PostgreSQL Databases Discovery260000007pgsql.database.discovery[]{#DATABASE}.*8A0PostgreSQL Databases: {#DATABASE} size200pgsql.database.size[{#DATABASE}]736503003b0000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Max datfrozenxid Age in: {#DATABASE}200pgsql.database.max_age[{#DATABASE}]7365030000000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Bloating Tables in {#DATABASE}200pgsql.database.bloating_tables[{#DATABASE}]7365030000000100Mamonsu PostgreSQL LinuxPostgreSQL Databases: Count of Invalid Indexes in {#DATABASE}200pgsql.database.invalid_indexes[{#DATABASE}]7365030000000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pgsql.database.invalid_indexes[{#DATABASE}].last()}>0PostgreSQL Databases: invalid indexes in {#DATABASE} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030PostgreSQL Databases: {#DATABASE} size9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.database.size[{#DATABASE}]
PostgreSQL Databases: {#DATABASE} Bloating Overview9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.database.bloating_tables[{#DATABASE}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacuum.count[]
PostgreSQL Databases: {#DATABASE} Max age(datfrozenxid)9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.database.max_age[{#DATABASE}]
12793F5D120- Mamonsu PostgreSQL Linuxpgsql.autovacuum.count[]
System: VFS Discovery260000007system.vfs.discovery[]{#MOUNTPOINT}.*8A0System: Mount Point {#MOUNTPOINT} Used200system.vfs.used[{#MOUNTPOINT}]73650603b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free200system.vfs.free[{#MOUNTPOINT}]73650603b0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free in Percents200system.vfs.percent_free[{#MOUNTPOINT}]73650600%0000100Mamonsu PostgreSQL LinuxSystem: Mount Point {#MOUNTPOINT} Free Inodes in Percent200system.vfs.percent_inode_free[{#MOUNTPOINT}]73650600%0000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:system.vfs.percent_free[{#MOUNTPOINT}].last()}<{$VFS_PERCENT_FREE}System: free disk space less than 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:system.vfs.percent_inode_free[{#MOUNTPOINT}].last()}<{$VFS_INODE_PERCENT_FREE}System: free inode space less than 10% on mountpoint {#MOUNTPOINT} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030System: Mount Point Overview {#MOUNTPOINT}9002000.0100.0111100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxsystem.vfs.used[{#MOUNTPOINT}]
1200CC00020- Mamonsu PostgreSQL Linuxsystem.vfs.free[{#MOUNTPOINT}]
System: Block Devices Discovery260000007system.disk.discovery[]{#BLOCKDEVICE}.*8A0System: Block Device {#BLOCKDEVICE} Utilization200system.disk.utilization[{#BLOCKDEVICE}]73650600%0000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read Operations200system.disk.read[{#BLOCKDEVICE}]736506000000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write Operations200system.disk.write[{#BLOCKDEVICE}]736506000000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Read byte/s200system.disk.read_b[{#BLOCKDEVICE}]73650600b0000100Mamonsu PostgreSQL LinuxSystem: Block Device {#BLOCKDEVICE} Write byte/s200system.disk.write_b[{#BLOCKDEVICE}]73650600b0000100Mamonsu PostgreSQL LinuxSystem: Block Device Overview {#BLOCKDEVICE} operations9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.read[{#BLOCKDEVICE}]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.write[{#BLOCKDEVICE}]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
System: Block Device Overview {#BLOCKDEVICE} byte/s9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.read_b[{#BLOCKDEVICE}]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.write_b[{#BLOCKDEVICE}]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.disk.utilization[{#BLOCKDEVICE}]
System: net Iface Discovery260000007system.net.discovery[]{#NETDEVICE}.*8A0System: Network Device {#NETDEVICE} RX bytes/s200system.net.rx_bytes[{#NETDEVICE}]73650600b0000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX errors/s200system.net.rx_errs[{#NETDEVICE}]736506000000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} RX drops/s200system.net.rx_drop[{#NETDEVICE}]736506000000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX bytes/s200system.net.tx_bytes[{#NETDEVICE}]73650600b0000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX errors/s200system.net.tx_errs[{#NETDEVICE}]736506000000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE} TX drops/s200system.net.tx_drop[{#NETDEVICE}]736506000000100Mamonsu PostgreSQL LinuxSystem: Network Device {#NETDEVICE}9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxsystem.net.rx_bytes[{#NETDEVICE}]
12793F5D020- Mamonsu PostgreSQL Linuxsystem.net.tx_bytes[{#NETDEVICE}]
pg_probackup Discovery260000007pg_probackup.discovery[]{#BACKUPDIR}.*8A0pg_probackup dir {#BACKUPDIR}: Size200pg_probackup.dir.size[{#BACKUPDIR}]736503003b0000100Mamonsu PostgreSQL Linuxpg_probackup dir {#BACKUPDIR}: Error200pg_probackup.dir.error[{#BACKUPDIR}]7365030040000100Mamonsu PostgreSQL Linux{Mamonsu PostgreSQL Linux:pg_probackup.dir.error[{#BACKUPDIR}].str(ok)}<>1pg_probackup: error in dir {#BACKUPDIR} (hostname={HOSTNAME} value={ITEM.LASTVALUE})030pg_probackup Backup dir: {#BACKUPDIR} Size9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpg_probackup.dir.size[{#BACKUPDIR}]
PostgreSQL Relations Sizes Discovery260000007pgsql.relation.size[]{#RELATIONNAME}.*8A0PostgreSQL Relation Size: {#RELATIONNAME}200pgsql.relation.size[{#RELATIONNAME}]73650153b0000100Mamonsu PostgreSQL LinuxPostgreSQL Relation Size: {#RELATIONNAME}9002000.0100.0111100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.relation.size[{#RELATIONNAME}]
PostgreSQL Replication Lag Discovery260000007pgsql.replication.discovery[]{#APPLICATION_NAME}.*8A0PostgreSQL Replication: {#APPLICATION_NAME} Send Lag - Time elapsed sending recent WAL locally200pgsql.replication.send_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Receive Lag - Time elapsed between receiving recent WAL locally and receiving notification that this standby server has flushed it200pgsql.replication.receive_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Write Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written it200pgsql.replication.write_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Flush Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written and flushed it200pgsql.replication.flush_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Replay Lag - Time elapsed between flushing recent WAL locally and receiving notification that this standby server has written, flushed and applied200pgsql.replication.replay_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: {#APPLICATION_NAME} Delta of Total Lag200pgsql.replication.total_lag[{#APPLICATION_NAME}]736506000000100Mamonsu PostgreSQL LinuxPostgreSQL Replication: Delta of Total Lag for {#APPLICATION_NAME}9002000.0100.0110100.00.0000000A39B98020- Mamonsu PostgreSQL Linuxpgsql.replication.total_lag[{#APPLICATION_NAME}]
+ {$ARCHIVE_QUEUE_FILES}2{$MAX_CHECKPOINT_BY_WAL_IN_HOUR}12{$CONNECTIONS_PERCENT}90{$VFS_PERCENT_FREE}10{$VFS_INODE_PERCENT_FREE}10{$MAMONSU_MAX_MEMORY_USAGE}41943040{$MAX_XID_AGE}18000000{$MAX_TRANSACTION_TIME}18000{$PG_UPTIME}600{$CACHE_HIT_RATIO_PERCENT}80{$MAX_PREPARED_TRANSACTION_TIME}18000{$CRITICAL_LAG_SECONDS}300{$SYSTEM_UPTIME}300
+ Mamonsu Overview2505001500011010003PostgreSQL Connections: OverviewMamonsu PostgreSQL Linux05001501011010003PostgreSQL Instance: Transactions RateMamonsu PostgreSQL Linux05001500111010003System: CPU Time SpentMamonsu PostgreSQL Linux05001501111010003System: Server Free/Used Memory OverviewMamonsu PostgreSQL Linux05001500211010003PostgreSQL Autovacuum: Count of Autovacuum WorkersMamonsu PostgreSQL Linux05001501211010003PostgreSQL Instance: TuplesMamonsu PostgreSQL Linux05001500311010003PostgreSQL bgwriter: BuffersMamonsu PostgreSQL Linux05001501311010003PostgreSQL bgwriter: EventsMamonsu PostgreSQL Linux05001500411010003PostgreSQL Checkpoints: Count (in hour)Mamonsu PostgreSQL Linux05001501411010003PostgreSQL Checkpoints: Write/SyncMamonsu PostgreSQL LinuxMamonsu PostgreSQL Instance2515001500011010003pgsql.ping[]Mamonsu PostgreSQL Linux15001501011010003pgsql.uptime[]Mamonsu PostgreSQL Linux15001500111010003pgsql.cache[hit]Mamonsu PostgreSQL Linux05001501111010003PostgreSQL Instance: EventsMamonsu PostgreSQL Linux15001500211010003pgsql.temp[bytes]Mamonsu PostgreSQL Linux15001501211010003pgsql.temp[files]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL WAL2505001500011010003PostgreSQL Archiver: Archive StatusMamonsu PostgreSQL Linux15001501011010003pgsql.wal.write[]Mamonsu PostgreSQL Linux15001500111010003pgsql.archive_command[size_files_to_archive]Mamonsu PostgreSQL Linux15001501111010003pgsql.archive_command[archived_files]Mamonsu PostgreSQL Linux15001500211010003pgsql.wal.write_timeMamonsu PostgreSQL Linux15001501211010003pgsql.wal.sync_timeMamonsu PostgreSQL LinuxMamonsu PostgreSQL Locks3513301000011010003pgsql.events[conflicts]Mamonsu PostgreSQL Linux13301001011010003pgsql.pg_locks[accessshare]Mamonsu PostgreSQL Linux13301002011010003pgsql.pg_locks[rowshare]Mamonsu PostgreSQL Linux13301000111010003pgsql.pg_locks[rowexclusive]Mamonsu PostgreSQL Linux13301001111010003pgsql.pg_locks[shareupdateexclusive]Mamonsu PostgreSQL Linux13301002111010003pgsql.pg_locks[share]Mamonsu PostgreSQL Linux13301000211010003pgsql.pg_locks[sharerowexclusive]Mamonsu PostgreSQL Linux13301001211010003pgsql.pg_locks[exclusive]Mamonsu PostgreSQL Linux13301002211010003pgsql.pg_locks[accessexclusive]Mamonsu PostgreSQL LinuxMamonsu PostgreSQL Transactions2515001500011010003pgsql.oldest[xid_age]Mamonsu PostgreSQL Linux15001501011010003pgsql.oldest[transaction_time]Mamonsu PostgreSQL Linux15001500111010003pgsql.prepared.countMamonsu PostgreSQL Linux15001501111010003pgsql.prepared.oldestMamonsu PostgreSQL LinuxMamonsu System (Linux)2505001500011010003System: Block Devices Read/Write BytesMamonsu PostgreSQL Linux05001501011010003System: Block Devices Read/Write OperationsMamonsu PostgreSQL Linux05001500111010003System: Processes OverviewMamonsu PostgreSQL Linux
- {Mamonsu PostgreSQL Linux:pgsql.archive_command[count_files_to_archive].last()}>2PostgreSQL Archiver: count files need to archive on {HOSTNAME} more than 2030{Mamonsu PostgreSQL Linux:pgsql.checkpoint[count_wal].last()}>12PostgreSQL Checkpoints: required checkpoints occurs to frequently on {HOSTNAME}030 {Mamonsu PostgreSQL Linux:pgsql.connections[total].last()}/{Mamonsu PostgreSQL Linux:pgsql.connections[max_connections].last()}*100 >90PostgreSQL Connections: too many connections on {HOSTNAME} (total connections more than 90% of max_connections)030{Mamonsu PostgreSQL Linux:mamonsu.plugin.errors[].strlen()}>1Mamonsu plugin errors on {HOSTNAME}. {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:mamonsu.plugin.keepalive[].nodata(180)}=1Mamonsu nodata from {HOSTNAME}030{Mamonsu PostgreSQL Linux:mamonsu.memory.rss[max].last()}>41943040Mamonsu agent memory usage alert on {HOSTNAME}: {ITEM.LASTVALUE} bytes030{Mamonsu PostgreSQL Linux:pgsql.server_mode.change()}>0PostgreSQL Instance: server mode has been changed on {HOSTNAME} to {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.memory_leak_diagnostic.msg_text[].strlen()}>1PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold on {HOSTNAME}. {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.oldest[xid_age].last()}>18000000PostgreSQL Transactions: the oldest XID is too big on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.oldest[transaction_time].last()}>18000PostgreSQL Transactions: running transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.uptime[].last()}<600PostgreSQL Health: service has been restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.cache[hit].last()}<80PostgreSQL Health: cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.ping[].nodata(180)}=1PostgreSQL Health: no ping from PostgreSQL for 3 minutes on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.prepared.oldest.last()}>60PostgreSQL Prepared Transactions: prepared transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:system.processes[forkrate].min(5m)}>500Process fork-rate to frequently on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.replication_lag[sec].last()}>300PostgreSQL streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.replication.non_active_slots[].last()}>0PostgreSQL number of non-active replication slots on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:system.uptime[].last()}<300System was restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030
- PostgreSQL Archiver: Archive Status9002000.0100.0110100.00.00000029C8A4E020- Mamonsu PostgreSQL Linuxpgsql.archive_command[count_files_to_archive]
12578159020- Mamonsu PostgreSQL Linuxpgsql.archive_command[archived_files]
22E57862020- Mamonsu PostgreSQL Linuxpgsql.archive_command[failed_trying_to_archive]
PostgreSQL bgwriter: Buffers9002000.0100.0110100.00.0000002793F5D020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_checkpoint]
129C8A4E020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_clean]
227EB29B020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_backend]
323B415A020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_alloc]
PostgreSQL bgwriter: Events9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[maxwritten_clean]
129C8A4E020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_backend_fsync]
PostgreSQL Checkpoints: Count (in hour)9002000.0100.0110100.00.0000002578159020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[count_timed]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[count_wal]
PostgreSQL Checkpoints: Write/Sync9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[write_time]
129C8A4E020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[checkpoint_sync_time]
PostgreSQL Connections: Overview9002000.0100.0110100.00.0000002578159020- Mamonsu PostgreSQL Linuxpgsql.connections[active]
128B817C020- Mamonsu PostgreSQL Linuxpgsql.connections[idle]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.connections[idle_in_transaction]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.connections[idle_in_transaction_aborted]
4200B0B8020- Mamonsu PostgreSQL Linuxpgsql.connections[fastpath_function_call]
523B415A020- Mamonsu PostgreSQL Linuxpgsql.connections[disabled]
62E57862020- Mamonsu PostgreSQL Linuxpgsql.connections[total]
720082A5020- Mamonsu PostgreSQL Linuxpgsql.connections[waiting]
82FF3C47020- Mamonsu PostgreSQL Linuxpgsql.connections[max_connections]
927EB29B020- Mamonsu PostgreSQL Linuxpgsql.connections[other]
PostgreSQL Autovacuum: Count of Autovacuum Workers9002000.0100.0110100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.autovacumm.count[]
System: Block Devices Read/Write Operations9002000.0100.0110100.00.00000007EB29B020- Mamonsu PostgreSQL Linuxsystem.disk.all_read[]
10793F5D020- Mamonsu PostgreSQL Linuxsystem.disk.all_write[]
System: Block Devices Read/Write Bytes9002000.0100.0110100.00.00000007EB29B020- Mamonsu PostgreSQL Linuxsystem.disk.all_read_b[]
10793F5D020- Mamonsu PostgreSQL Linuxsystem.disk.all_write_b[]
PostgreSQL Instance: Blocks Rate9002000.0100.0110100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.blocks[hit]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.blocks[read]
PostgreSQL Instance: Transactions Rate9002000.0100.0110100.00.0000002578159020- Mamonsu PostgreSQL Linuxpgsql.transactions[committed]
12E57862020- Mamonsu PostgreSQL Linuxpgsql.events[xact_rollback]
PostgreSQL Instance: Events9002000.0100.0110100.00.00000029C8A4E020- Mamonsu PostgreSQL Linuxpgsql.events[conflicts]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.events[deadlocks]
22793F5D020- Mamonsu PostgreSQL Linuxpgsql.events[checksum_failures]
PostgreSQL Instance: Temp Files9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.temp[bytes]
120082A5120- Mamonsu PostgreSQL Linuxpgsql.temp[files]
PostgreSQL Instance: Tuples9002000.0100.0110100.00.00000023B415A020- Mamonsu PostgreSQL Linuxpgsql.tuples[deleted]
127EB29B020- Mamonsu PostgreSQL Linuxpgsql.tuples[fetched]
2200B0B8020- Mamonsu PostgreSQL Linuxpgsql.tuples[inserted]
329C8A4E120- Mamonsu PostgreSQL Linuxpgsql.tuples[returned]
426A4F5F020- Mamonsu PostgreSQL Linuxpgsql.tuples[updated]
System: Server Memory Detailed Overview9004000.0100.0111100.00.000000090BD72020- Mamonsu PostgreSQL Linuxsystem.memory[active]
10578159020- Mamonsu PostgreSQL Linuxsystem.memory[available]
2000B0B8020- Mamonsu PostgreSQL Linuxsystem.memory[buffers]
309C8A4E020- Mamonsu PostgreSQL Linuxsystem.memory[cached]
4052768F020- Mamonsu PostgreSQL Linuxsystem.memory[committed]
50001219020- Mamonsu PostgreSQL Linuxsystem.memory[inactive]
609F1E28020- Mamonsu PostgreSQL Linuxsystem.memory[mapped]
708B817C020- Mamonsu PostgreSQL Linuxsystem.memory[page_tables]
80F6CB93020- Mamonsu PostgreSQL Linuxsystem.memory[slab]
900082A5020- Mamonsu PostgreSQL Linuxsystem.memory[swap]
1007EB29B020- Mamonsu PostgreSQL Linuxsystem.memory[swap_cache]
110E57862020- Mamonsu PostgreSQL Linuxsystem.memory[total]
1203B415A020- Mamonsu PostgreSQL Linuxsystem.memory[unused]
130793F5D020- Mamonsu PostgreSQL Linuxsystem.memory[used]
140CF6518020- Mamonsu PostgreSQL Linuxsystem.memory[vmalloc_used]
System: Server Free/Used Memory Overview9004000.0100.0111100.00.0000001578159020- Mamonsu PostgreSQL Linuxsystem.memory[available]
119C8A4E020- Mamonsu PostgreSQL Linuxsystem.memory[cached]
24E57862020- Mamonsu PostgreSQL Linuxsystem.memory[total]
31793F5D020- Mamonsu PostgreSQL Linuxsystem.memory[used]
PostgreSQL pg_buffercache: Shared Buffer9002000.0100.0110100.00.0000002E57862020- Mamonsu PostgreSQL Linuxpgsql.buffers[size]
127EB29B020- Mamonsu PostgreSQL Linuxpgsql.buffers[twice_used]
22793F5D020- Mamonsu PostgreSQL Linuxpgsql.buffers[dirty]
PostgreSQL: Locks Sampling9002000.0100.0110100.00.0000002578159020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[accessshare]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[rowshare]
227EB29B020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[rowexclusive]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[shareupdateexclusive]
420082A5020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[share]
5200B0B8020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[sharerowexclusive]
629C8A4E020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[exclusive]
72793F5D020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[accessexclusive]
PostgreSQL Prepared Transactions: Overview9002000.0100.0110100.00.00000028B817C020- Mamonsu PostgreSQL Linuxpgsql.prepared.count
129C8A4E120- Mamonsu PostgreSQL Linuxpgsql.prepared.oldest
System: Processes Overview9002000.0100.0110100.00.0000000578159020- Mamonsu PostgreSQL Linuxsystem.processes[running]
10E57862020- Mamonsu PostgreSQL Linuxsystem.processes[blocked]
209C8A4E120- Mamonsu PostgreSQL Linuxsystem.processes[forkrate]
System: CPU Time Spent9002000.0100.0111100.00.0000000578159020- Mamonsu PostgreSQL Linuxsystem.cpu[user]
10793F5D020- Mamonsu PostgreSQL Linuxsystem.cpu[nice]
209C8A4E020- Mamonsu PostgreSQL Linuxsystem.cpu[system]
308B817C020- Mamonsu PostgreSQL Linuxsystem.cpu[idle]
400082A5020- Mamonsu PostgreSQL Linuxsystem.cpu[iowait]
503B415A020- Mamonsu PostgreSQL Linuxsystem.cpu[irq]
60F6CB93020- Mamonsu PostgreSQL Linuxsystem.cpu[softirq]
PostgreSQL Statements: Bytes9002000.0100.0110100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.stat[read_bytes]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat[write_bytes]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat[dirty_bytes]
PostgreSQL Statements: Spend Time9002000.0100.0111100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.stat[read_time]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat[write_time]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat[other_time]
PostgreSQL Statements: WAL Statistics9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.stat[wal_bytes]
120082A5020- Mamonsu PostgreSQL Linuxpgsql.stat[wal_records]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat[wal_fpi]
PostgreSQL Wait Sampling: Locks by Type9002000.0100.0111100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.all_lock[lwlock]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.all_lock[hwlock]
2200B0B8020- Mamonsu PostgreSQL Linuxpgsql.all_lock[buffer]
329C8A4E020- Mamonsu PostgreSQL Linuxpgsql.all_lock[extension]
42F6CB93020- Mamonsu PostgreSQL Linuxpgsql.all_lock[client]
523B415A020- Mamonsu PostgreSQL Linuxpgsql.all_lock[other]
PostgreSQL Wait Sampling: Heavyweight Locks9002000.0100.0111100.00.00000027EB29B020- Mamonsu PostgreSQL Linuxpgsql.hwlock[relation]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.hwlock[extend]
22F6CB93020- Mamonsu PostgreSQL Linuxpgsql.hwlock[page]
320082A5020- Mamonsu PostgreSQL Linuxpgsql.hwlock[tuple]
4200B0B8020- Mamonsu PostgreSQL Linuxpgsql.hwlock[transactionid]
52793F5D020- Mamonsu PostgreSQL Linuxpgsql.hwlock[virtualxid]
629C8A4E020- Mamonsu PostgreSQL Linuxpgsql.hwlock[speculative_token]
728B817C020- Mamonsu PostgreSQL Linuxpgsql.hwlock[object]
8252768F020- Mamonsu PostgreSQL Linuxpgsql.hwlock[userlock]
92FE9430020- Mamonsu PostgreSQL Linuxpgsql.hwlock[advisory]
PostgreSQL Wait Sampling: Lightweight Locks9002000.0100.0111100.00.0000002793F5D020- Mamonsu PostgreSQL Linuxpgsql.lwlock[xid]
1200B0B8020- Mamonsu PostgreSQL Linuxpgsql.lwlock[autovacuum]
227EB29B020- Mamonsu PostgreSQL Linuxpgsql.lwlock[wal]
320082A5020- Mamonsu PostgreSQL Linuxpgsql.lwlock[clog]
423B415A020- Mamonsu PostgreSQL Linuxpgsql.lwlock[replication]
529C8A4E020- Mamonsu PostgreSQL Linuxpgsql.lwlock[logical_replication]
62F6CB93020- Mamonsu PostgreSQL Linuxpgsql.lwlock[buffer]
728B817C020- Mamonsu PostgreSQL Linuxpgsql.lwlock[other]
+ {Mamonsu PostgreSQL Linux:pgsql.archive_command[count_files_to_archive].last()}>{$ARCHIVE_QUEUE_FILES}PostgreSQL Archiver: count files need to archive on {HOSTNAME} more than 2030{Mamonsu PostgreSQL Linux:pgsql.checkpoint[count_wal].last()}>{$MAX_CHECKPOINT_BY_WAL_IN_HOUR}PostgreSQL Checkpoints: required checkpoints occurs too frequently on {HOSTNAME}030 {Mamonsu PostgreSQL Linux:pgsql.connections[total].last()}/{Mamonsu PostgreSQL Linux:pgsql.connections[max_connections].last()}*100 >{$CONNECTIONS_PERCENT}PostgreSQL Connections: too many connections on {HOSTNAME} (total connections more than {$CONNECTIONS_PERCENT}% of max_connections)030{Mamonsu PostgreSQL Linux:mamonsu.plugin.errors[].strlen()}>1Mamonsu health: plugin errors on {HOSTNAME}. {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:mamonsu.plugin.keepalive[].nodata(180)}=1Mamonsu health: nodata from {HOSTNAME}030{Mamonsu PostgreSQL Linux:mamonsu.memory.rss[max].last()}>{$MAMONSU_MAX_MEMORY_USAGE}Mamonsu health: agent memory usage alert on {HOSTNAME}: {ITEM.LASTVALUE} bytes030{Mamonsu PostgreSQL Linux:pgsql.server_mode.change()}>0PostgreSQL Instance: server mode has been changed on {HOSTNAME} to {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.memory_leak_diagnostic.msg_text[].strlen()}>1PostgreSQL Memory Leak: Number of Pids Which Private Anonymous Memory Exceeds private_anon_mem_threshold on {HOSTNAME}. {ITEM.LASTVALUE}030{Mamonsu PostgreSQL Linux:pgsql.oldest[xid_age].last()}>{$MAX_XID_AGE}PostgreSQL Transactions: the oldest XID is too big on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.oldest[transaction_time].last()}>{$MAX_TRANSACTION_TIME}PostgreSQL Transactions: running transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.uptime[].change()}>{$PG_UPTIME}PostgreSQL Health: service has been restarted on {HOSTNAME} (uptime={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.cache[hit].last()}<{$CACHE_HIT_RATIO_PERCENT}PostgreSQL Health: cache hit ratio too low on {HOSTNAME} ({ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.ping[].nodata(180)}=1PostgreSQL Health: no ping from PostgreSQL for 3 minutes on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.prepared.oldest.last()}>{$MAX_PREPARED_TRANSACTION_TIME}PostgreSQL Prepared Transactions: prepared transaction is too old on {HOSTNAME}030{Mamonsu PostgreSQL Linux:system.processes[forkrate].min(5m)}>500System: process fork-rate too frequently on {HOSTNAME}030{Mamonsu PostgreSQL Linux:pgsql.replication_lag[sec].last()}>{$CRITICAL_LAG_SECONDS}PostgreSQL Replication: streaming lag too high on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:pgsql.replication.non_active_slots[].last()}>0PostgreSQL Replication: number of non-active replication slots on {HOSTNAME} (value={ITEM.LASTVALUE})030{Mamonsu PostgreSQL Linux:system.uptime[].last()}<{$SYSTEM_UPTIME}System: {HOSTNAME} was restarted (start time={ITEM.LASTVALUE})030
+ PostgreSQL Archiver: Archive Status9002000.0100.0110100.00.0000002006AAE020- Mamonsu PostgreSQL Linuxpgsql.archive_command[count_files_to_archive]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.archive_command[archived_files]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.archive_command[failed_trying_to_archive]
PostgreSQL Autovacuum: Count of Autovacuum Workers9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.autovacuum.count[]
PostgreSQL bgwriter: Buffers9002000.0100.0110100.00.0000002006AAE020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_checkpoint]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_clean]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_backend]
32FF5656020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_alloc]
PostgreSQL bgwriter: Events9002000.0100.0110100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[maxwritten_clean]
1200CC00020- Mamonsu PostgreSQL Linuxpgsql.bgwriter[buffers_backend_fsync]
PostgreSQL Checkpoints: Count (in hour)9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[count_timed]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[count_wal]
PostgreSQL Checkpoints: Write/Sync9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[write_time]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.checkpoint[checkpoint_sync_time]
PostgreSQL Connections: Overview9002000.0100.0111100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.connections[active]
12A39B98020- Mamonsu PostgreSQL Linuxpgsql.connections[idle]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.connections[idle_in_transaction]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.connections[idle_in_transaction_aborted]
4200B0B8020- Mamonsu PostgreSQL Linuxpgsql.connections[fastpath_function_call]
523B415A020- Mamonsu PostgreSQL Linuxpgsql.connections[disabled]
62FF5656020- Mamonsu PostgreSQL Linuxpgsql.connections[total]
72006AAE020- Mamonsu PostgreSQL Linuxpgsql.connections[waiting]
8287C2B9020- Mamonsu PostgreSQL Linuxpgsql.connections[other]
System: Block Devices Read/Write Operations9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.all_read[]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.all_write[]
System: Block Devices Read/Write Bytes9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.disk.all_read_b[]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.disk.all_write_b[]
PostgreSQL Instance: Blocks Rate9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.blocks[hit]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.blocks[read]
PostgreSQL Instance: Transactions Rate9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.transactions[committed]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.events[xact_rollback]
PostgreSQL Instance: Events9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.events[conflicts]
12FF5656020- Mamonsu PostgreSQL Linuxpgsql.events[deadlocks]
22006AAE020- Mamonsu PostgreSQL Linuxpgsql.events[checksum_failures]
PostgreSQL Instance: Temp Files9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.temp[bytes]
12006AAE120- Mamonsu PostgreSQL Linuxpgsql.temp[files]
PostgreSQL Instance: Tuples9002000.0100.0110100.00.0000002FF5656020- Mamonsu PostgreSQL Linuxpgsql.tuples[deleted]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.tuples[fetched]
2200CC00020- Mamonsu PostgreSQL Linuxpgsql.tuples[inserted]
32001219120- Mamonsu PostgreSQL Linuxpgsql.tuples[returned]
429C8A4E020- Mamonsu PostgreSQL Linuxpgsql.tuples[updated]
System: Server Memory Detailed Overview9004000.0100.0111100.00.0000000BAEB6B020- Mamonsu PostgreSQL Linuxsystem.memory[active]
1000CC00020- Mamonsu PostgreSQL Linuxsystem.memory[available]
2000B0B8020- Mamonsu PostgreSQL Linuxsystem.memory[buffers]
3052768F020- Mamonsu PostgreSQL Linuxsystem.memory[cached]
409C8A4E020- Mamonsu PostgreSQL Linuxsystem.memory[committed]
50A39B98020- Mamonsu PostgreSQL Linuxsystem.memory[inactive]
609F1E28020- Mamonsu PostgreSQL Linuxsystem.memory[mapped]
70793F5D020- Mamonsu PostgreSQL Linuxsystem.memory[page_tables]
80F6CB93020- Mamonsu PostgreSQL Linuxsystem.memory[slab]
90006AAE020- Mamonsu PostgreSQL Linuxsystem.memory[swap]
10087C2B9020- Mamonsu PostgreSQL Linuxsystem.memory[swap_cache]
1103B415A020- Mamonsu PostgreSQL Linuxsystem.memory[unused]
120001219020- Mamonsu PostgreSQL Linuxsystem.memory[used]
130CF6518020- Mamonsu PostgreSQL Linuxsystem.memory[vmalloc_used]
System: Server Free/Used Memory Overview9004000.0100.0110100.00.0000001001219020- Mamonsu PostgreSQL Linuxsystem.memory[used]
1152768F020- Mamonsu PostgreSQL Linuxsystem.memory[cached]
2100CC00020- Mamonsu PostgreSQL Linuxsystem.memory[available]
34FF5656020- Mamonsu PostgreSQL Linuxsystem.memory[total]
PostgreSQL pg_buffercache: Shared Buffer9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.buffers[size]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.buffers[twice_used]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.buffers[dirty]
PostgreSQL: Locks Sampling9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[accessshare]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[rowshare]
22FF5656020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[rowexclusive]
32F6CB93020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[shareupdateexclusive]
42006AAE020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[share]
5200B0B8020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[sharerowexclusive]
629C8A4E020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[exclusive]
72793F5D020- Mamonsu PostgreSQL Linuxpgsql.pg_locks[accessexclusive]
PostgreSQL Prepared Transactions: Overview9002000.0100.0110100.00.0000002A39B98020- Mamonsu PostgreSQL Linuxpgsql.prepared.count
129C8A4E120- Mamonsu PostgreSQL Linuxpgsql.prepared.oldest
System: Processes Overview9002000.0100.0110100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.processes[running]
12FF5656020- Mamonsu PostgreSQL Linuxsystem.processes[blocked]
22006AAE120- Mamonsu PostgreSQL Linuxsystem.processes[forkrate]
System: CPU Time Spent9002000.0100.0111100.00.000000200CC00020- Mamonsu PostgreSQL Linuxsystem.cpu[user]
12793F5D020- Mamonsu PostgreSQL Linuxsystem.cpu[nice]
229C8A4E020- Mamonsu PostgreSQL Linuxsystem.cpu[system]
32A39B98020- Mamonsu PostgreSQL Linuxsystem.cpu[idle]
42006AAE020- Mamonsu PostgreSQL Linuxsystem.cpu[iowait]
52FF5656020- Mamonsu PostgreSQL Linuxsystem.cpu[irq]
62F6CB93020- Mamonsu PostgreSQL Linuxsystem.cpu[softirq]
PostgreSQL Statements: Bytes9002000.0100.0110100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.stat[read_bytes]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat[write_bytes]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat[dirty_bytes]
PostgreSQL Statements: Spent Time9002000.0100.0111100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.stat[read_time]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.stat[write_time]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat[other_time]
PostgreSQL Statements: WAL Statistics9002000.0100.0110100.00.000000200B0B8020- Mamonsu PostgreSQL Linuxpgsql.stat[wal_bytes]
12006AAE020- Mamonsu PostgreSQL Linuxpgsql.stat[wal_records]
229C8A4E020- Mamonsu PostgreSQL Linuxpgsql.stat[wal_fpi]
PostgreSQL Wait Sampling: Locks by Type9002000.0100.0111100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.all_lock[lwlock]
12793F5D020- Mamonsu PostgreSQL Linuxpgsql.all_lock[hwlock]
2200B0B8020- Mamonsu PostgreSQL Linuxpgsql.all_lock[buffer]
329C8A4E020- Mamonsu PostgreSQL Linuxpgsql.all_lock[extension]
42F6CB93020- Mamonsu PostgreSQL Linuxpgsql.all_lock[client]
523B415A020- Mamonsu PostgreSQL Linuxpgsql.all_lock[other]
PostgreSQL Wait Sampling: Heavyweight Locks9002000.0100.0111100.00.000000287C2B9020- Mamonsu PostgreSQL Linuxpgsql.hwlock[relation]
123B415A020- Mamonsu PostgreSQL Linuxpgsql.hwlock[extend]
22F6CB93020- Mamonsu PostgreSQL Linuxpgsql.hwlock[page]
32006AAE020- Mamonsu PostgreSQL Linuxpgsql.hwlock[tuple]
4200B0B8020- Mamonsu PostgreSQL Linuxpgsql.hwlock[transactionid]
52793F5D020- Mamonsu PostgreSQL Linuxpgsql.hwlock[virtualxid]
629C8A4E020- Mamonsu PostgreSQL Linuxpgsql.hwlock[speculative_token]
72A39B98020- Mamonsu PostgreSQL Linuxpgsql.hwlock[object]
8252768F020- Mamonsu PostgreSQL Linuxpgsql.hwlock[userlock]
92FE9430020- Mamonsu PostgreSQL Linuxpgsql.hwlock[advisory]
PostgreSQL Wait Sampling: Lightweight Locks9002000.0100.0111100.00.0000002793F5D020- Mamonsu PostgreSQL Linuxpgsql.lwlock[xid]
1200B0B8020- Mamonsu PostgreSQL Linuxpgsql.lwlock[autovacuum]
2287C2B9020- Mamonsu PostgreSQL Linuxpgsql.lwlock[wal]
32006AAE020- Mamonsu PostgreSQL Linuxpgsql.lwlock[clog]
423B415A020- Mamonsu PostgreSQL Linuxpgsql.lwlock[replication]
529C8A4E020- Mamonsu PostgreSQL Linuxpgsql.lwlock[logical_replication]
62F6CB93020- Mamonsu PostgreSQL Linuxpgsql.lwlock[buffer]
72A39B98020- Mamonsu PostgreSQL Linuxpgsql.lwlock[other]
\ No newline at end of file
diff --git a/packaging/debian/changelog b/packaging/debian/changelog
index 6f9cb2a8..6efa0973 100644
--- a/packaging/debian/changelog
+++ b/packaging/debian/changelog
@@ -1,3 +1,57 @@
+mamonsu (3.5.13-1) stable; urgency=low
+ * Added a new metric that displays the bytes held by non-active replication slots, along with the corresponding trigger.;
+ * Set the trigger for 'number of non-active replication slots' to be disabled by default.;
+ * Fixed the Linux plugin to ensure compatibility with recent Linux versions that use cgroups2.;
+ * Resolved a deadlock issue in the send queue that caused Mamonsu to hang after network problems.;
+
+mamonsu (3.5.12-1) stable; urgency=low
+ * Port version parser code from public archive of pypa/pkg_resources;
+ * Thread-safe implementation of connection cache;
+ * Skip BGwriter and Checkpoint plugins initialization if Postgres metrics collection was explicitly disabled;
+
+mamonsu (3.5.11-1) stable; urgency=low
+ * Updated statements plugin: added support for pgpro_stats 1.8;
+ * Fixed types for count_wal_lag_lsn() function (int to bigint);
+
+mamonsu (3.5.10-1) stable; urgency=low
+ * Updated checkpoint plugin: added support for new view pg_stat_checkpointer;
+ * Updated bgwriter plugin: consider updated view pg_stat_bgwriter in postgres 17;
+ * Run zabbix cli tools with latest setuptools installed (>67.7.2);
+
+mamonsu (3.5.9-1) stable; urgency=low
+ * Run on systems with latest setuptools installed (>67.7.2);
+ * Drop using dotted user:group specification in RPM pre-install stage;
+
+mamonsu (3.5.8-1) stable; urgency=low
+ * Prepare for python 3.12: remove deprecated distutils imports;
+
+mamonsu (3.5.7-1) stable; urgency=low
+ * added support for Zabbix 6.4 API: handle deprecated parameters for auth request;
+ * removed caching of pgsql.connections[max_connections] metric;
+ * update default logrotate rules;
+
+mamonsu (3.5.6-1) stable; urgency=low
+ * changed pg_locks plugin metrics names. Warning: custom user-defined triggers and processing functions may be broken if they use item.name parameter.;
+
+mamonsu (3.5.5-1) stable; urgency=low
+ * fixed types mismatch for pgpro_stats and pg_wait_sampling;
+
+mamonsu (3.5.4-1) stable; urgency=low
+ * fixed privileges for mamonsu role created by bootstrap;
+
+mamonsu (3.5.3-1) stable; urgency=low
+ * removed the owner check for the mamonsu agent.conf file (previously this was not flexible and only required the user "mamonsu");
+ * removed metrics that conflict with the native Zabbix agent metrics (only in agent mode, in regular mode it works as usual);
+ * added pg_stat_wal queries for native Zabbix agent;
+ * fixed native Zabbix agent queries;
+
+mamonsu (3.5.2-1) stable; urgency=low
+ * fixed Statements plugin list of metrics creation;
+ * fixed Zabbix API requests to fit new Dashboard Template section rules;
+ * fixed Replication plugin metrics - null values are now taken into account;
+ * added new autovacuum utilization metrics: instant and average per 5, 15 and 30 minutes;
+ * moved plugin custom parameters to Zabbix Macros;
+
mamonsu (3.5.1-1) stable; urgency=low
* fixed delta speed metrics evaluation;
diff --git a/packaging/debian/compat b/packaging/debian/compat
index 7ed6ff82..ec635144 100644
--- a/packaging/debian/compat
+++ b/packaging/debian/compat
@@ -1 +1 @@
-5
+9
diff --git a/packaging/rpm/SOURCES/mamonsu-logrotate.in b/packaging/rpm/SOURCES/mamonsu-logrotate.in
index 22fee288..31bc8ac8 100644
--- a/packaging/rpm/SOURCES/mamonsu-logrotate.in
+++ b/packaging/rpm/SOURCES/mamonsu-logrotate.in
@@ -1,16 +1,3 @@
-/var/log/mamonsu/agent.log {
- daily
- rotate 7
- compress
- missingok
- notifempty
- create 0640 mamonsu mamonsu
- sharedscripts
- postrotate
- [ -e /var/run/mamonsu/mamonsu.pid ] && /etc/init.d/mamonsu restart >/dev/null
- endscript
-}
-
/var/log/mamonsu/mamonsu.log {
daily
rotate 7
@@ -20,15 +7,11 @@
create 0640 mamonsu mamonsu
sharedscripts
postrotate
- [ -e /var/run/mamonsu/mamonsu.pid ] && /etc/init.d/mamonsu restart >/dev/null
+ if [ -d "/run/systemd/system" -a -x "/bin/systemctl" ]; then
+ /bin/systemctl condrestart mamonsu >/dev/null
+ else
+ /etc/init.d/mamonsu condrestart >/dev/null
+ fi
endscript
}
-/var/log/mamonsu/localhost.log {
- daily
- rotate 7
- compress
- missingok
- notifempty
- create 0640 mamonsu mamonsu
-}
diff --git a/packaging/rpm/SPECS/mamonsu.spec b/packaging/rpm/SPECS/mamonsu.spec
index 05427220..dcfd2bde 100644
--- a/packaging/rpm/SPECS/mamonsu.spec
+++ b/packaging/rpm/SPECS/mamonsu.spec
@@ -1,5 +1,5 @@
Name: mamonsu
-Version: 3.5.1
+Version: 3.5.13
Release: 1%{?dist}
Summary: Monitoring agent for PostgreSQL
Group: Applications/Internet
@@ -57,22 +57,76 @@ getent passwd mamonsu > /dev/null || \
-c "mamonsu monitoring user" mamonsu
mkdir -p /var/run/mamonsu
-chown -R mamonsu.mamonsu /var/run/mamonsu
+chown -R mamonsu:mamonsu /var/run/mamonsu
mkdir -p /etc/mamonsu/plugins
touch /etc/mamonsu/plugins/__init__.py
mkdir -p /var/log/mamonsu
-chown -R mamonsu.mamonsu /var/log/mamonsu
+chown -R mamonsu:mamonsu /var/log/mamonsu
%preun
/sbin/service mamonsu stop >/dev/null 2>&1
/sbin/chkconfig --del mamonsu
%post
-chown -R mamonsu.mamonsu /etc/mamonsu
+chown -R mamonsu:mamonsu /etc/mamonsu
%changelog
+* Thu May 29 2025 Andrey Papsuyko - 3.5.13-1
+ - Added a new metric that displays the bytes held by non-active replication slots, along with the corresponding trigger.;
+ - Set the trigger for 'number of non-active replication slots' to be disabled by default.;
+ - Fixed the Linux plugin to ensure compatibility with recent Linux versions that use cgroups2.;
+ - Resolved a deadlock issue in the send queue that caused Mamonsu to hang after network problems.;
+
+* Wed Mar 5 2025 Maxim Styushin - 3.5.12-1
+ - Port version parser code from public archive of pypa/pkg_resources;
+ - Thread-safe implementation of connection cache;
+ - Skip BGwriter and Checkpoint plugins initialization if Postgres metrics collection was explicitly disabled;
+
+* Wed Jan 15 2025 Maxim Styushin - 3.5.11-1
+ - Updated statements plugin: added support for pgpro_stats 1.8;
+ - Fixed types for count_wal_lag_lsn() function (int to bigint);
+
+* Sat Dec 14 2024 Maxim Styushin - 3.5.10-1
+ - Updated checkpoint plugin: added support for new view pg_stat_checkpointer;
+ - Updated bgwriter plugin: consider updated view pg_stat_bgwriter in postgres 17;
+ - Run zabbix cli tools with latest setuptools installed (>67.7.2);
+
+* Mon Aug 19 2024 Maxim Styushin - 3.5.9-1
+ - Run on systems with latest setuptools installed (>67.7.2);
+ - Drop using dotted user:group specification in RPM pre-install stage;
+
+* Thu Apr 18 2024 Maxim Styushin - 3.5.8-1
+ - Prepare for python 3.12: remove deprecated distutils imports;
+
+* Fri Apr 5 2024 Maxim Styushin - 3.5.7-1
+ - added support for Zabbix 6.4 API: handle deprecated parameters for auth request;
+ - removed caching of pgsql.connections[max_connections] metric;
+ - update default logrotate rules;
+
+* Thu Jan 11 2024 Alexandra Kuznetsova - 3.5.6-1
+ - changed pg_locks plugin metrics names. Warning: custom user-defined triggers and processing functions may be broken if they use item.name parameter.;
+
+* Tue Jun 13 2023 Alexandra Kuznetsova - 3.5.5-1
+ - fixed types mismatch for pgpro_stats and pg_wait_sampling;
+
+* Wed May 17 2023 Alexandra Kuznetsova - 3.5.4-1
+ - fixed privileges for mamonsu role created by bootstrap;
+
+* Thu Mar 16 2023 Alexandra Kuznetsova - 3.5.3-1
+ - removed the owner check for the mamonsu agent.conf file (previously this was not flexible and only required the user "mamonsu");
+ - removed metrics that conflict with the native Zabbix agent metrics (only in agent mode, in regular mode it works as usual);
+ - added pg_stat_wal queries for native Zabbix agent;
+ - fixed native Zabbix agent queries;
+
+* Tue Aug 16 2022 Alexandra Kuznetsova - 3.5.2-1
+ - fixed Statements plugin list of metrics creation;
+ - fixed Zabbix API requests to fit new Dashboard Template section rules;
+ - fixed Replication plugin metrics - null values are now taken into account;
+ - added new autovacuum utilization metrics: instant and average per 5, 15 and 30 minutes;
+ - moved plugin custom parameters to Zabbix Macros;
+
* Fri Jul 29 2022 Alexandra Kuznetsova - 3.5.1-1
- fixed delta speed metrics evaluation;
diff --git a/packaging/win/mamonsu.def.nsh b/packaging/win/mamonsu.def.nsh
index 75f33fcf..5afbfdc5 100644
--- a/packaging/win/mamonsu.def.nsh
+++ b/packaging/win/mamonsu.def.nsh
@@ -1,5 +1,5 @@
!define NAME Mamonsu
-!define VERSION 3.5.1
+!define VERSION 3.5.13
!define MAMONSU_REG_PATH "Software\PostgresPro\Mamonsu"
!define MAMONSU_REG_UNINSTALLER_PATH "Software\Microsoft\Windows\CurrentVersion\Uninstall"
!define EDB_REG "SOFTWARE\Postgresql"
diff --git a/service_win32.spec b/service_win32.spec
index 2d35e92c..175fe4ee 100644
--- a/service_win32.spec
+++ b/service_win32.spec
@@ -9,6 +9,7 @@ a = Analysis(['service_win32.py'],
datas=[],
hiddenimports=[
'mamonsu.plugins.pgsql.archive_command',
+ 'mamonsu.plugins.pgsql.autovacuum',
'mamonsu.plugins.pgsql.bgwriter',
'mamonsu.plugins.pgsql.cfs',
'mamonsu.plugins.pgsql.checkpoint',