pg-converter 2.0b0__py3-none-any.whl

pg_converter/__init__.py

@@ -0,0 +1,21 @@
+"""
+PG Converter - PostgreSQL Migration Tool.
+
+An async migration deployment tool for PostgreSQL databases.
+Supports SQL and Python steps, generators, and action tracking.
+"""
+
+from pg_converter.core.constants import VERSION
+
+__version__ = VERSION
+__author__ = "O2eg"
+
+from pg_converter.runner import PGConverter, main, run
+
+__all__ = [
+    "PGConverter",
+    "main",
+    "run",
+    "VERSION",
+    "__version__",
+]

pg_converter/__main__.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+# __main__.py
+"""
+PG Converter entry point.
+
+Allows running as:
+    python -m pg_converter
+    python -m pg_converter --packet-name mypacket --db-name mydb
+"""
+
+from pg_converter.runner import run
+
+if __name__ == "__main__":
+    run()

pg_converter/api.py

@@ -0,0 +1,114 @@
+"""Programmatic async API shared by the CLI and a future UI."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from argparse import Namespace
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, Mapping, Optional
+
+from pg_converter.core.context import PGCResult
+from pg_converter.core.events import ConfirmationHandler, EventHandler
+
+
+@dataclass(frozen=True)
+class RunRequest:
+    """UI-neutral request for one packet operation."""
+
+    packet_name: str
+    db_name: str = "ALL"
+    operation: str = "run"
+    force: bool = False
+    skip_step_cancel: bool = False
+    skip_action_cancel: bool = False
+    sequential: bool = False
+    template: Optional[str] = None
+    placeholders: Mapping[str, Any] = field(default_factory=dict)
+    config_overrides: Mapping[str, Any] = field(default_factory=dict)
+
+    def to_namespace(self, config_file: Optional[Path] = None) -> Namespace:
+        operations = {"run", "status", "wipe", "stop", "unlock", "list"}
+        if self.operation not in operations:
+            raise ValueError(
+                "Unsupported operation "
+                f"{self.operation!r}; expected one of: " + ", ".join(sorted(operations))
+            )
+        return Namespace(
+            packet_name=self.packet_name,
+            db_name=self.db_name,
+            status=self.operation == "status",
+            wipe=self.operation == "wipe",
+            stop=self.operation == "stop",
+            unlock=self.operation == "unlock",
+            list=self.operation == "list",
+            force=self.force,
+            skip_step_cancel=self.skip_step_cancel,
+            skip_action_cancel=self.skip_action_cancel,
+            seq=self.sequential,
+            template=self.template,
+            placeholders=json.dumps(dict(self.placeholders)),
+            conf=json.dumps(dict(self.config_overrides)),
+            config_file=str(config_file) if config_file else None,
+        )
+
+
+class PGConverterService:
+    """Reusable service facade with no dependency on argparse or stdout."""
+
+    def __init__(self, config_file: Optional[Path] = None):
+        self.config_file = config_file
+
+    def start(
+        self,
+        request: RunRequest,
+        event_handler: Optional[EventHandler] = None,
+        confirmation_handler: Optional[ConfirmationHandler] = None,
+    ) -> "RunHandle":
+        """Start a cancellable operation without exposing argparse."""
+        # Local import avoids making the packet runner depend on this facade.
+        from pg_converter.runner import PGConverter
+
+        converter = PGConverter(
+            request.to_namespace(self.config_file),
+            event_handler=event_handler,
+            confirmation_handler=confirmation_handler,
+        )
+        return RunHandle(converter)
+
+    async def execute(
+        self,
+        request: RunRequest,
+        event_handler: Optional[EventHandler] = None,
+        confirmation_handler: Optional[ConfirmationHandler] = None,
+    ) -> PGCResult:
+        handle = self.start(
+            request,
+            event_handler=event_handler,
+            confirmation_handler=confirmation_handler,
+        )
+        return await handle.wait()
+
+
+class RunHandle:
+    """UI-neutral handle for progress consumers and graceful cancellation."""
+
+    def __init__(self, converter: Any):
+        self._converter = converter
+        self._task: asyncio.Task[PGCResult] = asyncio.create_task(converter.run())
+
+    @property
+    def done(self) -> bool:
+        return self._task.done()
+
+    async def wait(self) -> PGCResult:
+        """Wait for the complete terminal result."""
+        return await self._task
+
+    async def cancel(self) -> Dict[str, Dict[int, bool]]:
+        """Cancel active PostgreSQL statements and let the run finalize."""
+        return await self._converter.cancel()
+
+    def __await__(self):
+        return self.wait().__await__()

pg_converter/bundled/conf/pg_converter.conf.example

@@ -0,0 +1,54 @@
+[databases]
+# Plain connection (pq:// and postgresql:// are both supported).
+development = postgresql://user:password@localhost:5432/development
+
+# TLS with server certificate and hostname verification.
+production = postgresql://user:password@db.example.com:5432/production?sslmode=verify-full&sslrootcert=/etc/pg_converter/ca.crt
+
+# Mutual TLS with a client certificate. Percent-encode special URL characters
+# in credentials and paths when required.
+production_mtls = postgresql://user@db.example.com:5432/production?sslmode=verify-full&sslrootcert=/etc/pg_converter/ca.crt&sslcert=/etc/pg_converter/client.crt&sslkey=/etc/pg_converter/client.key
+
+# The equivalent libpq key=value form is also supported:
+# reporting = host=db.example.com port=5432 dbname=reporting user=pgc sslmode=verify-ca sslrootcert=/etc/pg_converter/ca.crt sslcert=/etc/pg_converter/client.crt sslkey=/etc/pg_converter/client.key
+
+[main]
+application_name = pg_converter
+lock_observer_sleep_interval = 5
+execute_sql = true
+conn_exception_sleep_interval = 5
+# Bounded reconnect/action retry policy. The sleep value above is the
+# initial backoff delay.
+connect_retry_attempts = 5
+action_retry_attempts = 3
+retry_max_delay = 30
+retry_multiplier = 2
+retry_jitter = 0.2
+connect_timeout = 30
+cancel_wait_tx_timeout = 3 minutes
+cancel_blocker_tx_timeout = 60 seconds
+detailed_traceback = false
+db_name_all_confirmation = true
+schema_location = pgc
+
+[log]
+log_level = INFO
+log_sql = true
+file_maxmbytes = 50
+file_backupcount = 5
+
+[mattermost_hooks]
+url = https://mattermost.example.com
+chat_keys = pgc-alert/replace-with-hook-key,pgc-dba/replace-with-hook-key
+
+[slack_hooks]
+url = https://hooks.slack.com/services
+chat_keys = pgc-alert=replace/with/hook-key
+
+[postgresql]
+deadlock_timeout = 100ms
+statement_timeout = 1h
+vacuum_cost_limit = 3000
+work_mem = 200MB
+maintenance_work_mem = 1GB
+timezone = UTC

pg_converter/bundled/packets/alert_bloat/01_step.sql

@@ -0,0 +1,117 @@
+WITH btree_index_atts AS (
+    SELECT nspname,
+        ci.relname as index_name, 
+        ci.reltuples, 
+        ci.relpages, 
+        i.indrelid, i.indexrelid,
+        ci.relam,
+        ct.relname as tablename,
+        regexp_split_to_table(indkey::text, ' ')::smallint AS attnum,
+        coalesce(substring(array_to_string(ci.reloptions, ' ') from '%fillfactor=#"__#"%' for '#')::int2, 100) as fillfactor,
+        indexrelid as index_oid,
+        (SELECT pg_get_indexdef (i.indexrelid)) as def,
+        indisunique::integer,
+        indisprimary::integer, 
+        (select pg_get_constraintdef(cn.oid)) as constraintdef, cn.oid as conoid, 
+        conname,
+        cn.contype,
+        cn.conrelid
+    FROM pg_index i
+    JOIN pg_class AS ci ON i.indexrelid = ci.oid and ci.relkind = 'i'
+    JOIN pg_class AS ct ON i.indrelid = ct.oid and ct.relkind in ('r', 'm', 't')
+    -- where relkind: r = ordinary table, i = index, S = sequence, v = view, m = materialized view,
+        -- c = composite type, t = TOAST table, f = foreign table
+    JOIN pg_namespace n ON n.oid = ci.relnamespace
+    JOIN pg_am a ON ci.relam = a.oid
+    LEFT JOIN pg_constraint cn ON cn.connamespace = n.oid and cn.conindid = i.indexrelid
+    WHERE a.amname = 'btree' and ci.relpages > 3000
+         AND nspname NOT IN ('pg_catalog', 'information_schema')
+         AND ct.reltuples > 5000
+         AND ci.relname not in ('d_last_session_site_id_ip_user_agent')
+),
+index_item_sizes AS (
+    SELECT
+        ind_atts.nspname, ind_atts.index_name,
+        ind_atts.reltuples, ind_atts.relpages, ind_atts.relam,
+        indrelid AS table_oid, index_oid,
+        current_setting('block_size')::numeric AS bs, fillfactor,
+        8 AS maxalign,
+        24 AS pagehdr,
+        CASE WHEN max(coalesce(pg_stats.null_frac, 0)) = 0
+            THEN 2
+            ELSE 6
+        END AS index_tuple_hdr,
+        sum((1-coalesce(pg_stats.null_frac, 0)) * coalesce(pg_stats.avg_width, 1024)) AS nulldatawidth,
+        max(def) as def, max(indisunique) as indisunique, max(indisprimary) as indisprimary,
+        max(constraintdef) as constraintdef, max(conoid) as conoid, max(conname) as conname,
+        max(contype) as contype, max(conrelid) as conrelid -- ext info
+    FROM pg_attribute
+    JOIN btree_index_atts AS ind_atts ON pg_attribute.attrelid = ind_atts.indexrelid AND pg_attribute.attnum = ind_atts.attnum
+    JOIN pg_stats ON pg_stats.schemaname = ind_atts.nspname
+          -- stats for regular index columns
+          AND (
+            (
+               pg_stats.tablename = ind_atts.tablename AND
+               pg_stats.attname = pg_catalog.pg_get_indexdef(pg_attribute.attrelid, pg_attribute.attnum, TRUE)
+            )
+          -- stats for functional indexes
+          OR   (pg_stats.tablename = ind_atts.index_name AND pg_stats.attname = pg_attribute.attname))
+    WHERE pg_attribute.attnum > 0
+    GROUP BY 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
+),
+index_aligned_est AS (
+    SELECT maxalign, bs, nspname, index_name, reltuples,
+        relpages, relam, table_oid, index_oid,
+        coalesce (
+            ceil (
+                reltuples * ( 6 
+                    + maxalign 
+                    - CASE
+                        WHEN index_tuple_hdr%maxalign = 0 THEN maxalign
+                        ELSE index_tuple_hdr%maxalign
+                      END
+                    + nulldatawidth 
+                    + maxalign 
+                    - CASE /* Add padding to the data to align on MAXALIGN */
+                        WHEN nulldatawidth::integer%maxalign = 0 THEN maxalign
+                        ELSE nulldatawidth::integer%maxalign
+                      END
+                )::numeric 
+              / ( bs - pagehdr::NUMERIC )
+              +1 )
+         , 0 )
+      as expected,
+    def, indisunique, indisprimary, constraintdef, conoid, conname, contype, conrelid, fillfactor
+    FROM index_item_sizes
+),
+raw_bloat AS (
+    SELECT current_database() as dbname, nspname, pg_class.relname AS table_name, index_name,
+        bs*(index_aligned_est.relpages)::bigint AS totalbytes, expected,
+        CASE
+            WHEN index_aligned_est.relpages <= expected 
+                THEN 0
+                ELSE bs*(index_aligned_est.relpages-expected)::bigint 
+            END AS wastedbytes,
+        CASE
+            WHEN index_aligned_est.relpages <= expected
+                THEN 0 
+                ELSE bs*(index_aligned_est.relpages-expected)::bigint * 100 / (bs*(index_aligned_est.relpages)::bigint) 
+            END AS realbloat,
+        pg_relation_size(index_aligned_est.table_oid) as table_bytes,
+        stat.idx_scan as index_scans,
+        def, indisunique, indisprimary, constraintdef, conoid, conname, contype, conrelid, fillfactor  -- ext info
+    FROM index_aligned_est
+    JOIN pg_class ON pg_class.oid=index_aligned_est.table_oid
+    JOIN pg_stat_user_indexes AS stat ON index_aligned_est.index_oid = stat.indexrelid
+)
+SELECT
+    nspname as schema_name, table_name, index_name,
+    round(realbloat::numeric, 2) as bloat_pct,
+    pg_size_pretty(wastedbytes::NUMERIC) as bloat_size,
+    pg_size_pretty(totalbytes::NUMERIC) as index_size,
+    pg_size_pretty(table_bytes::NUMERIC) as table_size,
+    fillfactor
+FROM raw_bloat
+WHERE (round(realbloat::numeric, 2) >= 80 and wastedbytes/(1024^2)::NUMERIC > 5)
+ORDER BY wastedbytes DESC nulls last
+LIMIT 10;

pg_converter/bundled/packets/alert_bloat/02_step.sql

@@ -0,0 +1,73 @@
+with step1 as (
+	select
+		tbl.oid tblid,
+		ns.nspname as schema_name,
+		tbl.relname as table_name,
+		tbl.reltuples,
+		tbl.relpages as heappages,
+		coalesce(toast.relpages, 0) as toastpages,
+		coalesce(toast.reltuples, 0) as toasttuples,
+		coalesce(substring(array_to_string(tbl.reloptions, ' ') from '%fillfactor=#"__#"%' for '#')::int2, 100) as fillfactor,
+		current_setting('block_size')::numeric as bs,
+		case when version() ~ 'mingw32|64-bit|x86_64|ppc64|ia64|amd64' then 8 else 4 end as ma, -- NS: TODO: check it
+		24 as page_hdr,
+		23 + case when max(coalesce(null_frac, 0)) > 0 then (7 + count(*)) / 8 else 0::int end as tpl_hdr_size,
+		sum((1 - coalesce(s.null_frac, 0)) * coalesce(s.avg_width, 1024)) as tpl_data_size,
+		bool_or(att.atttypid = 'pg_catalog.name'::regtype) or count(att.attname) <> count(s.attname) as is_na
+	from pg_attribute as att
+	join pg_class as tbl on att.attrelid = tbl.oid and tbl.relkind = 'r'
+	join pg_namespace as ns on ns.oid = tbl.relnamespace
+	join pg_stats as s on s.schemaname = ns.nspname and s.tablename = tbl.relname and not s.inherited and s.attname = att.attname
+	left join pg_class as toast on tbl.reltoastrelid = toast.oid
+	where att.attnum > 0 and not att.attisdropped and s.schemaname not in ('pg_catalog', 'information_schema') and tbl.relpages > 2000
+	group by 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
+	order by 2, 3
+), step2 as (
+	select
+		*,
+		(
+			4 + tpl_hdr_size + tpl_data_size + (2 * ma)
+			- case when tpl_hdr_size % ma = 0 then ma else tpl_hdr_size % ma end
+			- case when ceil(tpl_data_size)::int % ma = 0 then ma else ceil(tpl_data_size)::int % ma end
+		) as tpl_size,
+		bs - page_hdr as size_per_block,
+		(heappages + toastpages) as tblpages
+	from step1
+), step3 as (
+	select
+		*,
+		ceil(reltuples / ((bs - page_hdr) / tpl_size)) + ceil(toasttuples / 4) as est_tblpages,
+		ceil(reltuples / ((bs - page_hdr) * fillfactor / (tpl_size * 100))) + ceil(toasttuples / 4) as est_tblpages_ff
+		-- , stattuple.pgstattuple(tblid) as pst
+	from step2
+), step4 as (
+	select
+		*,
+		tblpages * bs as real_size,
+		(tblpages - est_tblpages) * bs as extra_size,
+		case when tblpages - est_tblpages > 0 then 100 * (tblpages - est_tblpages) / tblpages::float else 0 end as extra_ratio,
+		(tblpages - est_tblpages_ff) * bs as bloat_size,
+		case when tblpages - est_tblpages_ff > 0 then 100 * (tblpages - est_tblpages_ff) / tblpages::float else 0 end as bloat_ratio
+	from step3
+)
+select
+	step4.schema_name,
+	step4.table_name,
+	round(bloat_ratio::numeric, 2) as bloat_pct,
+	pg_size_pretty(bloat_size::numeric)::text as bloat_size,
+	pg_size_pretty(real_size::numeric) as table_size,
+	case
+	  when (real_size - bloat_size)::numeric >=0
+		then '~' || pg_size_pretty((real_size - bloat_size)::numeric)
+		else null
+	end as "live",
+	(
+	  select
+		coalesce(substring(array_to_string(reloptions, ' ') from 'fillfactor=([0-9]+)')::smallint, 100)
+	  from pg_class
+	  where oid = tblid
+	) as "fillfactor"
+from step4
+where bloat_ratio >= 80 and bloat_size > 1024 * 1000 * 10
+order by bloat_size desc nulls last
+limit 10;

pg_converter/bundled/packets/alert_bloat/meta_data.json

@@ -0,0 +1,13 @@
+{
+	"responsible": "Oleg Gurov",
+	"description": "check index/heap bloat",
+	"type": "read_only",
+	"client_min_messages": "INFO",
+	"hook": {
+		"type": "mattermost",
+		"username": "pg_converter",
+		"verbosity": ["resultset"],
+		"channel": "pgc-alert",
+		"message": ":warning: @here Found extra bloat:"
+	}
+}

pg_converter/bundled/packets/alert_check_autovacuum/01_step.sql

@@ -0,0 +1,18 @@
+------------------
+-- tx start
+do $$ 
+begin
+	if exists(select 1
+		from pg_class
+		where '{autovacuum_enabled=false}'::text[] @> reloptions and relkind = 'r')
+	then
+			raise exception 'autovacuum_enabled=false on some tables! %', (
+				select array_agg(quote_ident(n.nspname) || '.' || quote_ident(c.relname))::text
+				from pg_class c
+				join pg_namespace n on n.oid = c.relnamespace
+				where '{autovacuum_enabled=false}'::text[] @> reloptions and relkind = 'r'
+			);																				   
+	end if;
+end$$;
+-- tx end
+------------------

pg_converter/bundled/packets/alert_check_autovacuum/meta_data.json

@@ -0,0 +1,10 @@
+{
+	"type": "read_only",
+	"hook": {
+		"type": "mattermost",
+		"username": "pg_converter",
+		"channel": "pgc-alert",
+		"message": ":warning: @here Found tables with disabled autovacuum! Use `ALTER TABLE tbl SET (autovacuum_enabled = true);`",
+		"verbosity": "raise"
+	}
+}

pg_converter/bundled/packets/alert_int4_capacity/01_gen_obj.sql

@@ -0,0 +1,22 @@
+    select
+	  '' as maint,
+      -- c.oid,
+      -- (select spcname from pg_tablespace where oid = reltablespace) as tblspace,
+      nspname as schema_name,
+      relname as table_name,
+      t.typname,
+      attname,
+      (select pg_get_serial_sequence(quote_ident(nspname) || '.' || quote_ident(relname), attname)) as seq
+    from pg_index i
+    join pg_class c on c.oid = i.indrelid
+    join pg_namespace n on n.oid = c.relnamespace
+    join pg_attribute a on
+      a.attrelid = i.indrelid
+      and a.attnum = any(i.indkey)
+    join pg_type t on t.oid = atttypid
+    where
+      i.indisprimary
+	  -- 8192 * 10000 = 81,92MB
+	  and c.relpages > 10000
+      and t.typname in ('int2', 'int4')
+      and nspname <> 'pg_toast'

pg_converter/bundled/packets/alert_int4_capacity/01_step.sql

@@ -0,0 +1,32 @@
+do $$
+declare
+  val bigint;
+  ratio numeric;
+begin
+      -- schema_name	- GEN_OBJ_FLD_1
+      -- table_name		- GEN_OBJ_FLD_2
+      -- typname		- GEN_OBJ_FLD_3
+      -- attname		- GEN_OBJ_FLD_4
+      -- seq			- GEN_OBJ_FLD_5
+
+    if 'GEN_OBJ_FLD_5' = 'None' then
+        execute format('select max(%I) from %I.%I;', 'GEN_OBJ_FLD_4', 'GEN_OBJ_FLD_1', 'GEN_OBJ_FLD_2') into val;
+    else
+        execute format('SELECT last_value FROM %s', 'GEN_OBJ_FLD_5') into val;
+    end if;
+    if 'GEN_OBJ_FLD_3' = 'int4' then
+      ratio := (val::numeric / 2^31)::numeric;
+    elsif 'GEN_OBJ_FLD_3' = 'int2' then
+      ratio := (val::numeric / 2^15)::numeric;
+    end if;
+    if ratio > 0.7 then -- report only if > 50% of capacity is reached
+		raise notice '%', format('tbl = %s pk = %s type = %s current_value = %s capacity = %s',
+			coalesce(nullif(quote_ident('GEN_OBJ_FLD_1'), 'public') || '.', '') || quote_ident('GEN_OBJ_FLD_2'),
+			'GEN_OBJ_FLD_4',
+			'GEN_OBJ_FLD_3',
+			val,
+			round(100 * ratio, 2)
+		);
+    end if;
+end;
+$$

pg_converter/bundled/packets/alert_int4_capacity/meta_data.json

@@ -0,0 +1,14 @@
+{
+	"type": "read_only",
+	"client_min_messages": "NOTICE",
+	"hook": {
+		"type": "mattermost",
+		"username": "pg_converter",
+		"verbosity": ["raise"],
+		"channel": "pgc-alert",
+		"message": ":warning: @here Found tables with low int4 capacity:"
+	},
+	"postgresql": {
+		"statement_timeout": "180s"
+	}
+}

pg_converter/bundled/packets/alert_invalid_indexes/01_step.sql

@@ -0,0 +1,8 @@
+select n.nspname, c.relname as tbl, ci.relname as idx, indisvalid, indisready
+from pg_index i
+join pg_class c on i.indrelid = c.oid and c.relkind in ('r', 'm')
+join pg_class ci on i.indexrelid = ci.oid and ci.relkind = 'i'
+join pg_namespace n on n.oid = c.relnamespace
+where indisvalid = false or indisready = false
+order by c.relpages desc
+limit 100

pg_converter/bundled/packets/alert_invalid_indexes/meta_data.json

@@ -0,0 +1,12 @@
+{
+	"responsible": "Oleg Gurov",
+	"type": "read_only",
+	"client_min_messages": "INFO",
+	"hook": {
+		"type": "mattermost",
+		"username": "pg_converter",
+		"verbosity": ["resultset"],
+		"channel": "pgc-alert",
+		"message": ":warning: @here List of `invalid` and `not ready` indexes:"
+	}
+}

pg_converter/bundled/packets/alert_max_connections/01_step.sql

@@ -0,0 +1,9 @@
+SELECT format('Low number of free connections: %s (%s) [max_connections = %s]', T.c, T.v || '%', T.s) as alert
+FROM (
+	SELECT
+		round(((select count(1) from pg_stat_activity) * 100)::numeric / setting::integer, 2) as v,
+		setting::integer - (select count(1) from pg_stat_activity) as c,
+		setting as s
+	FROM pg_settings
+	WHERE name = 'max_connections'
+) T WHERE T.v > 70

pg_converter/bundled/packets/alert_max_connections/meta_data.json

@@ -0,0 +1,13 @@
+{
+	"responsible": "Oleg Gurov",
+	"description": "Check available connections",
+	"type": "read_only",
+	"client_min_messages": "INFO",
+	"hook": {
+		"type": "mattermost",
+		"username": "pg_converter",
+		"verbosity": ["resultset"],
+		"channel": "pgc-alert",
+		"message": ":warning: @here Found problem with max_connections:"
+	}
+}

pg_converter/bundled/packets/alert_stat/01_step.sql

@@ -0,0 +1,34 @@
+select n.nspname,
+	c.relname,
+	c.reltuples::bigint,
+	st.last_autoanalyze,
+	st.last_autovacuum,
+	st.last_analyze,
+	st.last_vacuum
+from pg_class c
+join pg_namespace n on c.relnamespace = n.oid
+left join pg_stat_all_tables st on st.relid = c.oid
+where c.reltuples > 1000 and c.relkind in ('r', 'm') and not(n.nspname = 'pg_catalog' and c.relname = 'pg_shdepend') and
+(
+	(st.last_autoanalyze is null and st.last_autovacuum is null and st.last_analyze is null and st.last_vacuum is null)     -- attention!
+	OR
+	(
+		n.nspname not in('pg_toast', 'pg_catalog')
+		AND
+		LEAST(
+			age(now(), coalesce(st.last_autoanalyze, '2000-01-01'::timestamp with time zone)),
+			age(now(), coalesce(st.last_analyze, '2000-01-01'::timestamp with time zone))
+		) > '15 days'
+		AND
+		LEAST(
+			age(now(), coalesce(st.last_autovacuum, '2000-01-01'::timestamp with time zone)),
+			age(now(), coalesce(st.last_vacuum, '2000-01-01'::timestamp with time zone))
+		) > '15 days'
+	)
+)
+order by
+	st.last_autoanalyze asc nulls first,
+	st.last_autovacuum asc nulls first,
+	st.last_analyze asc nulls first,
+	st.last_vacuum asc nulls first
+limit 10;

pg_converter/bundled/packets/alert_stat/meta_data.json

@@ -0,0 +1,13 @@
+{
+	"responsible": "Oleg Gurov",
+	"description": "check outdated statistics",
+	"type": "read_only",
+	"client_min_messages": "INFO",
+	"hook": {
+		"type": "mattermost",
+		"username": "pg_converter",
+		"verbosity": ["resultset"],
+		"channel": "pgc-alert",
+		"message": ":warning: @here Found outdated statistics:"
+	}
+}

pg_converter/bundled/packets/alert_xact_age/01_step.sql

@@ -0,0 +1,11 @@
+SELECT
+    n.nspname,
+    c.relname,
+    age(c.relfrozenxid) as relfrozenxid_age,
+    mxid_age(c.relminmxid) as relminmxid_age
+FROM pg_class c
+JOIN pg_namespace n on c.relnamespace = n.oid
+WHERE c.relkind IN ('r', 'm', 't') and
+	(age(c.relfrozenxid) > 1300000000 or mxid_age(c.relminmxid) > 1400000000)
+ORDER BY age(c.relfrozenxid) desc
+LIMIT 10;

pg_converter/bundled/packets/alert_xact_age/02_step.sql

@@ -0,0 +1,7 @@
+SELECT
+	datname,
+	age(datfrozenxid) as datfrozenxid_age,
+	mxid_age(datminmxid) as datminmxid_age
+FROM pg_database
+WHERE (age(datfrozenxid) > 1300000000 or mxid_age(datminmxid) > 1400000000)
+ORDER BY age(datfrozenxid) DESC;

pg_converter/bundled/packets/alert_xact_age/meta_data.json

@@ -0,0 +1,13 @@
+{
+	"responsible": "Oleg Gurov",
+	"description": "Check xact age of relations and databases",
+	"type": "read_only",
+	"client_min_messages": "INFO",
+	"hook": {
+		"type": "mattermost",
+		"username": "pg_converter",
+		"verbosity": ["resultset"],
+		"channel": "pgc-alert",
+		"message": ":warning: @here Found problems with frozenxid:"
+	}
+}