fix: fixed extension monitoring without mamonsu user

Author: cuprumtan

mamonsu/plugins/pgsql/driver/pool.py

@@ -32,7 +32,7 @@ class Pool(object):
             "select sum(1) * (current_setting('block_size')::int8) as size, "
             " sum(case when usagecount > 1 then 1 else 0 end) * (current_setting('block_size')::int8) as twice_used, "
             " sum(case isdirty when true then 1 else 0 end) * (current_setting('block_size')::int8) as dirty "
-            " from mamonsu.pg_buffercache",
+            " from {0}.pg_buffercache",
             'select size, twice_used, dirty from mamonsu.buffer_cache()'
         ),
         'wal_lag_lsn': (
@@ -56,6 +56,7 @@ def __init__(self, params=None):
             'server_version': {'storage': {}},
             'bootstrap': {'storage': {}, 'counter': 0, 'cache': 10, 'version': False},
             'recovery': {'storage': {}, 'counter': 0, 'cache': 10},
+            'extension_schema': {'pg_buffercache': {}},
             'pgpro': {'storage': {}},
             'pgproee': {'storage': {}}
         }
@@ -167,6 +168,16 @@ def extension_installed(self, ext, db=None):
             'where extname = \'{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]
+        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]
+
     def databases(self):
         result, databases = self.query(
             'select datname from '
@@ -176,24 +187,25 @@ def databases(self):
                 databases.append(row[0])
         return databases
 
-    def fill_query_params(self, query, params):
-        if params:
-            return query.format(*params)
-        else:
-            return query
+    def fill_query_params(self, query, params, extension=None, db=None):
+        if not params:
+            params = []
+        if extension:
+            params.append(self.extension_schema(extension, db))
+        return query.format(*params)
 
-    def get_sql(self, typ, args=None, db=None):
+    def get_sql(self, typ, args=None, extension=None, db=None):
         db = self._normalize_db(db)
         if typ not in self.SQL:
             raise LookupError("Unknown SQL type: '{0}'".format(typ))
         result = self.SQL[typ]
         if self.is_bootstraped(db):
-            return self.fill_query_params(result[1], args)
+            return self.fill_query_params(result[1], args, extension, db)
         else:
-            return self.fill_query_params(result[0], args)
+            return self.fill_query_params(result[0], args, extension, db)
 
-    def run_sql_type(self, typ, args=None, db=None):
-        return self.query(self.get_sql(typ, args, db), db)
+    def run_sql_type(self, typ, args=None, extension=None, db=None):
+        return self.query(self.get_sql(typ, args, extension, db), db)
 
     def _normalize_db(self, db=None):
         if db is None:

mamonsu/plugins/pgsql/pg_buffercache.py

@@ -8,14 +8,14 @@
 class PgBufferCache(Plugin):
     AgentPluginType = 'pg'
     key = 'pgsql.buffers{0}'
-    query_agent_size = "select sum(1) *  (current_setting('block_size')::int8) as size from mamonsu.pg_buffercache;"
+    query_agent_size = "select sum(1) *  (current_setting('block_size')::int8) as size from {0}.pg_buffercache;"
     # for zabbix
     query_agent_twice_used = "select " \
                              "sum(case when usagecount > 1 then 1 else 0 end) * (current_setting('block_size')::int8) as twice_used " \
-                             "from mamonsu.pg_buffercache;"  # for zabbix
+                             "from {0}.pg_buffercache;"  # for zabbix
     query_agent_dirty = "select " \
                         "sum(case isdirty when true then 1 else 0 end) * (current_setting('block_size')::int8) as dirty " \
-                        "from mamonsu.pg_buffercache;"  # for zabbix
+                        "from {0}.pg_buffercache;"  # for zabbix
     query = [query_agent_size, query_agent_twice_used, query_agent_dirty]
     Items = [
         # key, name, color
@@ -27,7 +27,7 @@ class PgBufferCache(Plugin):
     def run(self, zbx):
         if not self.extension_installed('pg_buffercache'):
             return
-        result = Pooler.run_sql_type('buffer_cache')[0]
+        result = Pooler.run_sql_type('buffer_cache', extension='pg_buffercache')[0]
         for i, value in enumerate(result):
             zbx.send('pgsql.buffers[{0}]'.format(self.Items[i][0]), value)
 
@@ -65,5 +65,5 @@ def keys_and_queries(self, template_zabbix):
         result = []
         for i, item in enumerate(self.Items):
             result.append('{0}[*],$2 $1 -c "{1}"'.format(self.key.format('.' + item[0]),
-                                                         self.query[i].format(item[0])))
+                                                         self.query[i].format(self.extension_schema(extension='pg_buffercache'))))
         return template_zabbix.key_and_query(result)

mamonsu/plugins/pgsql/plugin.py

@@ -34,6 +34,9 @@ def check(self, extension):
 
         return self._ext_installed
 
+    def extension_schema(self, extension, db=None):
+        return Pooler.extension_schema(extension, db)
+
     def disable_and_exit_if_extension_is_not_installed(self, ext, db=None):
         if not self.extension_installed(ext, db=db, silent=True):
             self.disable()