Report some I/O metrics in bytes

* Add a query for pg_stat_io metrics grouped by backend type

* Switch some unsupported values from 0 to NULL to better reflect their
  nonexistence

Makefile

@@ -74,12 +74,12 @@ install-common:
 	# Set up directories
 	mkdir -p $(DESTDIR)/etc/$(PACKAGE_NAME)
 	mkdir -p ${DESTDIR}/etc/logrotate.d
-	mkdir -p $(DESTDIR)/usr/local/bin
+	mkdir -p $(DESTDIR)/usr/bin
 	mkdir -p $(DESTDIR)/usr/share/man/man1
 	
 	# Install script
-	cp $(SCRIPT) $(DESTDIR)/usr/local/bin/$(PACKAGE_NAME)
+	cp $(SCRIPT) $(DESTDIR)/usr/bin/$(PACKAGE_NAME)
-	chmod 755 $(DESTDIR)/usr/local/bin/$(PACKAGE_NAME)
+	chmod 755 $(DESTDIR)/usr/bin/$(PACKAGE_NAME)
 	
 	# Install manpage
 	cp manpages/* $(DESTDIR)/usr/share/man/man1/
@@ -113,6 +113,7 @@ install-openrc:
 	
 	# Install init script
 	cp openrc/pgmon.initd $(DESTDIR)/etc/init.d/pgmon
+	chmod 755 $(DESTDIR)/etc/init.d/pgmon
 	
 	# Install init script config file
 	cp openrc/pgmon.confd $(DESTDIR)/etc/conf.d/pgmon

RPM/pgmon-el7.spec

@@ -28,7 +28,7 @@ make -C /src install-systemd DESTDIR=%{buildroot}
 /etc/pgmon/pgmon-service.conf
 /lib/systemd/system/pgmon.service
 /lib/systemd/system/pgmon@.service
-/usr/local/bin/pgmon
+/usr/bin/pgmon
 /usr/share/man/man1/pgmon.1.gz
 
 %post

RPM/pgmon.spec

@@ -28,7 +28,7 @@ make -C /src install-systemd DESTDIR=%{buildroot}
 /etc/pgmon/pgmon-service.conf
 /lib/systemd/system/pgmon.service
 /lib/systemd/system/pgmon@.service
-/usr/local/bin/pgmon
+/usr/bin/pgmon
 /usr/share/man/man1/pgmon.1.gz
 
 %post

sample-config/pgmon-metrics.yml

@@ -1,63 +1,270 @@
 metrics:
+  ##
   # Discovery metrics
+  ##
   discover_dbs:
     type: set
     query:
-      0: SELECT datname AS dbname FROM pg_database
+      0: >
+        SELECT datname AS dbname
+        FROM pg_database
   discover_rep:
     type: set
     query:
-      0: SELECT client_addr || '_' || regexp_replace(application_name, '[ ,]', '_', 'g') AS repid, client_addr, state FROM pg_stat_replication
+      0: >
+        SELECT client_addr || '_' || regexp_replace(application_name, '[ ,]', '_', 'g') AS repid,
+               client_addr,
+               state
+        FROM pg_stat_replication
   discover_slots:
     type: set
     query:
-      90400: SELECT slot_name, plugin, slot_type, database, false as temporary, active FROM pg_replication_slots
+      90400: >
-      100000: SELECT slot_name, plugin, slot_type, database, temporary, active FROM pg_replication_slots
+        SELECT slot_name,
+               plugin,
+               slot_type,
+               database,
+               false as temporary,
+               active
+        FROM pg_replication_slots
+      100000: >
+        SELECT slot_name,
+               plugin,
+               slot_type,
+               database,
+               temporary,
+               active
+        FROM pg_replication_slots
 
+  ##
   # cluster-wide metrics
+  ##
   version:
     type: value
     query:
       0: SHOW server_version_num
+
   max_frozen_age:
     type: row
     query:
-      0: SELECT max(age(datfrozenxid)), max(mxid_age(datminmxid)) FROM pg_database
+      0: >
+        SELECT max(age(datfrozenxid)) AS xid_age,
+               NULL AS mxid_age
+        FROM pg_database
+      90600: >
+        SELECT max(age(datfrozenxid)) AS xid_age,
+               max(mxid_age(datminmxid)) AS mxid_age
+        FROM pg_database
 
+  bgwriter:
+    type: row
+    query:
+      0: >
+        SELECT checkpoints_timed,
+               checkpoints_req,
+               checkpoint_write_time,
+               checkpoint_sync_time,
+               buffers_checkpoint,
+               buffers_clean,
+               maxwritten_clean,
+               buffers_backend,
+               buffers_backend_fsync,
+               buffers_alloc
+        FROM pg_stat_bgwriter
+      170000: >
+        SELECT cp.num_timed AS checkpoints_timed,
+               cp.num_requested AS checkpoints_req,
+               cp.write_time AS checkpoint_write_time,
+               cp.sync_time AS checkpoint_sync_time,
+               cp.buffers_written AS buffers_checkpoint,
+               bg.buffers_clean AS buffers_clean,
+               bg.maxwritten_clean AS maxwritten_clean,
+               NULL AS buffers_backend,
+               NULL AS buffers_backend_fsync,
+               bg.buffers_alloc AS buffers_alloc
+        FROM pg_stat_bgwriter bg
+        CROSS JOIN pg_stat_checkpointer cp
+
+
+  io_per_backend:
+    type: set
+    query:
+      160000: >
+        SELECT backend_type,
+               COALESCE(SUM(reads * op_bytes), 0)::bigint AS reads,
+               COALESCE(SUM(read_time), 0)::bigint AS read_time,
+               COALESCE(SUM(writes * op_bytes), 0)::bigint AS writes,
+               COALESCE(SUM(write_time), 0)::bigint AS write_time,
+               COALESCE(SUM(writebacks * op_bytes), 0)::bigint AS writebacks,
+               COALESCE(SUM(writeback_time), 0)::bigint AS writeback_time,
+               COALESCE(SUM(extends * op_bytes), 0)::bigint AS extends,
+               COALESCE(SUM(extend_time), 0)::bigint AS extend_time,
+               COALESCE(SUM(op_bytes), 0)::bigint AS op_bytes,
+               COALESCE(SUM(hits), 0)::bigint AS hits,
+               COALESCE(SUM(evictions), 0)::bigint AS evictions,
+               COALESCE(SUM(reuses), 0)::bigint AS reuses,
+               COALESCE(SUM(fsyncs), 0)::bigint AS fsyncs,
+               COALESCE(SUM(fsync_time), 0)::bigint AS fsync_time
+        FROM pg_stat_io
+        GROUP BY backend_type
+
+  ##
   # Per-database metrics
+  ##
   db_stats:
     type: row
     query:
-      0: SELECT numbackends, xact_commit, xact_rollback, blks_read, blks_hit, tup_returned, tup_fetched, tup_inserted, tup_updated, tup_deleted, conflicts, temp_files, temp_bytes, deadlocks, blk_read_time, blk_write_time, extract('epoch' from stats_reset)::float FROM pg_stat_database WHERE datname = %(dbname)s
+      0: >
-      140000: SELECT numbackends, xact_commit, xact_rollback, blks_read, blks_hit, tup_returned, tup_fetched, tup_inserted, tup_updated, tup_deleted, conflicts, temp_files, temp_bytes, deadlocks, COALESCE(checksum_failures, 0) AS checksum_failures, blk_read_time, blk_write_time, session_time, active_time, idle_in_transaction_time, sessions, sessions_abandoned, sessions_fatal, sessions_killed, extract('epoch' from stats_reset)::float FROM pg_stat_database WHERE datname = %(dbname)s
+        SELECT numbackends,
+               xact_commit,
+               xact_rollback,
+               blks_read,
+               blks_hit,
+               tup_returned,
+               tup_fetched,
+               tup_inserted,
+               tup_updated,
+               tup_deleted,
+               conflicts,
+               temp_files,
+               temp_bytes,
+               deadlocks,
+               NULL AS checksum_failures,
+               blk_read_time,
+               blk_write_time,
+               NULL AS session_time,
+               NULL AS active_time,
+               NULL AS idle_in_transaction_time,
+               NULL AS sessions,
+               NULL AS sessions_abandoned,
+               NULL AS sessions_fatal,
+               NULL AS sessions_killed,
+               extract('epoch' from stats_reset)::float AS stats_reset
+        FROM pg_stat_database WHERE datname = %(dbname)s
+      140000: >
+        SELECT numbackends,
+               xact_commit,
+               xact_rollback,
+               blks_read,
+               blks_hit,
+               tup_returned,
+               tup_fetched,
+               tup_inserted,
+               tup_updated,
+               tup_deleted,
+               conflicts,
+               temp_files,
+               temp_bytes,
+               deadlocks,
+               COALESCE(checksum_failures, 0) AS checksum_failures,
+               blk_read_time,
+               blk_write_time,
+               session_time,
+               active_time,
+               idle_in_transaction_time,
+               sessions,
+               sessions_abandoned,
+               sessions_fatal,
+               sessions_killed,
+               extract('epoch' from stats_reset)::float AS stats_reset
+        FROM pg_stat_database WHERE datname = %(dbname)s
     test_args:
       dbname: postgres
 
+  hit_ratios:
+    type: row
+    query:
+      0: >
+        SELECT sum(heap_blks_read)::float / NULLIF(sum(heap_blks_read + heap_blks_hit), 0) AS avg_heap_hit_ratio,
+               sum(idx_blks_hit)::float / NULLIF(sum(idx_blks_read + idx_blks_hit), 0) AS avg_idx_hit_ratio,
+               sum(toast_blks_hit)::float / NULLIF(sum(toast_blks_read + toast_blks_hit), 0) AS avg_toast_hit_ratio,
+               sum(tidx_blks_hit)::float / NULLIF(sum(tidx_blks_read + tidx_blks_hit), 0) AS avg_tidx_hit_ratio
+        FROM pg_statio_all_tables
+    test_args:
+      dbname: postgres
+
+  activity:
+    type: set
+    query:
+      0: >
+        SELECT state,
+               count(*) AS backend_count,
+               COALESCE(EXTRACT(EPOCH FROM max(now() - state_change))::float, 0) AS max_state_time
+        FROM pg_stat_activity
+        WHERE datname = %(dbname)s
+        GROUP BY state
+    test_args:
+      dbname: postgres
+
+
+  ##
+  # Per-replication metrics
+  ##
+  rep_stats:
+    type: row
+    query:
+      90400: >
+        SELECT pid, usename,
+               EXTRACT(EPOCH FROM backend_start)::integer AS backend_start,
+               state,
+               pg_xlog_location_diff(pg_current_xlog_location(), sent_location) AS sent_lsn,
+               pg_xlog_location_diff(pg_current_xlog_location(), write_location) AS write_lsn,
+               pg_xlog_location_diff(pg_current_xlog_location(), flush_location) AS flush_lsn,
+               pg_xlog_location_diff(pg_current_xlog_location(), replay_location) AS replay_lsn,
+               NULL AS write_lag,
+               NULL AS flush_lag,
+               NULL AS replay_lag,
+               sync_state
+        FROM pg_stat_replication
+        WHERE client_addr || '_' || regexp_replace(application_name, '[ ,]', '_', 'g') = %(repid)s
+      100000: >
+        SELECT pid, usename,
+               EXTRACT(EPOCH FROM backend_start)::integer AS backend_start,
+               state,
+               pg_wal_lsn_diff(pg_current_wal_lsn(), sent_lsn) AS sent_lsn,
+               pg_wal_lsn_diff(pg_current_wal_lsn(), write_lsn) AS write_lsn,
+               pg_wal_lsn_diff(pg_current_wal_lsn(), flush_lsn) AS flush_lsn,
+               pg_wal_lsn_diff(pg_current_wal_lsn(), replay_lsn) AS replay_lsn,
+               COALESCE(EXTRACT(EPOCH FROM write_lag), 0)::integer AS write_lag,
+               COALESCE(EXTRACT(EPOCH FROM flush_lag), 0)::integer AS flush_lag,
+               COALESCE(EXTRACT(EPOCH FROM replay_lag), 0)::integer AS replay_lag,
+               sync_state
+        FROM pg_stat_replication WHERE client_addr || '_' || regexp_replace(application_name, '[ ,]', '_', 'g') = %(repid)s
+    test_args:
+      repid: 127.0.0.1_test_rep
+
+
+  ##
+  # Per-slot metrics
+  ##
+  slot_stats:
+    type: row
+    query:
+      90400: >
+        SELECT NULL as active_pid,
+               xmin,
+               pg_xlog_location_diff(pg_current_xlog_location(), restart_lsn) AS restart_bytes,
+               NULL AS confirmed_flush_bytes
+        FROM pg_replication_slots WHERE slot_name = %(slot)s
+      90600: >
+        SELECT active_pid,
+               xmin,
+               pg_xlog_location_diff(pg_current_xlog_location(), restart_lsn) AS restart_bytes,
+               pg_xlog_location_diff(pg_current_xlog_location(), confirmed_flush_lsn) AS confirmed_flush_bytes
+        FROM pg_replication_slots WHERE slot_name = %(slot)s
+      100000: >
+        SELECT active_pid,
+               xmin,
+               pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn) AS restart_bytes,
+               pg_wal_lsn_diff(pg_current_wal_lsn(), confirmed_flush_lsn) AS confirmed_flush_bytes
+        FROM pg_replication_slots WHERE slot_name = %(slot)s
+    test_args:
+      slot: test_slot
+
+  ##
   # Debugging
+  ##
   ntables:
     type: value
     query:
       0: SELECT count(*) AS ntables FROM pg_stat_user_tables
-
-  # Per-replication metrics
-  rep_stats:
-    type: row
-    query:
-      90400: SELECT * FROM pg_stat_replication WHERE client_addr || '_' || regexp_replace(application_name, '[ ,]', '_', 'g') = '{repid}'
-    test_args:
-      repid: 127.0.0.1_test_rep
-
-  # Debugging
-  sleep:
-    type: value
-    query:
-      0: SELECT now(), pg_sleep(5);
-
-  # Per-slot metrics
-  slot_stats:
-    type: row
-    query:
-      90400: SELECT active_pid, xmin, pg_xlog_location_diff(pg_current_xlog_location(), restart_lsn) AS restart_bytes, pg_xlog_location_diff(pg_current_xlog_location(), confirmed_flush_lsn) AS confirmed_flush_bytes FROM pg_replication_slots WHERE slot_name = '{slot}'
-      100000: SELECT active_pid, xmin, pg_wal_lsn_diff(pg_current_wal_lsn(), restart_lsn) AS restart_bytes, pg_wal_lsn_diff(pg_current_wal_lsn(), confirmed_flush_lsn) AS confirmed_flush_bytes FROM pg_replication_slots WHERE slot_name = '{slot}'
-    test_args:
-      slot: test_slot

src/pgmon.py

@@ -518,7 +518,6 @@ def parse_version_rss(raw_rss, release):
 
     This sets these global variables:
         latest_version
-        latest_version_next_check
         release_supported
 
     It is expected that the caller already holds the latest_version_lock lock.
@@ -528,7 +527,6 @@ def parse_version_rss(raw_rss, release):
         release: The PostgreSQL release we care about (ex: 9.2, 14)
     """
     global latest_version
-    global latest_version_next_check
     global release_supported
 
     # Regular expressions for parsing the RSS document
@@ -583,6 +581,8 @@ def get_latest_version():
     Get the latest supported version of the major PostgreSQL release running on the server being monitored.
     """
 
+    global latest_version_next_check
+
     # If we don't know the latest version or it's past the recheck time, get the
     # version from the PostgreSQL RSS feed.  Only one thread needs to do this, so
     # they all try to grab the lock, and then make sure nobody else beat them to it.
@@ -655,8 +655,25 @@ def test_queries():
     for name, metric in config["metrics"].items():
         # If the metric has arguments to use while testing, grab those
         args = metric.get("test_args", {})
-        # Run the query without the ability to retry.
+        print("Testing {} [{}]".format(name, ", ".join(["{}={}".format(key, value) for key, value in args.items()])))
-        res = sample_metric(dbname, name, args, retry=False)
+        # When testing against a docker container, we may end up connecting
+        # before the service is truly up (it restarts during the initialization
+        # phase).  To cope with this, we'll allow a few connection failures.
+        tries = 5
+        while True:
+            # Run the query without the ability to retry
+            try:
+                res = sample_metric(dbname, name, args, retry=False)
+                break
+            except MetricVersionError:
+                res = "Unsupported for this version"
+                break
+            except psycopg2.OperationalError as e:
+                print("Error encountered, {} tries left: {}".format(tries, e))
+                if tries <= 0:
+                    raise
+                time.sleep(1)
+            tries -= 1
         # Compare the result to the provided sample results
         # TODO
         print("{} -> {}".format(name, res))
@@ -705,12 +722,16 @@ class SimpleHTTPRequestHandler(BaseHTTPRequestHandler):
                 self._reply(
                     200,
                     json.dumps(
-                        {"latest": latest_version, "supported": 1 if release_supported else 0}
+                        {
+                            "latest": latest_version,
+                            "supported": 1 if release_supported else 0,
+                        }
                     ),
                 )
             except LatestVersionCheckError as e:
                 log.error("Failed to retrieve latest version information: {}".format(e))
                 self._reply(503, "Failed to retrieve latest version info")
+            return
 
         # Note: parse_qs returns the values as a list.  Since we always expect
         #       single values, just grab the first from each.

systemd/pgmon@.service

@@ -7,7 +7,7 @@ After=network.target
 [Service]
 EnvironmentFile=/etc/pgmon/%i-service.conf
 User=${SERVICE_USER:-postgres}
-ExecStart=/usr/local/bin/pgmon -c /etc/pgmon/%i.yml
+ExecStart=/usr/bin/pgmon -c /etc/pgmon/%i.yml
 ExecReload=kill -HUP $MAINPID
 Restart=on-failure
 Type=exec

tests/docker-compose.yml

@@ -23,7 +23,7 @@ services:
       test: [ "CMD-SHELL", "pg_controldata /var/lib/postgresql/data/ | grep -q 'in production'" ]
       interval: 5s
       timeout: 2s
-      retries: 20
+      retries: 40
     command: >
       postgres -c ssl=on
                -c ssl_cert_file='/etc/ssl/certs/ssl-cert-snakeoil.pem'

tests/run-tests.sh

@@ -6,12 +6,15 @@ versions=( $@ )
 # If we weren't given any versions, test them all
 if [ ${#versions[@]} -eq 0 ]
 then
-    versions=( 9.2 9.6 10 11 12 13 14 15 16 17 )
+    versions=( 9.2 9.4 9.6 10 11 12 13 14 15 16 17 )
 fi
 
 # Image tags to use
 declare -A images=()
 images["9.2"]='9.2'
+images["9.3"]='9.3'
+images["9.4"]='9.4'
+images["9.5"]='9.5'
 images["9.6"]='9.6-bullseye'
 images["10"]='10-bullseye'
 images["11"]='11-bookworm'

zabbix_templates/pgmon_templates.yaml

@@ -11,6 +11,44 @@ zabbix_export:
       groups:
         - name: 'My Templates'
       items:
+        - uuid: cc4a50ca681b4c4fb8c1c98f4bc81c96
+          name: 'Max Frozen MXID Age'
+          type: DEPENDENT
+          key: pgmon.age.mxid
+          delay: '0'
+          history: 90d
+          description: 'Maximum age of any frozen MXID in any database'
+          preprocessing:
+            - type: JSONPATH
+              parameters:
+                - $.mxid_age
+            - type: MATCHES_REGEX
+              parameters:
+                - '^[0-9]+$'
+          master_item:
+            key: 'pgmon[max_frozen_age]'
+          tags:
+            - tag: Application
+              value: PostgreSQL
+        - uuid: 2fa86d8c4a3a481e856a9414c5c70216
+          name: 'Max Frozen XID Age'
+          type: DEPENDENT
+          key: pgmon.age.xid
+          delay: '0'
+          history: 90d
+          description: 'Maximum age of any frozen XID in any database'
+          preprocessing:
+            - type: JSONPATH
+              parameters:
+                - $.xid_age
+            - type: MATCHES_REGEX
+              parameters:
+                - '^[0-9]+$'
+          master_item:
+            key: 'pgmon[max_frozen_age]'
+          tags:
+            - tag: Application
+              value: PostgreSQL
         - uuid: de1fa757395440118026f4c7a7c4ebbe
           name: 'PostgreSQL latest supported version'
           type: DEPENDENT
@@ -57,6 +95,20 @@ zabbix_export:
           tags:
             - tag: Application
               value: PostgreSQL
+        - uuid: 06b1d082ed1e4796bc31cc25f7db6326
+          name: 'PostgreSQL Backend IO Info'
+          type: HTTP_AGENT
+          key: 'pgmon[io_per_backend]'
+          history: '0'
+          value_type: TEXT
+          trends: '0'
+          description: 'Aggregated statistics about I/O activity for different backend types'
+          url: 'http://localhost:{$AGENT_PORT}/io_per_backend'
+          tags:
+            - tag: Application
+              value: PostgreSQL
+            - tag: Type
+              value: Raw
         - uuid: d890e395fbbc4f2bacbd50e7321fcb9f
           name: 'PostgreSQL latest version info'
           type: HTTP_AGENT
@@ -66,24 +118,27 @@ zabbix_export:
           value_type: TEXT
           trends: '0'
           description: 'Information about the latest PostgreSQL version in the current series'
-          url: 'http://localhost:{$AGENT_PORT}/version'
+          url: 'http://localhost:{$AGENT_PORT}/latest_version_info'
           tags:
             - tag: Application
               value: PostgreSQL
+            - tag: Type
+              value: Raw
         - uuid: 8706eccb7edc4fa394f552fc31f401a9
-          name: 'Max Frozen XID Age'
+          name: 'PostgreSQL ID Age Info'
           type: HTTP_AGENT
           key: 'pgmon[max_frozen_age]'
-          history: 90d
+          delay: 5m
-          description: 'Maximum age of any frozen XID in any database'
+          history: '0'
-          preprocessing:
+          value_type: TEXT
-            - type: MATCHES_REGEX
+          trends: '0'
-              parameters:
+          description: 'Maximum age of any frozen XID and MXID in any database'
-                - '^[0-9]+$'
           url: 'http://localhost:{$AGENT_PORT}/max_frozen_age'
           tags:
             - tag: Application
               value: PostgreSQL
+            - tag: Type
+              value: Raw
         - uuid: ee88f5f4d2384f97946d049af5af4502
           name: 'PostgreSQL version'
           type: HTTP_AGENT
@@ -636,6 +691,100 @@ zabbix_export:
                   value: '{#DBNAME}'
                 - tag: Type
                   value: Calculated
+            - uuid: bb0690e123e94e35a9bbd0f05ee322b4
+              name: 'Database Hit Ratios for {#DBNAME}'
+              type: HTTP_AGENT
+              key: 'pgmon_db_hit_ratios[{#DBNAME}]'
+              history: '0'
+              value_type: TEXT
+              trends: '0'
+              url: 'http://localhost:{$AGENT_PORT}/hit_ratios'
+              query_fields:
+                - name: dbname
+                  value: '{#DBNAME}'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: Database
+                  value: '{#DBNAME}'
+                - tag: Type
+                  value: Raw
+            - uuid: e0edbaf6f98249a6b357ade2ab41a76a
+              name: 'Average heap hit ratio on {#DBNAME}'
+              type: DEPENDENT
+              key: 'pgmon_db_hit_ratio[heap,{#DBNAME}]'
+              delay: '0'
+              history: 90d
+              value_type: FLOAT
+              description: 'The cache (shared_buffers) hit ratio for heap entries for the given database'
+              preprocessing:
+                - type: JSONPATH
+                  parameters:
+                    - $.avg_heap_hit_ratio
+              master_item:
+                key: 'pgmon_db_hit_ratios[{#DBNAME}]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: Database
+                  value: '{#DBNAME}'
+            - uuid: e4956d433a47455ca0c00d67a0f59355
+              name: 'Average index hit ratio on {#DBNAME}'
+              type: DEPENDENT
+              key: 'pgmon_db_hit_ratio[index,{#DBNAME}]'
+              delay: '0'
+              history: 90d
+              value_type: FLOAT
+              description: 'The cache (shared_buffers) hit ratio for index entries for the given database'
+              preprocessing:
+                - type: JSONPATH
+                  parameters:
+                    - $.avg_idx_hit_ratio
+              master_item:
+                key: 'pgmon_db_hit_ratios[{#DBNAME}]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: Database
+                  value: '{#DBNAME}'
+            - uuid: 0335267c14a8410a80a16b38167efcb3
+              name: 'Average toast hit ratio on {#DBNAME}'
+              type: DEPENDENT
+              key: 'pgmon_db_hit_ratio[toast,{#DBNAME}]'
+              delay: '0'
+              history: 90d
+              value_type: FLOAT
+              description: 'The cache (shared_buffers) hit ratio for heap entries for the given database'
+              preprocessing:
+                - type: JSONPATH
+                  parameters:
+                    - $.avg_toast_hit_ratio
+              master_item:
+                key: 'pgmon_db_hit_ratios[{#DBNAME}]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: Database
+                  value: '{#DBNAME}'
+            - uuid: 3f7da45e351443528c6c36145d38f9b8
+              name: 'Average toast index hit ratio on {#DBNAME}'
+              type: DEPENDENT
+              key: 'pgmon_db_hit_ratio[toast_index,{#DBNAME}]'
+              delay: '0'
+              history: 90d
+              value_type: FLOAT
+              description: 'The cache (shared_buffers) hit ratio for toast index entries for the given database'
+              preprocessing:
+                - type: JSONPATH
+                  parameters:
+                    - $.avg_tidx_hit_ratio
+              master_item:
+                key: 'pgmon_db_hit_ratios[{#DBNAME}]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: Database
+                  value: '{#DBNAME}'
             - uuid: 492b3cac15f348c2b85f97b69c114d1b
               name: 'Database Stats for {#DBNAME}'
               type: HTTP_AGENT
@@ -652,6 +801,8 @@ zabbix_export:
                   value: PostgreSQL
                 - tag: Database
                   value: '{#DBNAME}'
+                - tag: Type
+                  value: Raw
           graph_prototypes:
             - uuid: 1f7de43b77714f819e61c31273712b70
               name: 'DML Totals for {#DBNAME}'
@@ -744,6 +895,596 @@ zabbix_export:
           lld_macro_paths:
             - lld_macro: '{#DBNAME}'
               path: $.dbname
+        - uuid: 6afbe12fb9f54fa2ad29d647429eb16e
+          name: 'Discover I/O Backend Types'
+          type: DEPENDENT
+          key: pgmon_discover_io_backend_types
+          delay: '0'
+          item_prototypes:
+            - uuid: b1ac2e56b30f4812bf33ce973ef16b10
+              name: 'I/O Evictions by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend[evictions,{#BACKEND_TYPE}]'
+              delay: '0'
+              preprocessing:
+                - type: JSONPATH
+                  parameters:
+                    - '$[?(@.backend_type == "{#BACKEND_TYPE}")].evictions.first()'
+              master_item:
+                key: 'pgmon[io_per_backend]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: bde8e6c28e714be58fa963a395e14619
+              name: 'I/O Extends by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend[extends,{#BACKEND_TYPE}]'
+              delay: '0'
+              units: B
+              preprocessing:
+                - type: JSONPATH
+                  parameters:
+                    - '$[?(@.backend_type == "{#BACKEND_TYPE}")].extends.first()'
+              master_item:
+                key: 'pgmon[io_per_backend]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 5ce7a815c19241a6a398e17539cca1d4
+              name: 'I/O fsyncs by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend[fsyncs,{#BACKEND_TYPE}]'
+              delay: '0'
+              preprocessing:
+                - type: JSONPATH
+                  parameters:
+                    - '$[?(@.backend_type == "{#BACKEND_TYPE}")].fsyncs.first()'
+              master_item:
+                key: 'pgmon[io_per_backend]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 3be8cb08b6bc42f7888d8d7877ab759f
+              name: 'I/O Hits by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend[hits,{#BACKEND_TYPE}]'
+              delay: '0'
+              preprocessing:
+                - type: JSONPATH
+                  parameters:
+                    - '$[?(@.backend_type == "{#BACKEND_TYPE}")].hits.first()'
+              master_item:
+                key: 'pgmon[io_per_backend]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: e28566682196415fb3bdad9d9a294ae9
+              name: 'I/O Reads by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend[reads,{#BACKEND_TYPE}]'
+              delay: '0'
+              units: B
+              preprocessing:
+                - type: JSONPATH
+                  parameters:
+                    - '$[?(@.backend_type == "{#BACKEND_TYPE}")].reads.first()'
+              master_item:
+                key: 'pgmon[io_per_backend]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: e5e9b21c7f7649b284a8ca5b4502cb96
+              name: 'I/O Reuses by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend[reuses,{#BACKEND_TYPE}]'
+              delay: '0'
+              preprocessing:
+                - type: JSONPATH
+                  parameters:
+                    - '$[?(@.backend_type == "{#BACKEND_TYPE}")].reuses.first()'
+              master_item:
+                key: 'pgmon[io_per_backend]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 6de5bc1a98dc4d8da23ac0a90983c8aa
+              name: 'I/O Writebacks by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend[writebacks,{#BACKEND_TYPE}]'
+              delay: '0'
+              units: B
+              preprocessing:
+                - type: JSONPATH
+                  parameters:
+                    - '$[?(@.backend_type == "{#BACKEND_TYPE}")].writebacks.first()'
+              master_item:
+                key: 'pgmon[io_per_backend]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 87d09d3891c145a898050d390ea7f16e
+              name: 'I/O Writes by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend[writes,{#BACKEND_TYPE}]'
+              delay: '0'
+              units: B
+              preprocessing:
+                - type: JSONPATH
+                  parameters:
+                    - '$[?(@.backend_type == "{#BACKEND_TYPE}")].writes.first()'
+              master_item:
+                key: 'pgmon[io_per_backend]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 1587592caf694d91ba9457cafaca7761
+              name: 'I/O Evictions by {#BACKEND_TYPE} - 1h delta'
+              type: CALCULATED
+              key: 'pgmon_io_backend_delta[evictions,1h,{#BACKEND_TYPE}]'
+              delay: 10m
+              params: 'last(//pgmon_io_backend[evictions,{#BACKEND_TYPE}]) - last(//pgmon_io_backend[evictions,{#BACKEND_TYPE}], #1:now-1h)'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 637b0601458147b5b72bc40ab22b2117
+              name: 'I/O Evictions Rate by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend_delta[evictions,{#BACKEND_TYPE}]'
+              delay: '0'
+              value_type: FLOAT
+              preprocessing:
+                - type: CHANGE_PER_SECOND
+                  parameters:
+                    - ''
+              master_item:
+                key: 'pgmon_io_backend[evictions,{#BACKEND_TYPE}]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: c7ed8e1bcb0945ffa2a36b06ea5fe0c5
+              name: 'I/O Extends by {#BACKEND_TYPE} - 1h delta'
+              type: CALCULATED
+              key: 'pgmon_io_backend_delta[extends,1h,{#BACKEND_TYPE}]'
+              delay: 10m
+              units: B/h
+              params: 'last(//pgmon_io_backend[extends,{#BACKEND_TYPE}]) - last(//pgmon_io_backend[extends,{#BACKEND_TYPE}], #1:now-1h)'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 855cbbc83d884b00a6fea457f8e09806
+              name: 'I/O Extends Rate by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend_delta[extends,{#BACKEND_TYPE}]'
+              delay: '0'
+              value_type: FLOAT
+              units: Bps
+              preprocessing:
+                - type: CHANGE_PER_SECOND
+                  parameters:
+                    - ''
+              master_item:
+                key: 'pgmon_io_backend[extends,{#BACKEND_TYPE}]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 20c6135bb6c8491b9ca68fa506232b04
+              name: 'I/O fsyncs by {#BACKEND_TYPE} - 1h delta'
+              type: CALCULATED
+              key: 'pgmon_io_backend_delta[fsyncs,1h,{#BACKEND_TYPE}]'
+              delay: 10m
+              params: 'last(//pgmon_io_backend[fsyncs,{#BACKEND_TYPE}]) - last(//pgmon_io_backend[fsyncs,{#BACKEND_TYPE}], #1:now-1h)'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 7391c372d1704f21b314379c2fe5bb64
+              name: 'I/O fsyncs Rate by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend_delta[fsyncs,{#BACKEND_TYPE}]'
+              delay: '0'
+              value_type: FLOAT
+              preprocessing:
+                - type: CHANGE_PER_SECOND
+                  parameters:
+                    - ''
+              master_item:
+                key: 'pgmon_io_backend[fsyncs,{#BACKEND_TYPE}]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: ab8d0766bbf64db3bb09f9442d268a83
+              name: 'I/O Hits by {#BACKEND_TYPE} - 1h delta'
+              type: CALCULATED
+              key: 'pgmon_io_backend_delta[hits,1h,{#BACKEND_TYPE}]'
+              delay: 10m
+              params: 'last(//pgmon_io_backend[hits,{#BACKEND_TYPE}]) - last(//pgmon_io_backend[hits,{#BACKEND_TYPE}], #1:now-1h)'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: be9aa056b9364c12a8809d5dd3af8387
+              name: 'I/O Hits Rate by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend_delta[hits,{#BACKEND_TYPE}]'
+              delay: '0'
+              value_type: FLOAT
+              preprocessing:
+                - type: CHANGE_PER_SECOND
+                  parameters:
+                    - ''
+              master_item:
+                key: 'pgmon_io_backend[hits,{#BACKEND_TYPE}]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 0c42a40a263948dda4464856747ac6ef
+              name: 'I/O Reads by {#BACKEND_TYPE} - 1h delta'
+              type: CALCULATED
+              key: 'pgmon_io_backend_delta[reads,1h,{#BACKEND_TYPE}]'
+              delay: 10m
+              units: B/h
+              params: 'last(//pgmon_io_backend[reads,{#BACKEND_TYPE}]) - last(//pgmon_io_backend[reads,{#BACKEND_TYPE}], #1:now-1h)'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 01bc131aaec448e6aafb7ef13d1ea5ed
+              name: 'I/O Reads Rate by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend_delta[reads,{#BACKEND_TYPE}]'
+              delay: '0'
+              value_type: FLOAT
+              units: Bps
+              preprocessing:
+                - type: CHANGE_PER_SECOND
+                  parameters:
+                    - ''
+              master_item:
+                key: 'pgmon_io_backend[reads,{#BACKEND_TYPE}]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 740d5c84be6e4b99b4ca3513b6c6c5ea
+              name: 'I/O Reuses by {#BACKEND_TYPE} - 1h delta'
+              type: CALCULATED
+              key: 'pgmon_io_backend_delta[reuses,1h,{#BACKEND_TYPE}]'
+              delay: 10m
+              params: 'last(//pgmon_io_backend[reuses,{#BACKEND_TYPE}]) - last(//pgmon_io_backend[reuses,{#BACKEND_TYPE}], #1:now-1h)'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 8cbc16fc472a44d5945498285e8407be
+              name: 'I/O Reuses Rate by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend_delta[reuses,{#BACKEND_TYPE}]'
+              delay: '0'
+              value_type: FLOAT
+              preprocessing:
+                - type: CHANGE_PER_SECOND
+                  parameters:
+                    - ''
+              master_item:
+                key: 'pgmon_io_backend[reuses,{#BACKEND_TYPE}]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 2e796f4c75a94967a0b11a37a2d64726
+              name: 'I/O Writebacks by {#BACKEND_TYPE} - 1h delta'
+              type: CALCULATED
+              key: 'pgmon_io_backend_delta[writebacks,1h,{#BACKEND_TYPE}]'
+              delay: 10m
+              units: B/h
+              params: 'last(//pgmon_io_backend[writebacks,{#BACKEND_TYPE}]) - last(//pgmon_io_backend[writebacks,{#BACKEND_TYPE}], #1:now-1h)'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 52d2536db79047948893ccb764b2a220
+              name: 'I/O Writebacks Rate by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend_delta[writebacks,{#BACKEND_TYPE}]'
+              delay: '0'
+              value_type: FLOAT
+              units: Bps
+              preprocessing:
+                - type: CHANGE_PER_SECOND
+                  parameters:
+                    - ''
+              master_item:
+                key: 'pgmon_io_backend[writebacks,{#BACKEND_TYPE}]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 6a741d3b857b48eea0e1a4d1deea7183
+              name: 'I/O Writes by {#BACKEND_TYPE} - 1h delta'
+              type: CALCULATED
+              key: 'pgmon_io_backend_delta[writes,1h,{#BACKEND_TYPE}]'
+              delay: 10m
+              units: B/h
+              params: 'last(//pgmon_io_backend[writes,{#BACKEND_TYPE}]) - last(//pgmon_io_backend[writes,{#BACKEND_TYPE}], #1:now-1h)'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+            - uuid: 6d10339b08b84a91a931a64050a471cc
+              name: 'I/O Writes Rate by {#BACKEND_TYPE}'
+              type: DEPENDENT
+              key: 'pgmon_io_backend_delta[writes,{#BACKEND_TYPE}]'
+              delay: '0'
+              value_type: FLOAT
+              units: Bps
+              preprocessing:
+                - type: CHANGE_PER_SECOND
+                  parameters:
+                    - ''
+              master_item:
+                key: 'pgmon_io_backend[writes,{#BACKEND_TYPE}]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: 'Backend Type'
+                  value: '{#BACKEND_TYPE}'
+                - tag: Component
+                  value: IO
+          graph_prototypes:
+            - uuid: faf1e3f41dd84adba42c414f6efac152
+              name: 'Backend I/O for {#BACKEND_TYPE}'
+              graph_items:
+                - color: 199C0D
+                  yaxisside: RIGHT
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend[evictions,{#BACKEND_TYPE}]'
+                - sortorder: '1'
+                  color: F63100
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend[extends,{#BACKEND_TYPE}]'
+                - sortorder: '2'
+                  color: 2774A4
+                  yaxisside: RIGHT
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend[fsyncs,{#BACKEND_TYPE}]'
+                - sortorder: '3'
+                  color: F7941D
+                  yaxisside: RIGHT
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend[hits,{#BACKEND_TYPE}]'
+                - sortorder: '4'
+                  color: FC6EA3
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend[reads,{#BACKEND_TYPE}]'
+                - sortorder: '5'
+                  color: 6C59DC
+                  yaxisside: RIGHT
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend[reuses,{#BACKEND_TYPE}]'
+                - sortorder: '6'
+                  color: C7A72D
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend[writebacks,{#BACKEND_TYPE}]'
+                - sortorder: '7'
+                  color: BA2A5D
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend[writes,{#BACKEND_TYPE}]'
+            - uuid: 24e2e3ec67cd43058c8b6a02d686fc6a
+              name: 'Backend I/O for {#BACKEND_TYPE} - 1h delta'
+              graph_items:
+                - color: 199C0D
+                  yaxisside: RIGHT
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[evictions,1h,{#BACKEND_TYPE}]'
+                - sortorder: '1'
+                  color: F63100
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[extends,1h,{#BACKEND_TYPE}]'
+                - sortorder: '2'
+                  color: 2774A4
+                  yaxisside: RIGHT
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[fsyncs,1h,{#BACKEND_TYPE}]'
+                - sortorder: '3'
+                  color: F7941D
+                  yaxisside: RIGHT
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[hits,1h,{#BACKEND_TYPE}]'
+                - sortorder: '4'
+                  color: FC6EA3
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[reads,1h,{#BACKEND_TYPE}]'
+                - sortorder: '5'
+                  color: 6C59DC
+                  yaxisside: RIGHT
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[reuses,1h,{#BACKEND_TYPE}]'
+                - sortorder: '6'
+                  color: C7A72D
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[writebacks,1h,{#BACKEND_TYPE}]'
+                - sortorder: '7'
+                  color: BA2A5D
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[writes,1h,{#BACKEND_TYPE}]'
+            - uuid: 815f1a00c19d45a18b10846644710668
+              name: 'Backend I/O Rates for {#BACKEND_TYPE}'
+              graph_items:
+                - color: 199C0D
+                  yaxisside: RIGHT
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[evictions,{#BACKEND_TYPE}]'
+                - sortorder: '1'
+                  color: F63100
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[extends,{#BACKEND_TYPE}]'
+                - sortorder: '2'
+                  color: 2774A4
+                  yaxisside: RIGHT
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[fsyncs,{#BACKEND_TYPE}]'
+                - sortorder: '3'
+                  color: F7941D
+                  yaxisside: RIGHT
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[hits,{#BACKEND_TYPE}]'
+                - sortorder: '4'
+                  color: FC6EA3
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[reads,{#BACKEND_TYPE}]'
+                - sortorder: '5'
+                  color: 6C59DC
+                  yaxisside: RIGHT
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[reuses,{#BACKEND_TYPE}]'
+                - sortorder: '6'
+                  color: C7A72D
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[writebacks,{#BACKEND_TYPE}]'
+                - sortorder: '7'
+                  color: BA2A5D
+                  calc_fnc: ALL
+                  item:
+                    host: 'PostgreSQL by pgmon'
+                    key: 'pgmon_io_backend_delta[writes,{#BACKEND_TYPE}]'
+          master_item:
+            key: 'pgmon[io_per_backend]'
+          lld_macro_paths:
+            - lld_macro: '{#BACKEND_TYPE}'
+              path: $.backend_type
+          preprocessing:
+            - type: JSONPATH
+              parameters:
+                - '$[:]'
         - uuid: 8ec029d577ae4872858e2e5cfd1cc40e
           name: 'Discover Replication'
           type: HTTP_AGENT
@@ -949,6 +1690,8 @@ zabbix_export:
                   value: Replication
                 - tag: Database
                   value: '{#DBNAME}'
+                - tag: Type
+                  value: Raw
           url: 'http://localhost:{$AGENT_PORT}/discover_rep'
           lld_macro_paths:
             - lld_macro: '{#CLIENT_ADDR}'
@@ -963,6 +1706,40 @@ zabbix_export:
           key: pgmon_discover_slots
           delay: 10m
           item_prototypes:
+            - uuid: 536c5f82e3074ddfbfd842b3a2e8d46c
+              name: 'Slot {#SLOT_NAME} - Confirmed Flushed Bytes Lag'
+              type: DEPENDENT
+              key: 'pgmon_slot[confirmed_flush_bytes,{#SLOT_NAME}]'
+              delay: '0'
+              description: 'The lag in bytes for the slot.  This metric is how far behind the consumer has reported to be with regard to flushing writes to disk (or equivalent).'
+              preprocessing:
+                - type: JSONPATH
+                  parameters:
+                    - $.confirmed_flush_bytes
+              master_item:
+                key: 'pgmon_slot_stats[{#SLOT_NAME}]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: Slot
+                  value: '{#SLOT_NAME}'
+            - uuid: f239449d8e9e4ce79965528400f1669a
+              name: 'Slot {#SLOT_NAME} - Restart Bytes Lag'
+              type: DEPENDENT
+              key: 'pgmon_slot[restart_bytes,{#SLOT_NAME}]'
+              delay: '0'
+              description: 'The lag in bytes for the slot.  This metric is how far behind the restart location is, as reported by the consumer.'
+              preprocessing:
+                - type: JSONPATH
+                  parameters:
+                    - $.restart_bytes
+              master_item:
+                key: 'pgmon_slot_stats[{#SLOT_NAME}]'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: Slot
+                  value: '{#SLOT_NAME}'
             - uuid: a9f53efdce0a4bdc970925f8588e01c5
               name: 'Replication Slot Stats for {#SLOT_NAME}'
               type: HTTP_AGENT
@@ -974,6 +1751,13 @@ zabbix_export:
               query_fields:
                 - name: slot
                   value: '{#SLOT_NAME}'
+              tags:
+                - tag: Application
+                  value: PostgreSQL
+                - tag: Slot
+                  value: '{#SLOT_NAME}'
+                - tag: Type
+                  value: Raw
           url: 'http://localhost:{$AGENT_PORT}/discover_slots'
           lld_macro_paths:
             - lld_macro: '{#ACTIVE}'