diff --git a/contrib/Makefile b/contrib/Makefile index da4e231..9144cb7 100644 *** a/contrib/Makefile --- b/contrib/Makefile *************** SUBDIRS = \ *** 34,39 **** --- 34,40 ---- pg_buffercache \ pg_freespacemap \ pg_prewarm \ + pg_stat_logmsg \ pg_stat_statements \ pg_surgery \ pg_trgm \ diff --git a/contrib/meson.build b/contrib/meson.build index 84d4e18..4e8ac39 100644 *** a/contrib/meson.build --- b/contrib/meson.build *************** subdir('pgcrypto') *** 44,49 **** --- 44,50 ---- subdir('pg_freespacemap') subdir('pg_prewarm') subdir('pgrowlocks') + subdir('pg_stat_logmsg') subdir('pg_stat_statements') subdir('pgstattuple') subdir('pg_surgery') diff --git a/doc/src/sgml/contrib.sgml b/doc/src/sgml/contrib.sgml index ab7e38b..4dfc5dd 100644 *** a/doc/src/sgml/contrib.sgml --- b/doc/src/sgml/contrib.sgml *************** CREATE EXTENSION extension_ *** 157,162 **** --- 157,163 ---- &pgfreespacemap; &pgprewarm; &pgrowlocks; + &pgstatlogmsg; &pgstatstatements; &pgstattuple; &pgsurgery; diff --git a/doc/src/sgml/filelist.sgml b/doc/src/sgml/filelist.sgml index 4c63a7e..acede66 100644 *** a/doc/src/sgml/filelist.sgml --- b/doc/src/sgml/filelist.sgml *************** *** 145,150 **** --- 145,151 ---- + diff --git a/contrib/pg_stat_logmsg/.gitignore b/contrib/pg_stat_logmsg/.gitignore index ...5dcb3ff . *** a/contrib/pg_stat_logmsg/.gitignore --- b/contrib/pg_stat_logmsg/.gitignore *************** *** 0 **** --- 1,4 ---- + # Generated subdirectories + /log/ + /results/ + /tmp_check/ diff --git a/contrib/pg_stat_logmsg/LICENSE b/contrib/pg_stat_logmsg/LICENSE index ...998f814 . *** a/contrib/pg_stat_logmsg/LICENSE --- b/contrib/pg_stat_logmsg/LICENSE *************** *** 0 **** --- 1,4 ---- + This code is released under the PostgreSQL licence, as given at + http://www.postgresql.org/about/licence/ + + Copyright is novated to the PostgreSQL Global Development Group. diff --git a/contrib/pg_stat_logmsg/Makefile b/contrib/pg_stat_logmsg/Makefile index ...73e2f0e . *** a/contrib/pg_stat_logmsg/Makefile --- b/contrib/pg_stat_logmsg/Makefile *************** *** 0 **** --- 1,29 ---- + # contrib/pg_stat_logmsg/Makefile + + MODULE_big = pg_stat_logmsg + OBJS = \ + $(WIN32RES) \ + pg_stat_logmsg.o + + EXTENSION = pg_stat_logmsg + DATA = pg_stat_logmsg--1.0.sql + PGFILEDESC = "pg_stat_logmsg - statistics of log messages" + + LDFLAGS_SL += $(filter -lm, $(LIBS)) + + REGRESS_OPTS = --temp-config $(top_srcdir)/contrib/pg_stat_logmsg/pg_stat_logmsg.conf + REGRESS = select + # Disabled because these tests require "shared_preload_libraries=pg_stat_logmsg", + # which typical installcheck users do not have (e.g. buildfarm clients). + NO_INSTALLCHECK = 1 + + ifdef USE_PGXS + PG_CONFIG = pg_config + PGXS := $(shell $(PG_CONFIG) --pgxs) + include $(PGXS) + else + subdir = contrib/pg_stat_logmsg + top_builddir = ../.. + include $(top_builddir)/src/Makefile.global + include $(top_srcdir)/contrib/contrib-global.mk + endif diff --git a/contrib/pg_stat_logmsg/README.md b/contrib/pg_stat_logmsg/README.md index ...b16ef1f . *** a/contrib/pg_stat_logmsg/README.md --- b/contrib/pg_stat_logmsg/README.md *************** *** 0 **** --- 1,137 ---- + # PostgreSQL pg_stat_logmsg Extension Module + + ## Overview + This extension adds support to track statistics of log messages into PostgreSQL. It behaves in a very similar manner to pg_stat_stayements, except counts are aggregated by log message file, line number, and level. The SQL error code and log message format string are also provided for context. + + ## Syntax + + + + ## Configuration + * Add pg_stat_logmsg to shared_preload_libraries in postgresql.conf. + ``` + shared_preload_libraries = 'pg_stat_logmsg' + ``` + * The following custom parameters may be set: + ``` + # Sets the maximum number of messages tracked by pg_stat_logmsg. + pg_stat_logmsg.max = 5000 + + ``` + + ## Installation + + ### Requirements + + * PostgreSQL version 11 or newer + + ### Compile and Install + + Clone PostgreSQL repository: + + ```bash + $> git clone https://github.com/postgres/postgres.git + ``` + + Checkout REL_16_STABLE (for example) branch: + + ```bash + $> git checkout REL_16_STABLE + ``` + + Make PostgreSQL: + + ```bash + $> ./configure + $> make install -s + ``` + + Change to the contrib directory: + + ```bash + $> cd contrib + ``` + + Clone ```pg_stat_logmsg``` extension: + + ```bash + $> git clone https://github.com/pg-ext/pg_stat_logmsg + ``` + + Change to ```pg_stat_logmsg``` directory: + + ```bash + $> cd pg_stat_logmsg + ``` + + Build ```pg_stat_logmsg```: + + ```bash + $> make + ``` + + Install ```pg_stat_logmsg```: + + ```bash + $> make install + ``` + + #### Using PGXS + + If an instance of PostgreSQL is already installed, then PGXS can be utilized to build and install ```pg_stat_logmsg```. Ensure that PostgreSQL binaries are available via the ```$PATH``` environment variable then use the following commands. + + ```bash + $> make USE_PGXS=1 + $> make USE_PGXS=1 install + ``` + + ### Configure + + The following bash commands should configure your system to utilize pg_stat_logmsg. Replace all paths as appropriate. It may be prudent to visually inspect the files afterward to ensure the changes took place. + + ###### Initialize PostgreSQL (if needed): + + ```bash + $> initdb -D /path/to/data/directory + ``` + + ###### Create Target Database (if needed): + + ```bash + $> createdb + ``` + + ###### Install ```pg_stat_logmsg``` functions: + + Edit postgresql.conf and add ```pg_stat_logmsg``` to the shared_preload_libraries line, and change custom settings as mentioned above. + + Finally, restart PostgreSQL (method may vary): + + ``` + $> service postgresql restart + ``` + Install the extension into your database: + + ```bash + psql + CREATE EXTENSION pg_stat_logmsg; + ``` + + ###### Test basic functionality: + + Examples: + ``` + select * from pg_stat_logmsg; + + + + + ``` + + ## Notes + + ## Licensing + + Please see the [LICENSE](./LICENSE) file. + + diff --git a/contrib/pg_stat_logmsg/meson.build b/contrib/pg_stat_logmsg/meson.build index ...25fda63 . *** a/contrib/pg_stat_logmsg/meson.build --- b/contrib/pg_stat_logmsg/meson.build *************** *** 0 **** --- 1,41 ---- + # Copyright (c) 2022-2023, PostgreSQL Global Development Group + + pg_stat_logmsg_sources = files( + 'pg_stat_logmsg.c', + ) + + if host_system == 'windows' + pg_stat_logmsg_sources += rc_lib_gen.process(win32ver_rc, extra_args: [ + '--NAME', 'pg_stat_logmsg', + '--FILEDESC', 'pg_stat_logmsg - execution statistics of log messages',]) + endif + + pg_stat_logmsg = shared_module('pg_stat_logmsg', + pg_stat_logmsg_sources, + kwargs: contrib_mod_args + { + 'dependencies': contrib_mod_args['dependencies'], + }, + ) + contrib_targets += pg_stat_logmsg + + install_data( + 'pg_stat_logmsg.control', + 'pg_stat_logmsg--1.0.sql', + kwargs: contrib_data_args, + ) + + tests += { + 'name': 'pg_stat_logmsg', + 'sd': meson.current_source_dir(), + 'bd': meson.current_build_dir(), + 'regress': { + 'sql': [ + 'select', + ], + 'regress_args': ['--temp-config', files('pg_stat_logmsg.conf')], + # Disabled because these tests require + # "shared_preload_libraries=pg_stat_logmsg", which typical + # runningcheck users do not have (e.g. buildfarm clients). + 'runningcheck': false, + }, + } diff --git a/contrib/pg_stat_logmsg/pg_stat_logmsg--1.0.sql b/contrib/pg_stat_logmsg/pg_stat_logmsg--1.0.sql index ...4ccb657 . *** a/contrib/pg_stat_logmsg/pg_stat_logmsg--1.0.sql --- b/contrib/pg_stat_logmsg/pg_stat_logmsg--1.0.sql *************** *** 0 **** --- 1,49 ---- + /* contrib/pg_stat_logmsg/pg_stat_logmsg--1.0.sql */ + + -- complain if script is sourced in psql, rather than via CREATE EXTENSION + \echo Use "CREATE EXTENSION pg_stat_logmsg" to load this file. \quit + + -- Register functions. + CREATE FUNCTION pg_stat_logmsg_reset() + RETURNS void + AS 'MODULE_PATHNAME' + LANGUAGE C PARALLEL SAFE; + + CREATE FUNCTION pg_stat_logmsg( + OUT pgversion text, + OUT filename text, + OUT lineno int, + OUT elevel text, + OUT funcname text, + OUT sqlerrcode text, + OUT message text, + OUT translated_message text, + OUT count bigint + ) + RETURNS SETOF record + AS 'MODULE_PATHNAME', 'pg_stat_logmsg' + LANGUAGE C STRICT VOLATILE PARALLEL SAFE; + + -- Register a view on the function for ease of use. + CREATE VIEW pg_stat_logmsg AS + SELECT * FROM pg_stat_logmsg(); + + GRANT SELECT ON pg_stat_logmsg TO PUBLIC; + + -- Don't want this to be available to non-superusers. + REVOKE ALL ON FUNCTION pg_stat_logmsg_reset() FROM PUBLIC; + + --- Define pg_stat_logmsg_info + CREATE FUNCTION pg_stat_logmsg_info( + OUT dealloc bigint, + OUT stats_reset timestamp with time zone + ) + RETURNS record + AS 'MODULE_PATHNAME' + LANGUAGE C STRICT VOLATILE PARALLEL SAFE; + + CREATE VIEW pg_stat_logmsg_info AS + SELECT * FROM pg_stat_logmsg_info(); + + GRANT SELECT ON pg_stat_logmsg_info TO PUBLIC; + diff --git a/contrib/pg_stat_logmsg/pg_stat_logmsg.c b/contrib/pg_stat_logmsg/pg_stat_logmsg.c index ...4692527 . *** a/contrib/pg_stat_logmsg/pg_stat_logmsg.c --- b/contrib/pg_stat_logmsg/pg_stat_logmsg.c *************** *** 0 **** --- 1,1822 ---- + /*------------------------------------------------------------------------- + * + * pg_stat_logmsg.c + * Track log messages across a whole database cluster. + * + * Starting code cribbed from pg_stat_statements and modified to suit + * + * Copyright (c) 2023, PostgreSQL Global Development Group + * + * IDENTIFICATION + * contrib/pg_stat_logmsg/pg_stat_logmsg.c + * + *------------------------------------------------------------------------- + */ + #include "postgres.h" + + #include + #include + #include + + #include "access/htup_details.h" + #include "access/parallel.h" + #include "access/xact.h" + #include "catalog/pg_authid.h" + #if PG_VERSION_NUM >= 130000 + #include "common/hashfn.h" + #else + #include "utils/hashutils.h" + #endif /* PG_VERSION_NUM >= 130000 */ + #include "funcapi.h" + #include "mb/pg_wchar.h" + #include "miscadmin.h" + #include "pgstat.h" + #include "storage/fd.h" + #include "storage/ipc.h" + #include "storage/lwlock.h" + #include "storage/shmem.h" + #include "storage/spin.h" + #include "tcop/utility.h" + #include "utils/acl.h" + #include "utils/builtins.h" + #include "utils/memutils.h" + #include "utils/timestamp.h" + + PG_MODULE_MAGIC; + + /* Location of permanent stats file (valid when database is shut down) */ + #define PGLM_DUMP_FILE PGSTAT_STAT_PERMANENT_DIRECTORY "/pg_stat_logmsg.stat" + + /* + * Location of external logmsg text file. + */ + #define PGLM_TEXT_FILE PG_STAT_TMP_DIR "/pglm_logmsg_texts.stat" + + /* Magic number identifying the stats file format */ + static const uint32 PGLM_FILE_HEADER = 0x20230625; + + /* PostgreSQL major version number, changes in which invalidate all entries */ + static const uint32 PGLM_PG_MAJOR_VERSION = PG_VERSION_NUM / 100; + + #define ASSUMED_MEDIAN_INIT (10.0) /* initial assumed median usage */ + #define ASSUMED_LENGTH_INIT 1024 /* initial assumed mean query length */ + #define USAGE_DECREASE_FACTOR (0.99) /* decreased every entry_dealloc */ + #define USAGE_DEALLOC_PERCENT 5 /* free this % of entries at once */ + #define USAGE_INIT (1.0) /* including initial planning */ + #define MAXFILENAMELEN 64 + #define MAXFUNCNAMELEN 64 + + /* + * Hashtable key that defines the identity of a hashtable entry. + * + * If you add a new key to this struct, make sure to teach pglm_store() to + * zero the padding bytes. Otherwise, things will break, because pglm_hash is + * created using HASH_BLOBS, and thus tag_hash is used to hash this. + */ + typedef struct pglmHashKey + { + char filename[MAXFILENAMELEN]; /* filename */ + int lineno; /* line number */ + int elevel; /* log level */ + } pglmHashKey; + + /* + * The actual stats counters kept within pglmEntry. + */ + typedef struct Counters + { + int64 msgcnt; /* # of times planned/executed */ + double usage; /* usage factor */ + } Counters; + + /* + * Global statistics for pg_stat_logmsg + */ + typedef struct pglmGlobalStats + { + int64 dealloc; /* # of times entries were deallocated */ + TimestampTz stats_reset; /* timestamp with all stats reset */ + } pglmGlobalStats; + + /* + * Statistics per statement + * + * Note: in event of a failure in garbage collection of the logmsg text file, + * we reset logmsg_offset to zero and logmsg_len to -1. This will be seen as + * an invalid state by logmsg_fetch(). + */ + typedef struct pglmEntry + { + pglmHashKey key; /* hash key of entry - MUST BE FIRST */ + Counters counters; /* the statistics for this logmsg */ + Size logmsg_offset; /* logmsg text offset in external file */ + int logmsg_len; /* # of valid bytes in logmsg string, or -1 */ + int encoding; /* logmsg text encoding */ + int sqlerrcode; /* encoded ERRSTATE */ + char funcname[MAXFUNCNAMELEN]; /* edata function name */ + slock_t mutex; /* protects the counters only */ + } pglmEntry; + + /* + * Global shared state + */ + typedef struct pglmSharedState + { + LWLock *lock; /* protects hashtable search/modification */ + double cur_median_usage; /* current median usage in hashtable */ + Size mean_logmsg_len; /* current mean entry text length */ + slock_t mutex; /* protects following fields only: */ + Size extent; /* current extent of query file */ + int n_writers; /* number of active writers to query file */ + int gc_count; /* query file garbage collection cycle count */ + pglmGlobalStats stats; /* global statistics for pglm */ + } pglmSharedState; + + /*---- Local variables ----*/ + + /* anti recursion */ + static bool is_in_log_hook = false; + + /* Saved hook values in case of unload */ + #if PG_VERSION_NUM >= 150000 + static shmem_request_hook_type prev_shmem_request_hook = NULL; + #endif /* PG_VERSION_NUM >= 150000 */ + static shmem_startup_hook_type prev_shmem_startup_hook = NULL; + static emit_log_hook_type prev_emit_log_hook = NULL; + + /* Links to shared memory state */ + static pglmSharedState *pglm = NULL; + static HTAB *pglm_hash = NULL; + + /*---- GUC variables ----*/ + static int pglm_max = 5000; /* max # statements to track */ + + #define record_gc_msgfmts() \ + do { \ + volatile pglmSharedState *s = (volatile pglmSharedState *) pglm; \ + SpinLockAcquire(&s->mutex); \ + s->gc_count++; \ + SpinLockRelease(&s->mutex); \ + } while(0) + + /*---- Function declarations ----*/ + void _PG_init(void); + PG_FUNCTION_INFO_V1(pg_stat_logmsg_reset); + PG_FUNCTION_INFO_V1(pg_stat_logmsg); + PG_FUNCTION_INFO_V1(pg_stat_logmsg_info); + + #if PG_VERSION_NUM >= 150000 + static void pglm_shmem_request(void); + #endif /* PG_VERSION_NUM >= 150000 */ + static void pglm_shmem_startup(void); + static void pglm_shmem_shutdown(int code, Datum arg); + static void pglm_log_hook(ErrorData *edata); + static void pglm_store(ErrorData *edata); + static void pg_stat_logmsg_internal(FunctionCallInfo fcinfo); + static Size pglm_memsize(void); + static pglmEntry *entry_alloc(pglmHashKey *key, Size logmsg_offset, + int logmsg_len, int encoding, + int sqlerrcode, char *funcname); + static void entry_dealloc(void); + static bool logmsg_store(ErrorData *edata, Size *logmsg_offset, + int *logmsg_len, int *gc_count); + static char *logmsg_load_file(Size *buffer_size); + static char *logmsg_fetch(Size logmsg_offset, int logmsg_len, + char *buffer, Size buffer_size); + static bool need_gc_logmsgs(void); + static void gc_logmsgs(void); + static void entry_reset(char *filename, int lineno, int elevel); + static void logmsg_xact_callback(XactEvent event, void *arg); + #if PG_VERSION_NUM < 150000 + static void InitMaterializedSRF(FunctionCallInfo fcinfo, bits32 flags); + static const char *error_severity(int elevel); + #endif /* PG_VERSION_NUM < 150000 */ + + /* + * Module load callback + */ + void + _PG_init(void) + { + /* + * In order to create our shared memory area, we have to be loaded via + * shared_preload_libraries. If not, fall out without hooking into any of + * the main system. (We don't throw error here because it seems useful to + * allow the pg_stat_logmsg functions to be created even when the + * module isn't active. The functions must protect themselves against + * being called then, however.) + */ + if (!process_shared_preload_libraries_in_progress) + return; + + /* + * Define (or redefine) custom GUC variables. + */ + DefineCustomIntVariable("pg_stat_logmsg.max", + "Sets the maximum number of messages tracked by pg_stat_logmsg.", + NULL, + &pglm_max, + 5000, + 100, + INT_MAX / 2, + PGC_POSTMASTER, + 0, + NULL, + NULL, + NULL); + + #if PG_VERSION_NUM >= 150000 + MarkGUCPrefixReserved("pg_stat_logmsg"); + + /* + * Install hooks. + */ + prev_shmem_request_hook = shmem_request_hook; + shmem_request_hook = pglm_shmem_request; + #else + EmitWarningsOnPlaceholders("pg_stat_logmsg"); + + /* + * Request additional shared resources. (These are no-ops if we're not in + * the postmaster process.) We'll allocate or attach to the shared + * resources in pgss_shmem_startup(). + */ + RequestAddinShmemSpace(pglm_memsize()); + RequestNamedLWLockTranche("pg_stat_logmsg", 1); + + /* + * Install hooks. + */ + #endif /* PG_VERSION_NUM >= 150000 */ + + prev_shmem_startup_hook = shmem_startup_hook; + shmem_startup_hook = pglm_shmem_startup; + + prev_emit_log_hook = emit_log_hook; + emit_log_hook = pglm_log_hook; + + /* Arrange to restore state in case of ERROR */ + RegisterXactCallback(logmsg_xact_callback, NULL); + } + + #if PG_VERSION_NUM >= 150000 + /* + * shmem_request hook: request additional shared resources. We'll allocate or + * attach to the shared resources in pglm_shmem_startup(). + */ + static void + pglm_shmem_request(void) + { + if (prev_shmem_request_hook) + prev_shmem_request_hook(); + + RequestAddinShmemSpace(pglm_memsize()); + RequestNamedLWLockTranche("pg_stat_logmsg", 1); + } + #endif /* PG_VERSION_NUM >= 150000 */ + + /* + * shmem_startup hook: allocate or attach to shared memory, + * then load any pre-existing statistics from file. + * Also create and load the query-texts file, which is expected to exist + * (even if empty) while the module is enabled. + */ + static void + pglm_shmem_startup(void) + { + bool found; + HASHCTL info; + FILE *file = NULL; + FILE *lmfile = NULL; + uint32 header; + int32 num; + int32 pgver; + int32 i; + int buffer_size; + char *buffer = NULL; + + if (prev_shmem_startup_hook) + prev_shmem_startup_hook(); + + /* reset in case this is a restart within the postmaster */ + pglm = NULL; + pglm_hash = NULL; + + /* + * Create or attach to the shared memory state, including hash table + */ + LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE); + + pglm = ShmemInitStruct("pg_stat_logmsg", + sizeof(pglmSharedState), + &found); + + if (!found) + { + /* First time through ... */ + pglm->lock = &(GetNamedLWLockTranche("pg_stat_logmsg"))->lock; + pglm->cur_median_usage = ASSUMED_MEDIAN_INIT; + pglm->mean_logmsg_len = ASSUMED_LENGTH_INIT; + SpinLockInit(&pglm->mutex); + pglm->extent = 0; + pglm->n_writers = 0; + pglm->gc_count = 0; + pglm->stats.dealloc = 0; + pglm->stats.stats_reset = GetCurrentTimestamp(); + } + + info.keysize = sizeof(pglmHashKey); + info.entrysize = sizeof(pglmEntry); + pglm_hash = ShmemInitHash("pg_stat_logmsg hash", + pglm_max, pglm_max, + &info, + HASH_ELEM | HASH_BLOBS); + + LWLockRelease(AddinShmemInitLock); + + /* + * If we're in the postmaster (or a standalone backend...), set up a shmem + * exit hook to dump the statistics to disk. + */ + if (!IsUnderPostmaster) + on_shmem_exit(pglm_shmem_shutdown, (Datum) 0); + + /* + * Done if some other process already completed our initialization. + */ + if (found) + return; + + /* + * Note: we don't bother with locks here, because there should be no other + * processes running when this code is reached. + */ + + /* Unlink logmsg text file possibly left over from crash */ + unlink(PGLM_TEXT_FILE); + + /* Allocate new logmsg text temp file */ + lmfile = AllocateFile(PGLM_TEXT_FILE, PG_BINARY_W); + if (lmfile == NULL) + goto write_error; + + /* + * Attempt to load old statistics from the dump file. + */ + file = AllocateFile(PGLM_DUMP_FILE, PG_BINARY_R); + if (file == NULL) + { + if (errno != ENOENT) + goto read_error; + /* No existing persisted stats file, so we're done */ + FreeFile(lmfile); + return; + } + + buffer_size = 2048; + buffer = (char *) palloc(buffer_size); + + if (fread(&header, sizeof(uint32), 1, file) != 1 || + fread(&pgver, sizeof(uint32), 1, file) != 1 || + fread(&num, sizeof(int32), 1, file) != 1) + goto read_error; + + if (header != PGLM_FILE_HEADER || + pgver != PGLM_PG_MAJOR_VERSION) + goto data_error; + + for (i = 0; i < num; i++) + { + pglmEntry temp; + pglmEntry *entry; + Size logmsg_offset; + + if (fread(&temp, sizeof(pglmEntry), 1, file) != 1) + goto read_error; + + /* Encoding is the only field we can easily sanity-check */ + if (!PG_VALID_BE_ENCODING(temp.encoding)) + goto data_error; + + /* Resize buffer as needed */ + if (temp.logmsg_len >= buffer_size) + { + buffer_size = Max(buffer_size * 2, temp.logmsg_len + 1); + buffer = repalloc(buffer, buffer_size); + } + + if (fread(buffer, 1, temp.logmsg_len + 1, file) != temp.logmsg_len + 1) + goto read_error; + + /* Should have a trailing null, but let's make sure */ + buffer[temp.logmsg_len] = '\0'; + + /* Store the logmsg text */ + logmsg_offset = pglm->extent; + if (fwrite(buffer, 1, temp.logmsg_len + 1, lmfile) != temp.logmsg_len + 1) + goto write_error; + pglm->extent += temp.logmsg_len + 1; + + /* make the hashtable entry (discards old entries if too many) */ + entry = entry_alloc(&temp.key, logmsg_offset, temp.logmsg_len, + temp.encoding, temp.sqlerrcode, temp.funcname); + + /* copy in the actual stats */ + entry->counters = temp.counters; + } + + /* Read global statistics for pg_stat_logmsg */ + if (fread(&pglm->stats, sizeof(pglmGlobalStats), 1, file) != 1) + goto read_error; + + pfree(buffer); + FreeFile(file); + FreeFile(lmfile); + + /* + * Remove the persisted stats file so it's not included in + * backups/replication standbys, etc. A new file will be written on next + * shutdown. + * + * Note: it's okay if the PGLM_TEXT_FILE is included in a basebackup, + * because we remove that file on startup; it acts inversely to + * PGLM_DUMP_FILE, in that it is only supposed to be around when the + * server is running, whereas PGLM_DUMP_FILE is only supposed to be around + * when the server is not running. Leaving the file creates no danger of + * a newly restored database having a spurious record of execution costs, + * which is what we're really concerned about here. + */ + unlink(PGLM_DUMP_FILE); + + return; + + read_error: + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not read file \"%s\": %m", + PGLM_DUMP_FILE))); + goto fail; + data_error: + ereport(LOG, + (errcode(ERRCODE_INVALID_PARAMETER_VALUE), + errmsg("ignoring invalid data in file \"%s\"", + PGLM_DUMP_FILE))); + goto fail; + write_error: + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not write file \"%s\": %m", + PGLM_TEXT_FILE))); + fail: + if (buffer) + pfree(buffer); + if (file) + FreeFile(file); + if (lmfile) + FreeFile(lmfile); + /* If possible, throw away the bogus file; ignore any error */ + unlink(PGLM_DUMP_FILE); + + /* + * Don't unlink PGLM_TEXT_FILE here; it should always be around while the + * server is running with pg_stat_logmsg enabled + */ + } + + /* + * shmem_shutdown hook: Dump statistics into file. + * + * Note: we don't bother with acquiring lock, because there should be no + * other processes running when this is called. + */ + static void + pglm_shmem_shutdown(int code, Datum arg) + { + FILE *file; + char *mlbuffer = NULL; + Size mlbuffer_size = 0; + HASH_SEQ_STATUS hash_seq; + int32 num_entries; + pglmEntry *entry; + + /* Don't try to dump during a crash. */ + if (code) + return; + + /* Safety check ... shouldn't get here unless shmem is set up. */ + if (!pglm || !pglm_hash) + return; + + file = AllocateFile(PGLM_DUMP_FILE ".tmp", PG_BINARY_W); + if (file == NULL) + goto error; + + if (fwrite(&PGLM_FILE_HEADER, sizeof(uint32), 1, file) != 1) + goto error; + if (fwrite(&PGLM_PG_MAJOR_VERSION, sizeof(uint32), 1, file) != 1) + goto error; + num_entries = hash_get_num_entries(pglm_hash); + if (fwrite(&num_entries, sizeof(int32), 1, file) != 1) + goto error; + + mlbuffer = logmsg_load_file(&mlbuffer_size); + if (mlbuffer == NULL) + goto error; + + /* + * When serializing to disk, we store logmsg texts immediately after their + * entry data. Any orphaned logmsg texts are thereby excluded. + */ + hash_seq_init(&hash_seq, pglm_hash); + while ((entry = hash_seq_search(&hash_seq)) != NULL) + { + int len = entry->logmsg_len; + char *qstr = logmsg_fetch(entry->logmsg_offset, len, + mlbuffer, mlbuffer_size); + + if (qstr == NULL) + continue; /* Ignore any entries with bogus texts */ + + if (fwrite(entry, sizeof(pglmEntry), 1, file) != 1 || + fwrite(qstr, 1, len + 1, file) != len + 1) + { + /* note: we assume hash_seq_term won't change errno */ + hash_seq_term(&hash_seq); + goto error; + } + } + + /* Dump global statistics for pg_stat_logmsg */ + if (fwrite(&pglm->stats, sizeof(pglmGlobalStats), 1, file) != 1) + goto error; + + free(mlbuffer); + mlbuffer = NULL; + + if (FreeFile(file)) + { + file = NULL; + goto error; + } + + /* + * Rename file into place, so we atomically replace any old one. + */ + (void) durable_rename(PGLM_DUMP_FILE ".tmp", PGLM_DUMP_FILE, LOG); + + /* Unlink logmsg-texts file; it's not needed while shutdown */ + unlink(PGLM_TEXT_FILE); + + return; + + error: + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not write file \"%s\": %m", + PGLM_DUMP_FILE ".tmp"))); + free(mlbuffer); + if (file) + FreeFile(file); + unlink(PGLM_DUMP_FILE ".tmp"); + unlink(PGLM_TEXT_FILE); + } + + /* + * log hook: store results if needed + */ + static void + pglm_log_hook(ErrorData *edata) + { + if (!is_in_log_hook) + { + is_in_log_hook = true; + pglm_store(edata); + is_in_log_hook = false; + } + + if (prev_emit_log_hook) + prev_emit_log_hook(edata); + } + + /* + * Store statistics for a log message. + */ + static void + pglm_store(ErrorData *edata) + { + pglmHashKey key; + pglmEntry *entry; + int encoding = GetDatabaseEncoding(); + size_t filename_len; + + Assert(edata != NULL); + + /* Safety check... */ + if (!pglm || !pglm_hash) + return; + + /* Set up key for hashtable search */ + + /* memset() is required when pglmHashKey is without padding only */ + memset(&key, 0, sizeof(pglmHashKey)); + + /* make persistent copies of strings */ + if (edata->filename) + { + filename_len = strlen(edata->filename); + memcpy(key.filename, edata->filename, + filename_len < MAXFILENAMELEN ? + filename_len : MAXFILENAMELEN ); + } + + key.lineno = edata->lineno; + key.elevel = edata->elevel; + + /* Lookup the hash table entry with shared lock. */ + LWLockAcquire(pglm->lock, LW_SHARED); + + entry = (pglmEntry *) hash_search(pglm_hash, &key, HASH_FIND, NULL); + + /* Create new entry, if not present */ + if (!entry) + { + Size logmsg_offset; + int logmsg_len; + int gc_count; + bool stored; + bool do_gc; + + /* Append new logmsg text to file with only shared lock held */ + stored = logmsg_store(edata, &logmsg_offset, &logmsg_len, &gc_count); + + /* + * Determine whether we need to garbage collect external logmsg texts + * while the shared lock is still held. This micro-optimization + * avoids taking the time to decide this while holding exclusive lock. + */ + do_gc = need_gc_logmsgs(); + + /* Need exclusive lock to make a new hashtable entry - promote */ + LWLockRelease(pglm->lock); + LWLockAcquire(pglm->lock, LW_EXCLUSIVE); + + /* + * A garbage collection may have occurred while we weren't holding the + * lock. In the unlikely event that this happens, the logmsg text we + * stored above will have been garbage collected, so write it again. + * This should be infrequent enough that doing it while holding + * exclusive lock isn't a performance problem. + */ + if (!stored || pglm->gc_count != gc_count) + stored = logmsg_store(edata, &logmsg_offset, &logmsg_len, NULL); + + /* If we failed to write to the text file, give up */ + if (!stored) + goto done; + + /* OK to create a new hashtable entry */ + entry = entry_alloc(&key, logmsg_offset, logmsg_len, + encoding, edata->sqlerrcode, + (char *) edata->funcname); + + /* If needed, perform garbage collection while exclusive lock held */ + if (do_gc) + gc_logmsgs(); + } + + /* + * Grab the spinlock while updating the counters (see comment about + * locking rules at the head of the file) + */ + { + volatile pglmEntry *e = (volatile pglmEntry *) entry; + + SpinLockAcquire(&e->mutex); + e->counters.msgcnt += 1; + SpinLockRelease(&e->mutex); + } + + done: + LWLockRelease(pglm->lock); + } + + /* + * Reset statement statistics. + */ + Datum + pg_stat_logmsg_reset(PG_FUNCTION_ARGS) + { + entry_reset(NULL, 0, 0); + + PG_RETURN_VOID(); + } + + /* Number of output arguments (columns) */ + #define PG_STAT_LOGMSG_COLS 9 + + Datum + pg_stat_logmsg(PG_FUNCTION_ARGS) + { + pg_stat_logmsg_internal(fcinfo); + + return (Datum) 0; + } + + /* Common code for all versions of pg_stat_statements() */ + static void + pg_stat_logmsg_internal(FunctionCallInfo fcinfo) + { + ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo; + Oid userid = GetUserId(); + char *mlbuffer = NULL; + Size mlbuffer_size = 0; + Size extent = 0; + int gc_count = 0; + HASH_SEQ_STATUS hash_seq; + pglmEntry *entry; + int n_writers; + + /* + * Superusers or roles with the privileges of pg_read_all_stats members + * are allowed + */ + #if PG_VERSION_NUM >= 140000 + #define PGLM_STATSROLE ROLE_PG_READ_ALL_STATS + #else + #define PGLM_STATSROLE DEFAULT_ROLE_READ_ALL_STATS + #endif /* PG_VERSION_NUM >= 140000 */ + if (!has_privs_of_role(userid, PGLM_STATSROLE)) + ereport(ERROR, + (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), + errmsg("must be member of %s role", + GetUserNameFromId(PGLM_STATSROLE, false)))); + + /* hash table must exist already */ + if (!pglm || !pglm_hash) + ereport(ERROR, + (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), + errmsg("pg_stat_logmsg must be loaded via shared_preload_libraries"))); + + InitMaterializedSRF(fcinfo, 0); + + /* Check we have the expected number of output arguments. */ + if (rsinfo->setDesc->natts != PG_STAT_LOGMSG_COLS) + elog(ERROR, "incorrect number of output arguments"); + + /* + * We'd like to load the logmsg text file (if needed) while not holding any + * lock on pglm->lock. In the worst case we'll have to do this again + * after we have the lock, but it's unlikely enough to make this a win + * despite occasional duplicated work. We need to reload if anybody + * writes to the file (either a retail logmsg_store(), or a garbage + * collection) between this point and where we've gotten shared lock. If + * a logmsg_store is actually in progress when we look, we might as well + * skip the speculative load entirely. + */ + + /* Take the mutex so we can examine variables */ + { + volatile pglmSharedState *s = (volatile pglmSharedState *) pglm; + + SpinLockAcquire(&s->mutex); + extent = s->extent; + n_writers = s->n_writers; + gc_count = s->gc_count; + SpinLockRelease(&s->mutex); + } + + /* No point in loading file now if there are active writers */ + if (n_writers == 0) + mlbuffer = logmsg_load_file(&mlbuffer_size); + + /* + * Get shared lock, load or reload the logmsg text file if we must, and + * iterate over the hashtable entries. + * + * With a large hash table, we might be holding the lock rather longer + * than one could wish. However, this only blocks creation of new hash + * table entries, and the larger the hash table the less likely that is to + * be needed. So we can hope this is okay. Perhaps someday we'll decide + * we need to partition the hash table to limit the time spent holding any + * one lock. + */ + LWLockAcquire(pglm->lock, LW_SHARED); + + /* + * Here it is safe to examine extent and gc_count without taking the + * mutex. Note that although other processes might change + * pglm->extent just after we look at it, the strings they then write + * into the file cannot yet be referenced in the hashtable, so we + * don't care whether we see them or not. + * + * If logmsg_load_file fails, we just press on; we'll return NULL for + * every logmsg text. + */ + if (mlbuffer == NULL || + pglm->extent != extent || + pglm->gc_count != gc_count) + { + free(mlbuffer); + mlbuffer = logmsg_load_file(&mlbuffer_size); + } + + hash_seq_init(&hash_seq, pglm_hash); + while ((entry = hash_seq_search(&hash_seq)) != NULL) + { + Datum values[PG_STAT_LOGMSG_COLS]; + bool nulls[PG_STAT_LOGMSG_COLS]; + int i = 0; + Counters tmp; + char *mstr; + + memset(values, 0, sizeof(values)); + memset(nulls, 0, sizeof(nulls)); + + values[i++] = CStringGetTextDatum(PG_VERSION); + values[i++] = CStringGetTextDatum(entry->key.filename); + values[i++] = Int32GetDatum(entry->key.lineno); + values[i++] = CStringGetTextDatum(error_severity(entry->key.elevel)); + + if (entry->funcname[0]) + values[i++] = CStringGetTextDatum(entry->funcname); + else + nulls[i++] = true; + + values[i++] = CStringGetTextDatum(unpack_sql_state(entry->sqlerrcode)); + + mstr = logmsg_fetch(entry->logmsg_offset, + entry->logmsg_len, + mlbuffer, + mlbuffer_size); + + if (mstr) + { + char *enc; + + enc = pg_any_to_server(mstr, + entry->logmsg_len, + entry->encoding); + /* first the original format string */ + values[i++] = CStringGetTextDatum(enc); + /* then the localized string */ + values[i++] = CStringGetTextDatum(_(enc)); + + if (enc != mstr) + pfree(enc); + } + else + { + /* Just return a null if we fail to find the text */ + nulls[i++] = true; + nulls[i++] = true; + } + + /* copy counters to a local variable to keep locking time short */ + { + volatile pglmEntry *e = (volatile pglmEntry *) entry; + + SpinLockAcquire(&e->mutex); + tmp = e->counters; + SpinLockRelease(&e->mutex); + } + + values[i++] = Int64GetDatumFast(tmp.msgcnt); + + tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc, values, nulls); + } + + LWLockRelease(pglm->lock); + + free(mlbuffer); + } + + /* Number of output arguments (columns) for pg_stat_logmsg_info */ + #define PG_STAT_LOGMSG_INFO_COLS 2 + + /* + * Return statistics of pg_stat_logmsg. + */ + Datum + pg_stat_logmsg_info(PG_FUNCTION_ARGS) + { + pglmGlobalStats stats; + TupleDesc tupdesc; + Datum values[PG_STAT_LOGMSG_INFO_COLS] = {0}; + bool nulls[PG_STAT_LOGMSG_INFO_COLS] = {0}; + + if (!pglm || !pglm_hash) + ereport(ERROR, + (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), + errmsg("pg_stat_logmsg must be loaded via shared_preload_libraries"))); + + /* Build a tuple descriptor for our result type */ + if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE) + elog(ERROR, "return type must be a row type"); + + /* Read global statistics for pg_stat_logmsg */ + { + volatile pglmSharedState *s = (volatile pglmSharedState *) pglm; + + SpinLockAcquire(&s->mutex); + stats = s->stats; + SpinLockRelease(&s->mutex); + } + + values[0] = Int64GetDatum(stats.dealloc); + values[1] = TimestampTzGetDatum(stats.stats_reset); + + PG_RETURN_DATUM(HeapTupleGetDatum(heap_form_tuple(tupdesc, values, nulls))); + } + + /* + * Estimate shared memory space needed. + */ + static Size + pglm_memsize(void) + { + Size size; + + size = MAXALIGN(sizeof(pglmSharedState)); + size = add_size(size, hash_estimate_size(pglm_max, sizeof(pglmEntry))); + + return size; + } + + /* + * Allocate a new hashtable entry. + * caller must hold an exclusive lock on pglm->lock + * + * Note: despite needing exclusive lock, it's not an error for the target + * entry to already exist. This is because pglm_store releases and + * reacquires lock after failing to find a match; so someone else could + * have made the entry while we waited to get exclusive lock. + */ + static pglmEntry * + entry_alloc(pglmHashKey *key, + Size logmsg_offset, + int logmsg_len, + int encoding, + int sqlerrcode, + char *efuncname) + { + pglmEntry *entry; + bool found; + + /* Make space if needed */ + while (hash_get_num_entries(pglm_hash) >= pglm_max) + entry_dealloc(); + + /* Find or create an entry with desired hash code */ + entry = (pglmEntry *) hash_search(pglm_hash, key, HASH_ENTER, &found); + + if (!found) + { + /* New entry, initialize it */ + + /* reset the statistics */ + memset(&entry->counters, 0, sizeof(Counters)); + /* set the appropriate initial usage count */ + entry->counters.usage = USAGE_INIT; + /* re-initialize the mutex each time ... we assume no one using it */ + SpinLockInit(&entry->mutex); + /* ... and don't forget the logmsg text metadata */ + Assert(logmsg_len >= 0); + entry->logmsg_offset = logmsg_offset; + entry->logmsg_len = logmsg_len; + entry->encoding = encoding; + entry->sqlerrcode = sqlerrcode; + + if (efuncname) + { + size_t funcname_len = strlen(efuncname); + + memcpy(entry->funcname, efuncname, + funcname_len < MAXFUNCNAMELEN ? + funcname_len : MAXFUNCNAMELEN ); + } + } + + return entry; + } + + /* + * qsort comparator for sorting into increasing usage order + */ + static int + entry_cmp(const void *lhs, const void *rhs) + { + double l_usage = (*(pglmEntry *const *) lhs)->counters.usage; + double r_usage = (*(pglmEntry *const *) rhs)->counters.usage; + + if (l_usage < r_usage) + return -1; + else if (l_usage > r_usage) + return +1; + else + return 0; + } + + /* + * Deallocate least-used entries. + * + * Caller must hold an exclusive lock on pglm->lock. + */ + static void + entry_dealloc(void) + { + HASH_SEQ_STATUS hash_seq; + pglmEntry **entries; + pglmEntry *entry; + int nvictims; + int i; + Size tottextlen; + int nvalidtexts; + + /* + * Sort entries by usage and deallocate USAGE_DEALLOC_PERCENT of them. + * While we're scanning the table, apply the decay factor to the usage + * values, and update the mean query length. + * + * Note that the mean query length is almost immediately obsolete, since + * we compute it before not after discarding the least-used entries. + * Hopefully, that doesn't affect the mean too much; it doesn't seem worth + * making two passes to get a more current result. Likewise, the new + * cur_median_usage includes the entries we're about to zap. + */ + + entries = palloc(hash_get_num_entries(pglm_hash) * sizeof(pglmEntry *)); + + i = 0; + tottextlen = 0; + nvalidtexts = 0; + + hash_seq_init(&hash_seq, pglm_hash); + while ((entry = hash_seq_search(&hash_seq)) != NULL) + { + entries[i++] = entry; + entry->counters.usage *= USAGE_DECREASE_FACTOR; + /* In the mean length computation, ignore dropped texts. */ + if (entry->logmsg_len >= 0) + { + tottextlen += entry->logmsg_len + 1; + nvalidtexts++; + } + } + + /* Sort into increasing order by usage */ + qsort(entries, i, sizeof(pglmEntry *), entry_cmp); + + /* Record the (approximate) median usage */ + if (i > 0) + pglm->cur_median_usage = entries[i / 2]->counters.usage; + /* Record the mean query length */ + if (nvalidtexts > 0) + pglm->mean_logmsg_len = tottextlen / nvalidtexts; + else + pglm->mean_logmsg_len = ASSUMED_LENGTH_INIT; + + /* Now zap an appropriate fraction of lowest-usage entries */ + nvictims = Max(10, i * USAGE_DEALLOC_PERCENT / 100); + nvictims = Min(nvictims, i); + + for (i = 0; i < nvictims; i++) + hash_search(pglm_hash, &entries[i]->key, HASH_REMOVE, NULL); + + pfree(entries); + + /* Increment the number of times entries are deallocated */ + { + volatile pglmSharedState *s = (volatile pglmSharedState *) pglm; + + SpinLockAcquire(&s->mutex); + s->stats.dealloc += 1; + SpinLockRelease(&s->mutex); + } + } + + /* + * Given a logmsg string (not necessarily null-terminated), allocate a new + * entry in the external logmsg text file and store the string there. + * + * If successful, returns true, and stores the new entry's offset in the file + * into *logmsg_offset. Also, if gc_count isn't NULL, *gc_count is set to the + * number of garbage collections that have occurred so far. + * + * On failure, returns false. + * + * At least a shared lock on pglm->lock must be held by the caller, so as + * to prevent a concurrent garbage collection. Share-lock-holding callers + * should pass a gc_count pointer to obtain the number of garbage collections, + * so that they can recheck the count after obtaining exclusive lock to + * detect whether a garbage collection occurred (and removed this entry). + */ + static bool + logmsg_store(ErrorData *edata, Size *logmsg_offset, + int *logmsg_len, int *gc_count) + { + Size off; + int fd; + + if (edata->message_id) + *logmsg_len = strlen(edata->message_id); + + /* + * We use a spinlock to protect extent/n_writers/gc_count, so that + * multiple processes may execute this function concurrently. + */ + { + volatile pglmSharedState *s = (volatile pglmSharedState *) pglm; + + SpinLockAcquire(&s->mutex); + off = s->extent; + s->extent += *logmsg_len + 1; + s->n_writers++; + if (gc_count) + *gc_count = s->gc_count; + SpinLockRelease(&s->mutex); + } + + *logmsg_offset = off; + + /* + * Don't allow the file to grow larger than what logmsg_load_file can + * (theoretically) handle. This has been seen to be reachable on 32-bit + * platforms. + */ + if (unlikely(*logmsg_len >= MaxAllocHugeSize - off)) + { + errno = EFBIG; /* not quite right, but it'll do */ + fd = -1; + goto error; + } + + /* Now write the data into the successfully-reserved part of the file */ + fd = OpenTransientFile(PGLM_TEXT_FILE, O_RDWR | O_CREAT | PG_BINARY); + if (fd < 0) + goto error; + + #if PG_VERSION_NUM >= 120000 + if (pg_pwrite(fd, edata->message_id, *logmsg_len, off) != *logmsg_len) + goto error; + if (pg_pwrite(fd, "\0", 1, off + *logmsg_len) != 1) + goto error; + #else + if (lseek(fd, off, SEEK_SET) != off) + goto error; + + if (write(fd, edata->message_id, *logmsg_len) != *logmsg_len) + goto error; + if (write(fd, "\0", 1) != 1) + goto error; + #endif /* PG_VERSION_NUM >= 120000 */ + + CloseTransientFile(fd); + + /* Mark our write complete */ + { + volatile pglmSharedState *s = (volatile pglmSharedState *) pglm; + + SpinLockAcquire(&s->mutex); + s->n_writers--; + SpinLockRelease(&s->mutex); + } + + return true; + + error: + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not write file \"%s\": %m", + PGLM_TEXT_FILE))); + + if (fd >= 0) + CloseTransientFile(fd); + + /* Mark our write complete */ + { + volatile pglmSharedState *s = (volatile pglmSharedState *) pglm; + + SpinLockAcquire(&s->mutex); + s->n_writers--; + SpinLockRelease(&s->mutex); + } + + return false; + } + + /* + * Read the external logmsg text file into a malloc'd buffer. + * + * Returns NULL (without throwing an error) if unable to read, eg + * file not there or insufficient memory. + * + * On success, the buffer size is also returned into *buffer_size. + * + * This can be called without any lock on pglm->lock, but in that case + * the caller is responsible for verifying that the result is sane. + */ + static char * + logmsg_load_file(Size *buffer_size) + { + char *buf; + int fd; + struct stat stat; + Size nread; + + fd = OpenTransientFile(PGLM_TEXT_FILE, O_RDONLY | PG_BINARY); + if (fd < 0) + { + if (errno != ENOENT) + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not read file \"%s\": %m", + PGLM_TEXT_FILE))); + return NULL; + } + + /* Get file length */ + if (fstat(fd, &stat)) + { + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not stat file \"%s\": %m", + PGLM_TEXT_FILE))); + CloseTransientFile(fd); + return NULL; + } + + /* Allocate buffer; beware that off_t might be wider than size_t */ + if (stat.st_size <= MaxAllocHugeSize) + buf = (char *) malloc(stat.st_size); + else + buf = NULL; + + if (buf == NULL) + { + ereport(LOG, + (errcode(ERRCODE_OUT_OF_MEMORY), + errmsg("out of memory"), + errdetail("Could not allocate enough memory to read file \"%s\".", + PGLM_TEXT_FILE))); + CloseTransientFile(fd); + return NULL; + } + + /* + * OK, slurp in the file. Windows fails if we try to read more than + * INT_MAX bytes at once, and other platforms might not like that either, + * so read a very large file in 1GB segments. + */ + nread = 0; + while (nread < stat.st_size) + { + int toread = Min(1024 * 1024 * 1024, stat.st_size - nread); + + /* + * If we get a short read and errno doesn't get set, the reason is + * probably that garbage collection truncated the file since we did + * the fstat(), so we don't log a complaint --- but we don't return + * the data, either, since it's most likely corrupt due to concurrent + * writes from garbage collection. + */ + errno = 0; + if (read(fd, buf + nread, toread) != toread) + { + if (errno) + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not read file \"%s\": %m", + PGLM_TEXT_FILE))); + free(buf); + CloseTransientFile(fd); + return NULL; + } + nread += toread; + } + + if (CloseTransientFile(fd) != 0) + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not close file \"%s\": %m", PGLM_TEXT_FILE))); + + *buffer_size = nread; + return buf; + } + + /* + * Locate a logmsg text in the file image previously read by logmsg_load_file(). + * + * We validate the given offset/length, and return NULL if bogus. Otherwise, + * the result points to a null-terminated string within the buffer. + */ + static char * + logmsg_fetch(Size logmsg_offset, int logmsg_len, + char *buffer, Size buffer_size) + { + /* File read failed? */ + if (buffer == NULL) + return NULL; + /* Bogus offset/length? */ + if (logmsg_len < 0 || + logmsg_offset + logmsg_len >= buffer_size) + return NULL; + /* As a further sanity check, make sure there's a trailing null */ + if (buffer[logmsg_offset + logmsg_len] != '\0') + return NULL; + /* Looks OK */ + return buffer + logmsg_offset; + } + + /* + * Do we need to garbage-collect the external logmsg text file? + * + * Caller should hold at least a shared lock on pglm->lock. + */ + static bool + need_gc_logmsgs(void) + { + Size extent; + + /* Read shared extent pointer */ + { + volatile pglmSharedState *s = (volatile pglmSharedState *) pglm; + + SpinLockAcquire(&s->mutex); + extent = s->extent; + SpinLockRelease(&s->mutex); + } + + /* + * Don't proceed if file does not exceed 512 bytes per possible entry. + * + * Here and in the next test, 32-bit machines have overflow hazards if + * pglm_max and/or mean_logmsg_len are large. Force the multiplications + * and comparisons to be done in uint64 arithmetic to forestall trouble. + */ + if ((uint64) extent < (uint64) 512 * pglm_max) + return false; + + /* + * Don't proceed if file is less than about 50% bloat. Nothing can or + * should be done in the event of unusually large logmsg texts accounting + * for file's large size. We go to the trouble of maintaining the mean + * query length in order to prevent garbage collection from thrashing + * uselessly. + */ + if ((uint64) extent < (uint64) pglm->mean_logmsg_len * pglm_max * 2) + return false; + + return true; + } + + /* + * Garbage-collect orphaned logmsg texts in external file. + * + * This won't be called often in the typical case, since it's likely that + * there won't be too much churn, and besides, a similar compaction process + * occurs when serializing to disk at shutdown or as part of resetting. + * Despite this, it seems prudent to plan for the edge case where the file + * becomes unreasonably large, with no other method of compaction likely to + * occur in the foreseeable future. + * + * The caller must hold an exclusive lock on pglm->lock. + * + * At the first sign of trouble we unlink the logmsg text file to get a clean + * slate (although existing statistics are retained), rather than risk + * thrashing by allowing the same problem case to recur indefinitely. + */ + static void + gc_logmsgs(void) + { + char *mlbuffer; + Size mlbuffer_size; + FILE *lmfile = NULL; + HASH_SEQ_STATUS hash_seq; + pglmEntry *entry; + Size extent; + int nentries; + + /* + * When called from pglm_store, some other session might have proceeded + * with garbage collection in the no-lock-held interim of lock strength + * escalation. Check once more that this is actually necessary. + */ + if (!need_gc_logmsgs()) + return; + + /* + * Load the old texts file. If we fail (out of memory, for instance), + * invalidate logmsg texts. Hopefully this is rare. It might seem better + * to leave things alone on an OOM failure, but the problem is that the + * file is only going to get bigger; hoping for a future non-OOM result is + * risky and can easily lead to complete denial of service. + */ + mlbuffer = logmsg_load_file(&mlbuffer_size); + if (mlbuffer == NULL) + goto gc_fail; + + /* + * We overwrite the logmsg texts file in place, so as to reduce the risk of + * an out-of-disk-space failure. Since the file is guaranteed not to get + * larger, this should always work on traditional filesystems; though we + * could still lose on copy-on-write filesystems. + */ + lmfile = AllocateFile(PGLM_TEXT_FILE, PG_BINARY_W); + if (lmfile == NULL) + { + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not write file \"%s\": %m", + PGLM_TEXT_FILE))); + goto gc_fail; + } + + extent = 0; + nentries = 0; + + hash_seq_init(&hash_seq, pglm_hash); + while ((entry = hash_seq_search(&hash_seq)) != NULL) + { + int logmsg_len = entry->logmsg_len; + char *msg = logmsg_fetch(entry->logmsg_offset, + logmsg_len, + mlbuffer, + mlbuffer_size); + + if (msg == NULL) + { + /* Trouble ... drop the text */ + entry->logmsg_offset = 0; + entry->logmsg_len = -1; + /* entry will not be counted in mean logmsg length computation */ + continue; + } + + if (fwrite(msg, 1, logmsg_len + 1, lmfile) != logmsg_len + 1) + { + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not write file \"%s\": %m", + PGLM_TEXT_FILE))); + hash_seq_term(&hash_seq); + goto gc_fail; + } + + entry->logmsg_offset = extent; + extent += logmsg_len + 1; + nentries++; + } + + /* + * Truncate away any now-unused space. If this fails for some odd reason, + * we log it, but there's no need to fail. + */ + if (ftruncate(fileno(lmfile), extent) != 0) + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not truncate file \"%s\": %m", + PGLM_TEXT_FILE))); + + if (FreeFile(lmfile)) + { + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not write file \"%s\": %m", + PGLM_TEXT_FILE))); + lmfile = NULL; + goto gc_fail; + } + + elog(DEBUG1, "pglm gc of queries file shrunk size from %zu to %zu", + pglm->extent, extent); + + /* Reset the shared extent pointer */ + pglm->extent = extent; + + /* + * Also update the mean logmsg length, to be sure that need_gc_logmsgs() + * won't still think we have a problem. + */ + if (nentries > 0) + pglm->mean_logmsg_len = extent / nentries; + else + pglm->mean_logmsg_len = ASSUMED_LENGTH_INIT; + + free(mlbuffer); + + /* + * OK, count a garbage collection cycle. (Note: even though we have + * exclusive lock on pglm->lock, we must take pglm->mutex for this, since + * other processes may examine gc_count while holding only the mutex. + * Also, we have to advance the count *after* we've rewritten the file, + * else other processes might not realize they read a stale file.) + */ + record_gc_msgfmts(); + + return; + + gc_fail: + /* clean up resources */ + if (lmfile) + FreeFile(lmfile); + free(mlbuffer); + + /* + * Since the contents of the external file are now uncertain, mark all + * hashtable entries as having invalid texts. + */ + hash_seq_init(&hash_seq, pglm_hash); + while ((entry = hash_seq_search(&hash_seq)) != NULL) + { + entry->logmsg_offset = 0; + entry->logmsg_len = -1; + } + + /* + * Destroy the logmsg text file and create a new, empty one + */ + (void) unlink(PGLM_TEXT_FILE); + lmfile = AllocateFile(PGLM_TEXT_FILE, PG_BINARY_W); + if (lmfile == NULL) + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not recreate file \"%s\": %m", + PGLM_TEXT_FILE))); + else + FreeFile(lmfile); + + /* Reset the shared extent pointer */ + pglm->extent = 0; + + /* Reset mean_logmsg_len to match the new state */ + pglm->mean_logmsg_len = ASSUMED_LENGTH_INIT; + + /* + * Bump the GC count even though we failed. + * + * This is needed to make concurrent readers of file without any lock on + * pglm->lock notice existence of new version of file. Once readers + * subsequently observe a change in GC count with pglm->lock held, that + * forces a safe reopen of file. Writers also require that we bump here, + * of course. (As required by locking protocol, readers and writers don't + * trust earlier file contents until gc_count is found unchanged after + * pglm->lock acquired in shared or exclusive mode respectively.) + */ + record_gc_msgfmts(); + } + + /* + * Release entries corresponding to parameters passed. + */ + static void + entry_reset(char *filename, int lineno, int elevel) + { + HASH_SEQ_STATUS hash_seq; + pglmEntry *entry; + FILE *lmfile; + long num_entries; + long num_remove = 0; + pglmHashKey key; + + if (!pglm || !pglm_hash) + ereport(ERROR, + (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), + errmsg("pg_stat_logmsg must be loaded via shared_preload_libraries"))); + + LWLockAcquire(pglm->lock, LW_EXCLUSIVE); + num_entries = hash_get_num_entries(pglm_hash); + + if (filename != NULL && lineno != 0 && elevel != 0) + { + /* If all the parameters are available, use the fast path. */ + memset(&key, 0, sizeof(pglmHashKey)); + + if (filename) + { + size_t filename_len = strlen(filename); + + memcpy(key.filename, filename, + filename_len < MAXFILENAMELEN ? + filename_len : MAXFILENAMELEN ); + } + else + memset(key.filename, '\0', MAXFILENAMELEN); + + key.lineno = lineno; + key.elevel = elevel; + + /* Remove the key if exists */ + entry = (pglmEntry *) hash_search(pglm_hash, &key, HASH_REMOVE, NULL); + if (entry) /* found */ + num_remove++; + } + else if (filename != NULL || lineno != 0 || elevel != 0) + { + /* Remove entries corresponding to valid parameters. */ + hash_seq_init(&hash_seq, pglm_hash); + while ((entry = hash_seq_search(&hash_seq)) != NULL) + { + if ((!filename || entry->key.filename == filename) && + (!lineno || entry->key.lineno == lineno) && + (!elevel || entry->key.elevel == elevel)) + { + hash_search(pglm_hash, &entry->key, HASH_REMOVE, NULL); + num_remove++; + } + } + } + else + { + /* Remove all entries. */ + hash_seq_init(&hash_seq, pglm_hash); + while ((entry = hash_seq_search(&hash_seq)) != NULL) + { + hash_search(pglm_hash, &entry->key, HASH_REMOVE, NULL); + num_remove++; + } + } + + /* All entries are removed? */ + if (num_entries != num_remove) + goto release_lock; + + /* + * Reset global statistics for pg_stat_logmsg since all entries are + * removed. + */ + { + volatile pglmSharedState *s = (volatile pglmSharedState *) pglm; + TimestampTz stats_reset = GetCurrentTimestamp(); + + SpinLockAcquire(&s->mutex); + s->stats.dealloc = 0; + s->stats.stats_reset = stats_reset; + SpinLockRelease(&s->mutex); + } + + /* + * Write new empty logmsg file, perhaps even creating a new one to recover + * if the file was missing. + */ + lmfile = AllocateFile(PGLM_TEXT_FILE, PG_BINARY_W); + if (lmfile == NULL) + { + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not create file \"%s\": %m", + PGLM_TEXT_FILE))); + goto done; + } + + /* If ftruncate fails, log it, but it's not a fatal problem */ + if (ftruncate(fileno(lmfile), 0) != 0) + ereport(LOG, + (errcode_for_file_access(), + errmsg("could not truncate file \"%s\": %m", + PGLM_TEXT_FILE))); + + FreeFile(lmfile); + + done: + pglm->extent = 0; + /* This counts as a logmsg text garbage collection for our purposes */ + record_gc_msgfmts(); + + release_lock: + LWLockRelease(pglm->lock); + } + + /* + * logmsg_xact_callback --- cleanup at main-transaction end. + */ + static void + logmsg_xact_callback(XactEvent event, void *arg) + { + is_in_log_hook = false; + } + + #if PG_VERSION_NUM < 150000 + /* flag bits for InitMaterializedSRF() */ + #define MAT_SRF_USE_EXPECTED_DESC 0x01 /* use expectedDesc as tupdesc. */ + #define MAT_SRF_BLESS 0x02 /* "Bless" a tuple descriptor with + * BlessTupleDesc(). */ + + /* + * InitMaterializedSRF + * + * Helper function to build the state of a set-returning function used + * in the context of a single call with materialize mode. This code + * includes sanity checks on ReturnSetInfo, creates the Tuplestore and + * the TupleDesc used with the function and stores them into the + * function's ReturnSetInfo. + * + * "flags" can be set to MAT_SRF_USE_EXPECTED_DESC, to use the tuple + * descriptor coming from expectedDesc, which is the tuple descriptor + * expected by the caller. MAT_SRF_BLESS can be set to complete the + * information associated to the tuple descriptor, which is necessary + * in some cases where the tuple descriptor comes from a transient + * RECORD datatype. + */ + static void + InitMaterializedSRF(FunctionCallInfo fcinfo, bits32 flags) + { + bool random_access; + ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo; + Tuplestorestate *tupstore; + MemoryContext old_context, + per_query_ctx; + TupleDesc stored_tupdesc; + + /* check to see if caller supports returning a tuplestore */ + if (rsinfo == NULL || !IsA(rsinfo, ReturnSetInfo)) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("set-valued function called in context that cannot accept a set"))); + if (!(rsinfo->allowedModes & SFRM_Materialize) || + ((flags & MAT_SRF_USE_EXPECTED_DESC) != 0 && rsinfo->expectedDesc == NULL)) + ereport(ERROR, + (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), + errmsg("materialize mode required, but it is not allowed in this context"))); + + /* + * Store the tuplestore and the tuple descriptor in ReturnSetInfo. This + * must be done in the per-query memory context. + */ + per_query_ctx = rsinfo->econtext->ecxt_per_query_memory; + old_context = MemoryContextSwitchTo(per_query_ctx); + + /* build a tuple descriptor for our result type */ + if ((flags & MAT_SRF_USE_EXPECTED_DESC) != 0) + stored_tupdesc = CreateTupleDescCopy(rsinfo->expectedDesc); + else + { + if (get_call_result_type(fcinfo, NULL, &stored_tupdesc) != TYPEFUNC_COMPOSITE) + elog(ERROR, "return type must be a row type"); + } + + /* If requested, bless the tuple descriptor */ + if ((flags & MAT_SRF_BLESS) != 0) + BlessTupleDesc(stored_tupdesc); + + random_access = (rsinfo->allowedModes & SFRM_Materialize_Random) != 0; + + tupstore = tuplestore_begin_heap(random_access, false, work_mem); + rsinfo->returnMode = SFRM_Materialize; + rsinfo->setResult = tupstore; + rsinfo->setDesc = stored_tupdesc; + MemoryContextSwitchTo(old_context); + } + + /* + * error_severity --- get string representing elevel + * + * The string is not localized here, but we mark the strings for translation + * so that callers can invoke _() on the result. + */ + static const char * + error_severity(int elevel) + { + const char *prefix; + + switch (elevel) + { + case DEBUG1: + case DEBUG2: + case DEBUG3: + case DEBUG4: + case DEBUG5: + prefix = gettext_noop("DEBUG"); + break; + case LOG: + case LOG_SERVER_ONLY: + prefix = gettext_noop("LOG"); + break; + case INFO: + prefix = gettext_noop("INFO"); + break; + case NOTICE: + prefix = gettext_noop("NOTICE"); + break; + case WARNING: + #if PG_VERSION_NUM >= 140000 + case WARNING_CLIENT_ONLY: + #endif /* PG_VERSION_NUM >= 140000 */ + prefix = gettext_noop("WARNING"); + break; + case ERROR: + prefix = gettext_noop("ERROR"); + break; + case FATAL: + prefix = gettext_noop("FATAL"); + break; + case PANIC: + prefix = gettext_noop("PANIC"); + break; + default: + prefix = "???"; + break; + } + + return prefix; + } + #endif /* PG_VERSION_NUM < 150000 */ diff --git a/contrib/pg_stat_logmsg/pg_stat_logmsg.conf b/contrib/pg_stat_logmsg/pg_stat_logmsg.conf index ...ab6336c . *** a/contrib/pg_stat_logmsg/pg_stat_logmsg.conf --- b/contrib/pg_stat_logmsg/pg_stat_logmsg.conf *************** *** 0 **** --- 1 ---- + shared_preload_libraries = 'pg_stat_logmsg' diff --git a/contrib/pg_stat_logmsg/pg_stat_logmsg.control b/contrib/pg_stat_logmsg/pg_stat_logmsg.control index ...800b550 . *** a/contrib/pg_stat_logmsg/pg_stat_logmsg.control --- b/contrib/pg_stat_logmsg/pg_stat_logmsg.control *************** *** 0 **** --- 1,5 ---- + # pg_stat_logmsg extension + comment = 'track statistics of log messages' + default_version = '1.0' + module_pathname = '$libdir/pg_stat_logmsg' + relocatable = true diff --git a/doc/src/sgml/pgstatlogmsg.sgml b/doc/src/sgml/pgstatlogmsg.sgml index ...3f52beb . *** a/doc/src/sgml/pgstatlogmsg.sgml --- b/doc/src/sgml/pgstatlogmsg.sgml *************** *** 0 **** --- 1,595 ---- + + + + pg_stat_logmsg — track counts of normalized server log messages + + + pg_stat_logmsg + + + + The pg_stat_logmsg module provides a means for + tracking the aggregated counts of normalized server log message strings. + + + + The module must be loaded by adding pg_stat_logmsg to + in + postgresql.conf, because it requires additional shared memory. + This means that a server restart is needed to add or remove the module. + + + + When pg_stat_logmsg is active, it tracks + log message counts across all databases of the server. To access and manipulate + these statistics, the module provides views + pg_stat_logmsg and + pg_stat_logmsg_info, + and the utility functions pg_stat_logmsg_reset and + pg_stat_logmsg. These are not available globally but + can be enabled for a specific database with + CREATE EXTENSION pg_stat_logmsg. + + + + The <structname>pg_stat_logmsg</structname> View + + + The counts gathered by the module are made available via a + view named pg_stat_logmsg. This view + contains one row for each distinct combination of source code + filename, source code line number, and log severity level + (up to the maximum number of distinct messages that the module + can track). The columns of the view are shown in + . + + + + <structname>pg_stat_logmsg</structname> Columns + + + + + Column Type + + + Description + + + + + + + + + pgversion text + + + PostgreSQL version number. Useful for + correlating source code filename and line number with the actual + entry source code. + + + + + + filename text + + + Source code filename where the log message originates. + + + + + + lineno int + + + Source code line number where the log message originates. + + + + + + elevel text + + + Log message severity level as called at runtime. + + + + + + funcname text + + + Source code function name where the log message originates. + + + + + + sqlerrcode text + + + SQL error code of the log message. See . + + + + + + message text + + + Normalized log message. Basically the log message text with the + replaceable format parameters rather than the actual runtime + data. + + + + + + translated_message text + + + Same as message, except localized. + + + + + + count bigint + + + Number of times this log message has occurred. + + + + +
+ + + For security reasons, only superusers and roles with privileges of the + pg_read_all_stats role are allowed to view this data. + + + + Log messages are combined into a single + pg_stat_logmsg entry whenever they + originate from identical source code filename + and line number (lineno), + and they have the same runtime error severity level + (elevel). + + + + As a rule of thumb, filename, + lineno, and elevel + values can be assumed to be stable and comparable only so long as + the underlying server version stays exactly the same. + + + + The representative log messages are kept in an external disk file, and do + not consume shared memory. Therefore, even very lengthy log messages can + be stored successfully. However, if many long log messages are + accumulated, the external file might grow unmanageably large. As a + recovery method if that happens, pg_stat_logmsg may + choose to discard the log messages, whereupon all existing entries in + the pg_stat_logmsg view will show + null message fields, though the counts + associated with each row are preserved. If this happens, consider + reducing pg_stat_logmsg.max to prevent + recurrences. + + + + + The <structname>pg_stat_logmsg_info</structname> View + + + pg_stat_logmsg_info + + + + The statistics of the pg_stat_logmsg module + itself are tracked and made available via a view named + pg_stat_logmsg_info. This view contains + only a single row. The columns of the view are shown in + . + + + + <structname>pg_stat_logmsg_info</structname> Columns + + + + + Column Type + + + Description + + + + + + + + dealloc bigint + + + Total number of times pg_stat_logmsg + entries about the least-executed statements were deallocated + because more distinct statements than + pg_stat_logmsg.max were observed + + + + + stats_reset timestamp with time zone + + + Time at which all statistics in the + pg_stat_logmsg view were last reset. + + + + + +
+ + + + Functions + + + + + pg_stat_logmsg_reset() returns void + + pg_stat_logmsg_reset + + + + + + pg_stat_logmsg_reset discards all statistics + gathered so far by pg_stat_logmsg. It will + also reset the statistics in the + pg_stat_logmsg_info view. + By default, this function can only be executed by superusers. + Access may be granted to others using GRANT. + + + + + + + pg_stat_logmsg() returns setof record + + pg_stat_logmsg + function + + + + + + The pg_stat_logmsg view is defined in + terms of a function also named pg_stat_logmsg. + It is possible for clients to call + the pg_stat_logmsg function directly. + + + + + + + + Configuration Parameters + + + + + pg_stat_logmsg.max (integer) + + pg_stat_logmsg.max configuration parameter + + + + + + pg_stat_logmsg.max is the maximum number of + log messages tracked by the module (i.e., the maximum number of rows + in the pg_stat_logmsg view). If more distinct + log messages than that are observed, information about the least-recorded + log message is discarded. The number of times such information was + discarded can be seen in the + pg_stat_logmsg_info view. + The default value is 5000. + This parameter can only be set at server start. + + + + + + + The module requires additional shared memory proportional to + pg_stat_logmsg.max. Note that this + memory is consumed whenever the module is loaded. + + + + These parameters must be set in postgresql.conf. + Typical usage might be: + + + # postgresql.conf + shared_preload_libraries = 'pg_stat_logmsg' + + pg_stat_logmsg.max = 10000 + + + + + + Sample Output + + + $ make installcheck + $ psql logmsg + logmsg=# \x + logmsg=# -- most common messages + logmsg=# SELECT * FROM pg_stat_logmsg + ORDER BY count DESC LIMIT 5; + -[ RECORD 1 ]------+---------------------------------------- + pgversion | 17devel + filename | aclchk.c + lineno | 2807 + elevel | ERROR + funcname | aclcheck_error + sqlerrcode | 42501 + message | permission denied for schema %s + translated_message | permission denied for schema %s + count | 282 + -[ RECORD 2 ]------+---------------------------------------- + pgversion | 17devel + filename | mcxt.c + lineno | 913 + elevel | LOG + funcname | MemoryContextStatsPrint + sqlerrcode | 00000 + message | level: %d; %s: %s%s + translated_message | level: %d; %s: %s%s + count | 255 + -[ RECORD 3 ]------+---------------------------------------- + pgversion | 17devel + filename | pl_exec.c + lineno | 3909 + elevel | WARNING + funcname | exec_stmt_raise + sqlerrcode | 01000 + message | %s + translated_message | %s + count | 241 + -[ RECORD 4 ]------+---------------------------------------- + pgversion | 17devel + filename | scan.l + lineno | 1241 + elevel | ERROR + funcname | scanner_yyerror + sqlerrcode | 42601 + message | %s at or near "%s" + translated_message | %s at or near "%s" + count | 133 + -[ RECORD 5 ]------+---------------------------------------- + pgversion | 17devel + filename | datetime.c + lineno | 4002 + elevel | ERROR + funcname | DateTimeParseError + sqlerrcode | 22015 + message | interval field value out of range: "%s" + translated_message | interval field value out of range: "%s" + count | 120 + + logmsg=# -- internal errors + logmsg=# SELECT * FROM pg_stat_logmsg + WHERE sqlerrcode = 'XX000' + ORDER BY count DESC LIMIT 5; + -[ RECORD 1 ]------+------------------------------------------------------- + pgversion | 17devel + filename | user.c + lineno | 2130 + elevel | ERROR + funcname | check_role_membership_authorization + sqlerrcode | XX000 + message | role "%s" cannot have explicit members + translated_message | role "%s" cannot have explicit members + count | 2 + -[ RECORD 2 ]------+------------------------------------------------------- + pgversion | 17devel + filename | tablecmds.c + lineno | 11216 + elevel | ERROR + funcname | ATExecAlterConstraint + sqlerrcode | XX000 + message | cannot alter constraint "%s" on relation "%s" + translated_message | cannot alter constraint "%s" on relation "%s" + count | 2 + -[ RECORD 3 ]------+------------------------------------------------------- + pgversion | 17devel + filename | tid.c + lineno | 358 + elevel | ERROR + funcname | currtid_for_view + sqlerrcode | XX000 + message | currtid cannot handle views with no CTID + translated_message | currtid cannot handle views with no CTID + count | 1 + -[ RECORD 4 ]------+------------------------------------------------------- + pgversion | 17devel + filename | tid.c + lineno | 315 + elevel | ERROR + funcname | currtid_internal + sqlerrcode | XX000 + message | cannot look at latest visible tid for relation "%s.%s" + translated_message | cannot look at latest visible tid for relation "%s.%s" + count | 1 + -[ RECORD 5 ]------+------------------------------------------------------- + pgversion | 17devel + filename | pg_locale.c + lineno | 2904 + elevel | ERROR + funcname | icu_validate_locale + sqlerrcode | XX000 + message | ICU locale "%s" has unknown language "%s" + translated_message | ICU locale "%s" has unknown language "%s" + count | 1 + + logmsg=# SELECT sqlerrcode, sum(count) AS total_count + FROM pg_stat_logmsg + GROUP BY sqlerrcode ORDER BY 1; + sqlerrcode | total_count + ------------+------------- + 00000 | 295 + 01000 | 318 + 01006 | 1 + 01007 | 5 + 08006 | 2 + 08P01 | 1 + 09000 | 5 + 0A000 | 400 + 0LP01 | 9 + 0Z002 | 2 + 21000 | 9 + 22000 | 11 + 22001 | 17 + 22003 | 184 + 22004 | 25 + 22005 | 1 + 22007 | 91 + 22008 | 95 + 22009 | 2 + 2200C | 1 + 2200F | 1 + 2200H | 2 + 2200L | 5 + 2200M | 2 + 2200N | 16 + 2200S | 2 + 2200T | 1 + 22011 | 6 + 22012 | 54 + 22013 | 6 + 22014 | 1 + 22015 | 120 + 22016 | 1 + 2201B | 7 + 2201E | 21 + 2201F | 11 + 2201G | 14 + 2201W | 1 + 22021 | 1 + 22023 | 332 + 22025 | 3 + 22026 | 5 + 2202E | 33 + 2202G | 1 + 2202H | 5 + 22030 | 14 + 22031 | 8 + 22033 | 7 + 22036 | 13 + 22038 | 9 + 22039 | 3 + 2203A | 8 + 2203B | 2 + 2203C | 4 + 22P02 | 357 + 22P04 | 13 + 22P05 | 8 + 22P06 | 10 + 23502 | 69 + 23503 | 132 + 23505 | 70 + 23514 | 220 + 23P01 | 13 + 24000 | 9 + 25001 | 21 + 25006 | 16 + 25P01 | 33 + 25P02 | 14 + 27000 | 3 + 2BP01 | 86 + 2F003 | 1 + 2F005 | 1 + 34000 | 5 + 39P03 | 1 + 3B001 | 1 + 3D000 | 4 + 3F000 | 16 + 42501 | 525 + 42601 | 387 + 42602 | 8 + 42611 | 7 + 42701 | 18 + 42702 | 7 + 42703 | 140 + 42704 | 154 + 42710 | 67 + 42712 | 12 + 42723 | 4 + 42725 | 14 + 42803 | 38 + 42804 | 171 + 42809 | 135 + 42830 | 2 + 42846 | 4 + 42883 | 138 + 428C9 | 21 + 42P01 | 128 + 42P02 | 1 + 42P05 | 1 + 42P06 | 1 + 42P07 | 20 + 42P09 | 2 + 42P10 | 85 + 42P13 | 79 + 42P15 | 15 + 42P16 | 119 + 42P17 | 98 + 42P18 | 1 + 42P19 | 19 + 42P20 | 14 + 42P21 | 17 + 42P22 | 8 + 44000 | 31 + 54000 | 3 + 54001 | 5 + 54011 | 3 + 55000 | 143 + 55006 | 8 + 55P04 | 5 + 58P01 | 5 + F0000 | 3 + P0001 | 42 + P0002 | 5 + P0003 | 11 + P0004 | 4 + XX000 | 14 + (126 rows) + + + + + + Authors + + + Joe Conway mail@joeconway.com. + + + +