Support a wildcard in backtrace_functions

From 7f9208ccb95df113873e7c23257e1215b1be6919 Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <dgustafsson@postgresql.org>
Date: Mon, 12 Feb 2024 14:02:40 +0100
Subject: [PATCH v2 2/2] Support wildcard in backtrace_functions to handle all
 errors

Sometimes during debugging it can be useful to get backtraces for all
errors, regardless of where they were fired. This is possible already
by specifying a list of functions, but it can quickly become unwieldy
when the exact callsite isn't known in advance. This adds support for
specifying a '*' wildcard which will emit backtraces for *all* errors
regardless (but only elevel >= ERROR).

Author: Jelte Fennema-Nio <me@jeltef.nl>
Discussion: https://postgr.es/m/CAGECzQTpdujCEt2SH4DBwRLoDq4HJArGDaxJSsWX0G=tNnzaVA@mail.gmail.com
---
 doc/src/sgml/config.sgml       |  5 +++++
 src/backend/utils/error/elog.c | 14 ++++++++------
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index f865d0b87e..21cc96c327 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11075,6 +11075,11 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
         be used to debug specific areas of the source code.
        </para>
 
+       <para>
+        A single <literal>*</literal> character is interpreted as a wildcard and
+        will cause all errors in the log to contain backtraces.
+       </para>
+
        <para>
         Backtrace support is not available on all platforms, and the quality
         of the backtraces depends on compilation options.
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index 700fbde6db..6776972309 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -182,7 +182,7 @@ static void set_stack_entry_domain(ErrorData *edata, const char *domain);
 static void set_stack_entry_location(ErrorData *edata,
 									 const char *filename, int lineno,
 									 const char *funcname);
-static bool matches_backtrace_functions(const char *funcname);
+static bool matches_backtrace_functions(const char *funcname, int elevel);
 static pg_noinline void set_backtrace(ErrorData *edata, int num_skip);
 static void set_errdata_field(MemoryContextData *cxt, char **ptr, const char *str);
 static void FreeErrorDataContents(ErrorData *edata);
@@ -500,7 +500,7 @@ errfinish(const char *filename, int lineno, const char *funcname)
 	if (!edata->backtrace &&
 		((edata->funcname &&
 		  backtrace_functions &&
-		  matches_backtrace_functions(edata->funcname)) ||
+		  matches_backtrace_functions(edata->funcname, edata->elevel)) ||
 		 (edata->sqlerrcode == ERRCODE_INTERNAL_ERROR &&
 		  backtrace_on_internal_error)))
 		set_backtrace(edata, 2);
@@ -829,7 +829,7 @@ set_stack_entry_location(ErrorData *edata,
  * See check_backtrace_functions.
  */
 static bool
-matches_backtrace_functions(const char *funcname)
+matches_backtrace_functions(const char *funcname, int elevel)
 {
 	const char *p;
 
@@ -842,6 +842,8 @@ matches_backtrace_functions(const char *funcname)
 		if (*p == '\0')			/* end of backtrace_function_list */
 			break;
 
+		if (strcmp("*", p) == 0 && elevel >= ERROR)
+			return true;
 		if (strcmp(funcname, p) == 0)
 			return true;
 		p += strlen(p) + 1;
@@ -2134,14 +2136,14 @@ check_backtrace_functions(char **newval, void **extra, GucSource source)
 	int			j;
 
 	/*
-	 * Allow characters that can be C identifiers and commas as separators, as
-	 * well as some whitespace for readability.
+	 * Allow characters that can be C identifiers, commas as separators, the
+	 * wildcard symbol, as well as some whitespace for readability.
 	 */
 	validlen = strspn(*newval,
 					  "0123456789_"
 					  "abcdefghijklmnopqrstuvwxyz"
 					  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-					  ", \n\t");
+					  ",* \n\t");
 	if (validlen != newvallen)
 	{
 		GUC_check_errdetail("Invalid character");
-- 
2.32.1 (Apple Git-133)

From 913cb1ccfaf1600d6f25eb5bc9a3f587806a77bb Mon Sep 17 00:00:00 2001
From: Daniel Gustafsson <dgustafsson@postgresql.org>
Date: Mon, 12 Feb 2024 13:58:13 +0100
Subject: [PATCH v2 1/2] doc: Clarify when backtrace_functions is invoked

The documentation for backtrace_functions only mentioned error logs,
but backtraces will be printed for LOG as well so soften the wording
a bit to make clear that not just errors can be debugged like this.
---
 doc/src/sgml/config.sgml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 61038472c5..f865d0b87e 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11069,9 +11069,9 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       <listitem>
        <para>
         This parameter contains a comma-separated list of C function names.
-        If an error is raised and the name of the internal C function where
-        the error happens matches a value in the list, then a backtrace is
-        written to the server log together with the error message.  This can
+        If an log entry is raised and the name of the internal C function where
+        the logging happens matches a value in the list, then a backtrace is
+        written to the server log together with the log message.  This can
         be used to debug specific areas of the source code.
        </para>
 
-- 
2.32.1 (Apple Git-133)

From 71e2c1f1fa903ecfce4a79ff5981d0d754d134a2 Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Wed, 20 Dec 2023 11:41:18 +0100
Subject: [PATCH v3 2/2] Add wildcard support to backtrace_functions GUC

With this change setting backtrace_functions to '*' will start logging
backtraces for all errors (or more precisely all logs).
---
 doc/src/sgml/config.sgml       | 5 +++++
 src/backend/utils/error/elog.c | 8 +++++---
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index ba5dbf9f096..a59d8e1b263 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11136,6 +11136,11 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
         code.
        </para>
 
+       <para>
+        A single <literal>*</literal> character is interpreted as a wildcard and
+        will cause all errors in the log to contain backtraces.
+       </para>
+
        <para>
         Backtrace support is not available on all platforms, and the quality
         of the backtraces depends on compilation options.
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index 8364125f44a..923e00e766e 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -843,6 +843,8 @@ matches_backtrace_functions(const char *funcname)
 		if (*p == '\0')			/* end of backtrace_function_list */
 			break;
 
+		if (strcmp("*", p) == 0)
+			return true;
 		if (strcmp(funcname, p) == 0)
 			return true;
 		p += strlen(p) + 1;
@@ -2135,14 +2137,14 @@ check_backtrace_functions(char **newval, void **extra, GucSource source)
 	int			j;
 
 	/*
-	 * Allow characters that can be C identifiers and commas as separators, as
-	 * well as some whitespace for readability.
+	 * Allow characters that can be C identifiers, commas as separators, the
+	 * wildcard symbol, as well as some whitespace for readability.
 	 */
 	validlen = strspn(*newval,
 					  "0123456789_"
 					  "abcdefghijklmnopqrstuvwxyz"
 					  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-					  ", \n\t");
+					  ",* \n\t");
 	if (validlen != newvallen)
 	{
 		GUC_check_errdetail("Invalid character");
-- 
2.34.1

From 4ffbc6b51a711bd266f15c02611d894b080a3e11 Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Tue, 27 Feb 2024 17:31:24 +0100
Subject: [PATCH v3 1/2] Add backtrace_functions_min_level

Before this change a stacktrace would be attached to all logs messages
in a function that matched backtrace_functions. But in most cases people
only care about the stacktraces for messages with an ERROR level. This
changes that default to only log stacktraces for ERROR messages but
keeps the option open of logging stacktraces for different log levels
too by having users configure the new backtrace_functions_min_level GUC.
---
 doc/src/sgml/config.sgml            | 37 +++++++++++++++++++++++++----
 src/backend/utils/error/elog.c      |  1 +
 src/backend/utils/misc/guc_tables.c | 12 ++++++++++
 src/include/utils/guc.h             |  1 +
 4 files changed, 47 insertions(+), 4 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 36a2a5ce431..ba5dbf9f096 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11128,10 +11128,12 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       <listitem>
        <para>
         This parameter contains a comma-separated list of C function names.
-        If an error is raised and the name of the internal C function where
-        the error happens matches a value in the list, then a backtrace is
-        written to the server log together with the error message.  This can
-        be used to debug specific areas of the source code.
+        If a log entry is raised with a level higher than
+        <xref linkend="guc-backtrace-functions-min-level"/> and the name of the
+        internal C function where the error happens matches a value in the
+        list, then a backtrace is written to the server log together with the
+        error message. This can be used to debug specific areas of the source
+        code.
        </para>
 
        <para>
@@ -11146,6 +11148,33 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-backtrace-functions-min-level" xreflabel="backtrace_functions_min_level">
+      <term><varname>backtrace_functions_min_level</varname> (<type>string</type>)
+      <indexterm>
+        <primary><varname>backtrace_functions_min_level</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        Controls which <link linkend="runtime-config-severity-levels">message
+        levels</link> cause stack traces to be written to the log, for log
+        entries in C functions that match the configured
+        <xref linkend="guc-backtrace-functions"/>.
+       </para>
+
+       <para>
+        Backtrace support is not available on all platforms, and the quality
+        of the backtraces depends on compilation options.
+       </para>
+
+       <para>
+        Only superusers and users with the appropriate <literal>SET</literal>
+        privilege can change this setting.
+       </para>
+      </listitem>
+     </varlistentry>
+
+
      <varlistentry id="guc-backtrace-on-internal-error" xreflabel="backtrace_on_internal_error">
       <term><varname>backtrace_on_internal_error</varname> (<type>boolean</type>)
       <indexterm>
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index bba00a0087f..8364125f44a 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -500,6 +500,7 @@ errfinish(const char *filename, int lineno, const char *funcname)
 	if (!edata->backtrace &&
 		((edata->funcname &&
 		  backtrace_functions &&
+		  edata->elevel >= backtrace_functions_min_level &&
 		  matches_backtrace_functions(edata->funcname)) ||
 		 (edata->sqlerrcode == ERRCODE_INTERNAL_ERROR &&
 		  backtrace_on_internal_error)))
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index 527a2b27340..20cedc208e7 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -529,6 +529,7 @@ double		log_statement_sample_rate = 1.0;
 double		log_xact_sample_rate = 0;
 char	   *backtrace_functions;
 bool		backtrace_on_internal_error = false;
+int			backtrace_functions_min_level = ERROR;
 
 int			temp_file_limit = -1;
 
@@ -4658,6 +4659,17 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"backtrace_functions_min_level", PGC_SUSET, DEVELOPER_OPTIONS,
+			gettext_noop("Sets the message levels that create backtraces when backtrace_functions is configured"),
+			NULL,
+			GUC_NOT_IN_SAMPLE
+		},
+		&backtrace_functions_min_level,
+		ERROR, client_message_level_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
 			gettext_noop("Sets the output format for bytea."),
diff --git a/src/include/utils/guc.h b/src/include/utils/guc.h
index 471d53da8f0..69d5cb7a125 100644
--- a/src/include/utils/guc.h
+++ b/src/include/utils/guc.h
@@ -267,6 +267,7 @@ extern PGDLLIMPORT double log_statement_sample_rate;
 extern PGDLLIMPORT double log_xact_sample_rate;
 extern PGDLLIMPORT char *backtrace_functions;
 extern PGDLLIMPORT bool backtrace_on_internal_error;
+extern PGDLLIMPORT int backtrace_functions_min_level;
 
 extern PGDLLIMPORT int temp_file_limit;
 

base-commit: 92d2ab7554f92b841ea71bcc72eaa8ab11aae662
-- 
2.34.1

From 5ab507155a1cb60e490209d28a092fc2d7c0f6be Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Wed, 20 Dec 2023 11:41:18 +0100
Subject: [PATCH v4 2/2] Add wildcard support to backtrace_functions GUC

With this change setting backtrace_functions to '*' will start logging
backtraces for all errors (or more precisely all logs).
---
 doc/src/sgml/config.sgml       | 5 +++++
 src/backend/utils/error/elog.c | 8 +++++---
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index bc066284334..2a6d015d6d4 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11275,6 +11275,11 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
         code.
        </para>
 
+       <para>
+        A single <literal>*</literal> character is interpreted as a wildcard and
+        will cause all errors in the log to contain backtraces.
+       </para>
+
        <para>
         Backtrace support is not available on all platforms, and the quality
         of the backtraces depends on compilation options.
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index 699d9d0a241..553e4785520 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -843,6 +843,8 @@ matches_backtrace_functions(const char *funcname)
 		if (*p == '\0')			/* end of backtrace_function_list */
 			break;
 
+		if (strcmp("*", p) == 0)
+			return true;
 		if (strcmp(funcname, p) == 0)
 			return true;
 		p += strlen(p) + 1;
@@ -2133,14 +2135,14 @@ check_backtrace_functions(char **newval, void **extra, GucSource source)
 	int			j;
 
 	/*
-	 * Allow characters that can be C identifiers and commas as separators, as
-	 * well as some whitespace for readability.
+	 * Allow characters that can be C identifiers, commas as separators, the
+	 * wildcard symbol, as well as some whitespace for readability.
 	 */
 	validlen = strspn(*newval,
 					  "0123456789_"
 					  "abcdefghijklmnopqrstuvwxyz"
 					  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-					  ", \n\t");
+					  ",* \n\t");
 	if (validlen != newvallen)
 	{
 		GUC_check_errdetail("Invalid character");
-- 
2.34.1

From d928c3e49593f3bf08def8a40c246d3aa8de46ac Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Tue, 27 Feb 2024 17:31:24 +0100
Subject: [PATCH v4 1/2] Add backtrace_functions_min_level

Before this change a stacktrace would be attached to all logs messages
in a function that matched backtrace_functions. But in most cases people
only care about the stacktraces for messages with an ERROR level. This
changes that default to only log stacktraces for ERROR messages but
keeps the option open of logging stacktraces for different log levels
too by having users configure the new backtrace_functions_min_level GUC.
---
 doc/src/sgml/config.sgml            | 46 ++++++++++++++++++++++++++---
 src/backend/utils/error/elog.c      |  1 +
 src/backend/utils/misc/guc_tables.c | 29 ++++++++++++++++++
 src/include/utils/guc.h             |  1 +
 4 files changed, 73 insertions(+), 4 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 43b1a132a2c..bc066284334 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11267,10 +11267,12 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       <listitem>
        <para>
         This parameter contains a comma-separated list of C function names.
-        If an error is raised and the name of the internal C function where
-        the error happens matches a value in the list, then a backtrace is
-        written to the server log together with the error message.  This can
-        be used to debug specific areas of the source code.
+        If a log entry is raised with a level equal to or higher than
+        <xref linkend="guc-backtrace-functions-min-level"/> and the name of the
+        internal C function where the error happens matches a value in the
+        list, then a backtrace is written to the server log together with the
+        error message. This can be used to debug specific areas of the source
+        code.
        </para>
 
        <para>
@@ -11285,6 +11287,42 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-backtrace-functions-min-level" xreflabel="backtrace_functions_min_level">
+      <term><varname>backtrace_functions_min_level</varname> (<type>string</type>)
+      <indexterm>
+        <primary><varname>backtrace_functions_min_level</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        Controls which <link linkend="runtime-config-severity-levels">message
+        levels</link> cause stack traces to be written to the log, for messages
+        raised from C functions that match the configured
+        <xref linkend="guc-backtrace-functions"/>.
+        Valid values are <literal>DEBUG5</literal>, <literal>DEBUG4</literal>,
+        <literal>DEBUG3</literal>, <literal>DEBUG2</literal>, <literal>DEBUG1</literal>,
+        <literal>LOG</literal>, <literal>INFO</literal>, <literal>NOTICE</literal>,
+        <literal>WARNING</literal>, <literal>ERROR</literal>, <literal>FATAL</literal>,
+        and <literal>PANIC</literal>.  Each level includes all the levels that
+        follow it.  The later the level, the fewer messages result in a
+        backtrace.  The default is <literal>ERROR</literal>.  Note that
+        <literal>LOG</literal> has a different rank here than in
+        <xref linkend="guc-log-min-messages"/>.
+       </para>
+
+       <para>
+        Backtrace support is not available on all platforms, and the quality
+        of the backtraces depends on compilation options.
+       </para>
+
+       <para>
+        Only superusers and users with the appropriate <literal>SET</literal>
+        privilege can change this setting.
+       </para>
+      </listitem>
+     </varlistentry>
+
+
      <varlistentry id="guc-backtrace-on-internal-error" xreflabel="backtrace_on_internal_error">
       <term><varname>backtrace_on_internal_error</varname> (<type>boolean</type>)
       <indexterm>
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index c9719f358b6..699d9d0a241 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -500,6 +500,7 @@ errfinish(const char *filename, int lineno, const char *funcname)
 	if (!edata->backtrace &&
 		((edata->funcname &&
 		  backtrace_functions &&
+		  edata->elevel >= backtrace_functions_min_level &&
 		  matches_backtrace_functions(edata->funcname)) ||
 		 (edata->sqlerrcode == ERRCODE_INTERNAL_ERROR &&
 		  backtrace_on_internal_error)))
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index 93ded31ed92..94497e0174d 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -162,6 +162,23 @@ static const struct config_enum_entry server_message_level_options[] = {
 	{NULL, 0, false}
 };
 
+static const struct config_enum_entry backtrace_functions_level_options[] = {
+	{"debug5", DEBUG5, false},
+	{"debug4", DEBUG4, false},
+	{"debug3", DEBUG3, false},
+	{"debug2", DEBUG2, false},
+	{"debug1", DEBUG1, false},
+	{"debug", DEBUG2, true},
+	{"log", LOG, false},
+	{"info", INFO, true},
+	{"notice", NOTICE, false},
+	{"warning", WARNING, false},
+	{"error", ERROR, false},
+	{"fatal", FATAL, false},
+	{"panic", PANIC, false},
+	{NULL, 0, false}
+};
+
 static const struct config_enum_entry intervalstyle_options[] = {
 	{"postgres", INTSTYLE_POSTGRES, false},
 	{"postgres_verbose", INTSTYLE_POSTGRES_VERBOSE, false},
@@ -530,6 +547,7 @@ double		log_statement_sample_rate = 1.0;
 double		log_xact_sample_rate = 0;
 char	   *backtrace_functions;
 bool		backtrace_on_internal_error = false;
+int			backtrace_functions_min_level = ERROR;
 
 int			temp_file_limit = -1;
 
@@ -4689,6 +4707,17 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"backtrace_functions_min_level", PGC_SUSET, DEVELOPER_OPTIONS,
+			gettext_noop("Sets the message levels that create backtraces when backtrace_functions is configured"),
+			NULL,
+			GUC_NOT_IN_SAMPLE
+		},
+		&backtrace_functions_min_level,
+		ERROR, backtrace_functions_level_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
 			gettext_noop("Sets the output format for bytea."),
diff --git a/src/include/utils/guc.h b/src/include/utils/guc.h
index 471d53da8f0..69d5cb7a125 100644
--- a/src/include/utils/guc.h
+++ b/src/include/utils/guc.h
@@ -267,6 +267,7 @@ extern PGDLLIMPORT double log_statement_sample_rate;
 extern PGDLLIMPORT double log_xact_sample_rate;
 extern PGDLLIMPORT char *backtrace_functions;
 extern PGDLLIMPORT bool backtrace_on_internal_error;
+extern PGDLLIMPORT int backtrace_functions_min_level;
 
 extern PGDLLIMPORT int temp_file_limit;
 

base-commit: 53c2a97a92665be6bd7d70bd62ae6158fe4db96e
-- 
2.34.1

From d928c3e49593f3bf08def8a40c246d3aa8de46ac Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Tue, 27 Feb 2024 17:31:24 +0100
Subject: [PATCH v4 1/2] Add backtrace_functions_min_level

Before this change a stacktrace would be attached to all logs messages
in a function that matched backtrace_functions. But in most cases people
only care about the stacktraces for messages with an ERROR level. This
changes that default to only log stacktraces for ERROR messages but
keeps the option open of logging stacktraces for different log levels
too by having users configure the new backtrace_functions_min_level GUC.
---
 doc/src/sgml/config.sgml            | 46 ++++++++++++++++++++++++++---
 src/backend/utils/error/elog.c      |  1 +
 src/backend/utils/misc/guc_tables.c | 29 ++++++++++++++++++
 src/include/utils/guc.h             |  1 +
 4 files changed, 73 insertions(+), 4 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 43b1a132a2c..bc066284334 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11267,10 +11267,12 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       <listitem>
        <para>
         This parameter contains a comma-separated list of C function names.
-        If an error is raised and the name of the internal C function where
-        the error happens matches a value in the list, then a backtrace is
-        written to the server log together with the error message.  This can
-        be used to debug specific areas of the source code.
+        If a log entry is raised with a level equal to or higher than
+        <xref linkend="guc-backtrace-functions-min-level"/> and the name of the
+        internal C function where the error happens matches a value in the
+        list, then a backtrace is written to the server log together with the
+        error message. This can be used to debug specific areas of the source
+        code.
        </para>
 
        <para>
@@ -11285,6 +11287,42 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-backtrace-functions-min-level" xreflabel="backtrace_functions_min_level">
+      <term><varname>backtrace_functions_min_level</varname> (<type>string</type>)
+      <indexterm>
+        <primary><varname>backtrace_functions_min_level</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        Controls which <link linkend="runtime-config-severity-levels">message
+        levels</link> cause stack traces to be written to the log, for messages
+        raised from C functions that match the configured
+        <xref linkend="guc-backtrace-functions"/>.
+        Valid values are <literal>DEBUG5</literal>, <literal>DEBUG4</literal>,
+        <literal>DEBUG3</literal>, <literal>DEBUG2</literal>, <literal>DEBUG1</literal>,
+        <literal>LOG</literal>, <literal>INFO</literal>, <literal>NOTICE</literal>,
+        <literal>WARNING</literal>, <literal>ERROR</literal>, <literal>FATAL</literal>,
+        and <literal>PANIC</literal>.  Each level includes all the levels that
+        follow it.  The later the level, the fewer messages result in a
+        backtrace.  The default is <literal>ERROR</literal>.  Note that
+        <literal>LOG</literal> has a different rank here than in
+        <xref linkend="guc-log-min-messages"/>.
+       </para>
+
+       <para>
+        Backtrace support is not available on all platforms, and the quality
+        of the backtraces depends on compilation options.
+       </para>
+
+       <para>
+        Only superusers and users with the appropriate <literal>SET</literal>
+        privilege can change this setting.
+       </para>
+      </listitem>
+     </varlistentry>
+
+
      <varlistentry id="guc-backtrace-on-internal-error" xreflabel="backtrace_on_internal_error">
       <term><varname>backtrace_on_internal_error</varname> (<type>boolean</type>)
       <indexterm>
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index c9719f358b6..699d9d0a241 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -500,6 +500,7 @@ errfinish(const char *filename, int lineno, const char *funcname)
 	if (!edata->backtrace &&
 		((edata->funcname &&
 		  backtrace_functions &&
+		  edata->elevel >= backtrace_functions_min_level &&
 		  matches_backtrace_functions(edata->funcname)) ||
 		 (edata->sqlerrcode == ERRCODE_INTERNAL_ERROR &&
 		  backtrace_on_internal_error)))
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index 93ded31ed92..94497e0174d 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -162,6 +162,23 @@ static const struct config_enum_entry server_message_level_options[] = {
 	{NULL, 0, false}
 };
 
+static const struct config_enum_entry backtrace_functions_level_options[] = {
+	{"debug5", DEBUG5, false},
+	{"debug4", DEBUG4, false},
+	{"debug3", DEBUG3, false},
+	{"debug2", DEBUG2, false},
+	{"debug1", DEBUG1, false},
+	{"debug", DEBUG2, true},
+	{"log", LOG, false},
+	{"info", INFO, true},
+	{"notice", NOTICE, false},
+	{"warning", WARNING, false},
+	{"error", ERROR, false},
+	{"fatal", FATAL, false},
+	{"panic", PANIC, false},
+	{NULL, 0, false}
+};
+
 static const struct config_enum_entry intervalstyle_options[] = {
 	{"postgres", INTSTYLE_POSTGRES, false},
 	{"postgres_verbose", INTSTYLE_POSTGRES_VERBOSE, false},
@@ -530,6 +547,7 @@ double		log_statement_sample_rate = 1.0;
 double		log_xact_sample_rate = 0;
 char	   *backtrace_functions;
 bool		backtrace_on_internal_error = false;
+int			backtrace_functions_min_level = ERROR;
 
 int			temp_file_limit = -1;
 
@@ -4689,6 +4707,17 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"backtrace_functions_min_level", PGC_SUSET, DEVELOPER_OPTIONS,
+			gettext_noop("Sets the message levels that create backtraces when backtrace_functions is configured"),
+			NULL,
+			GUC_NOT_IN_SAMPLE
+		},
+		&backtrace_functions_min_level,
+		ERROR, backtrace_functions_level_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
 			gettext_noop("Sets the output format for bytea."),
diff --git a/src/include/utils/guc.h b/src/include/utils/guc.h
index 471d53da8f0..69d5cb7a125 100644
--- a/src/include/utils/guc.h
+++ b/src/include/utils/guc.h
@@ -267,6 +267,7 @@ extern PGDLLIMPORT double log_statement_sample_rate;
 extern PGDLLIMPORT double log_xact_sample_rate;
 extern PGDLLIMPORT char *backtrace_functions;
 extern PGDLLIMPORT bool backtrace_on_internal_error;
+extern PGDLLIMPORT int backtrace_functions_min_level;
 
 extern PGDLLIMPORT int temp_file_limit;
 

base-commit: 53c2a97a92665be6bd7d70bd62ae6158fe4db96e
-- 
2.34.1

From 5ab507155a1cb60e490209d28a092fc2d7c0f6be Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Wed, 20 Dec 2023 11:41:18 +0100
Subject: [PATCH v4 2/2] Add wildcard support to backtrace_functions GUC

With this change setting backtrace_functions to '*' will start logging
backtraces for all errors (or more precisely all logs).
---
 doc/src/sgml/config.sgml       | 5 +++++
 src/backend/utils/error/elog.c | 8 +++++---
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index bc066284334..2a6d015d6d4 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11275,6 +11275,11 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
         code.
        </para>
 
+       <para>
+        A single <literal>*</literal> character is interpreted as a wildcard and
+        will cause all errors in the log to contain backtraces.
+       </para>
+
        <para>
         Backtrace support is not available on all platforms, and the quality
         of the backtraces depends on compilation options.
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index 699d9d0a241..553e4785520 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -843,6 +843,8 @@ matches_backtrace_functions(const char *funcname)
 		if (*p == '\0')			/* end of backtrace_function_list */
 			break;
 
+		if (strcmp("*", p) == 0)
+			return true;
 		if (strcmp(funcname, p) == 0)
 			return true;
 		p += strlen(p) + 1;
@@ -2133,14 +2135,14 @@ check_backtrace_functions(char **newval, void **extra, GucSource source)
 	int			j;
 
 	/*
-	 * Allow characters that can be C identifiers and commas as separators, as
-	 * well as some whitespace for readability.
+	 * Allow characters that can be C identifiers, commas as separators, the
+	 * wildcard symbol, as well as some whitespace for readability.
 	 */
 	validlen = strspn(*newval,
 					  "0123456789_"
 					  "abcdefghijklmnopqrstuvwxyz"
 					  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-					  ", \n\t");
+					  ",* \n\t");
 	if (validlen != newvallen)
 	{
 		GUC_check_errdetail("Invalid character");
-- 
2.34.1

From 452c828f54312f34c6c099304007eb4b45bd6102 Mon Sep 17 00:00:00 2001
From: Bharath Rupireddy <bharath.rupireddyforpostgres@gmail.com>
Date: Fri, 8 Mar 2024 05:57:24 +0000
Subject: [PATCH v4] Simplify backtrace_functions GUC code

---
 src/backend/utils/error/elog.c      | 125 ++++++++++++++--------------
 src/backend/utils/misc/guc_tables.c |   4 +-
 src/include/utils/guc_hooks.h       |   1 -
 3 files changed, 63 insertions(+), 67 deletions(-)

diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index d5fb5fd4f2..fa41a4c65e 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -114,9 +114,6 @@ char	   *Log_destination_string = NULL;
 bool		syslog_sequence_numbers = true;
 bool		syslog_split_messages = true;
 
-/* Processed form of backtrace_functions GUC */
-static char *backtrace_function_list;
-
 #ifdef HAVE_SYSLOG
 
 /*
@@ -831,24 +828,32 @@ set_stack_entry_location(ErrorData *edata,
 static bool
 matches_backtrace_functions(const char *funcname)
 {
-	const char *p;
+	char	   *rawstring;
+	List	   *elemlist;
+	ListCell   *l;
+	bool		is_parase_okay PG_USED_FOR_ASSERTS_ONLY;
 
-	if (!backtrace_function_list || funcname == NULL || funcname[0] == '\0')
-		return false;
+	/* Need a modifiable copy of string */
+	rawstring = pstrdup(backtrace_functions);
+
+	/* Parse string into list of identifiers */
+	is_parase_okay = SplitIdentifierString(rawstring, ',', &elemlist);
+	Assert(is_parase_okay);
 
-	p = backtrace_function_list;
-	for (;;)
+	foreach(l, elemlist)
 	{
-		if (*p == '\0')			/* end of backtrace_function_list */
-			break;
+		char	   *tok = (char *) lfirst(l);
 
-		if (strcmp("*", p) == 0)
-			return true;
-		if (strcmp(funcname, p) == 0)
+		if (strcmp(tok, "*") == 0 || strcmp(tok, funcname) == 0)
+		{
+			pfree(rawstring);
+			list_free(elemlist);
 			return true;
-		p += strlen(p) + 1;
+		}
 	}
 
+	pfree(rawstring);
+	list_free(elemlist);
 	return false;
 }
 
@@ -2127,68 +2132,60 @@ DebugFileOpen(void)
 bool
 check_backtrace_functions(char **newval, void **extra, GucSource source)
 {
-	int			newvallen = strlen(*newval);
-	char	   *someval;
-	int			validlen;
-	int			i;
-	int			j;
+	char	   *rawstring;
+	List	   *elemlist;
+	ListCell   *l;
 
-	/*
-	 * Allow characters that can be C identifiers, commas as separators, the
-	 * wildcard symbol, as well as some whitespace for readability.
-	 */
-	validlen = strspn(*newval,
-					  "0123456789_"
-					  "abcdefghijklmnopqrstuvwxyz"
-					  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-					  ",* \n\t");
-	if (validlen != newvallen)
+	/* Need a modifiable copy of string */
+	rawstring = pstrdup(*newval);
+
+	/* Parse string into list of identifiers */
+	if (!SplitIdentifierString(rawstring, ',', &elemlist))
 	{
-		GUC_check_errdetail("Invalid character");
+		/* syntax error in list */
+		GUC_check_errdetail("List syntax is invalid.");
+		pfree(rawstring);
+		list_free(elemlist);
 		return false;
 	}
 
-	if (*newval[0] == '\0')
+	foreach(l, elemlist)
 	{
-		*extra = NULL;
-		return true;
-	}
+		char	   *tok = (char *) lfirst(l);
+		int			toklen = strlen(tok);
+		int			validlen;
 
-	/*
-	 * Allocate space for the output and create the copy.  We could discount
-	 * whitespace chars to save some memory, but it doesn't seem worth the
-	 * trouble.
-	 */
-	someval = guc_malloc(ERROR, newvallen + 1 + 1);
-	for (i = 0, j = 0; i < newvallen; i++)
-	{
-		if ((*newval)[i] == ',')
-			someval[j++] = '\0';	/* next item */
-		else if ((*newval)[i] == ' ' ||
-				 (*newval)[i] == '\n' ||
-				 (*newval)[i] == '\t')
-			;					/* ignore these */
-		else
-			someval[j++] = (*newval)[i];	/* copy anything else */
-	}
+		if (strcmp(tok, "*") == 0)
+		{
+			pfree(rawstring);
+			list_free(elemlist);
+			return true;
+		}
+
+		/*
+		 * Allow characters that can be C identifiers, commas as separators,
+		 * the wildcard symbol, as well as some whitespace for readability.
+		 */
+		validlen = strspn(tok,
+						  "0123456789_"
+						  "abcdefghijklmnopqrstuvwxyz"
+						  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+						  ", \n\t");
 
-	/* two \0s end the setting */
-	someval[j] = '\0';
-	someval[j + 1] = '\0';
+		if (validlen != toklen)
+		{
+			GUC_check_errdetail("Invalid character");
+			pfree(rawstring);
+			list_free(elemlist);
+			return false;
+		}
+	}
 
-	*extra = someval;
+	pfree(rawstring);
+	list_free(elemlist);
 	return true;
 }
 
-/*
- * GUC assign_hook for backtrace_functions
- */
-void
-assign_backtrace_functions(const char *newval, void *extra)
-{
-	backtrace_function_list = (char *) extra;
-}
-
 /*
  * GUC check_hook for log_destination
  */
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index ff799a296a..e4ae8e1573 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -4670,11 +4670,11 @@ struct config_string ConfigureNamesString[] =
 		{"backtrace_functions", PGC_SUSET, DEVELOPER_OPTIONS,
 			gettext_noop("Log backtrace for errors in these functions."),
 			NULL,
-			GUC_NOT_IN_SAMPLE
+			GUC_LIST_INPUT | GUC_NOT_IN_SAMPLE
 		},
 		&backtrace_functions,
 		"",
-		check_backtrace_functions, assign_backtrace_functions, NULL
+		check_backtrace_functions, NULL, NULL
 	},
 
 	{
diff --git a/src/include/utils/guc_hooks.h b/src/include/utils/guc_hooks.h
index d64dc5fcdb..b9b801216a 100644
--- a/src/include/utils/guc_hooks.h
+++ b/src/include/utils/guc_hooks.h
@@ -37,7 +37,6 @@ extern bool check_vacuum_buffer_usage_limit(int *newval, void **extra,
 											GucSource source);
 extern bool check_backtrace_functions(char **newval, void **extra,
 									  GucSource source);
-extern void assign_backtrace_functions(const char *newval, void *extra);
 extern bool check_bonjour(bool *newval, void **extra, GucSource source);
 extern bool check_canonical_path(char **newval, void **extra, GucSource source);
 extern void assign_checkpoint_completion_target(double newval, void *extra);
-- 
2.34.1

From 317975f40e8747b76108937f4ecbdd0bba3121a7 Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Wed, 20 Dec 2023 11:41:18 +0100
Subject: [PATCH v5 2/2] Add wildcard support to backtrace_functions GUC

With this change setting backtrace_functions to '*' will start logging
backtraces for all errors (or more precisely all logs).
---
 doc/src/sgml/config.sgml       | 6 ++++++
 src/backend/utils/error/elog.c | 9 +++++++++
 2 files changed, 15 insertions(+)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 254b75382f8..cb195ffb553 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11314,6 +11314,12 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
         code.
        </para>
 
+       <para>
+        A single <literal>*</literal> character can be used instead of a list
+        of C functions. This <literal>*</literal> is interpreted as a wildcard
+        and will cause all errors in the log to contain backtraces.
+       </para>
+
        <para>
         Backtrace support is not available on all platforms, and the quality
         of the backtraces depends on compilation options.
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index b214747500c..ca621ea3fff 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -836,6 +836,9 @@ matches_backtrace_functions(const char *funcname)
 	if (!backtrace_function_list || funcname == NULL || funcname[0] == '\0')
 		return false;
 
+	if (strcmp(backtrace_function_list, "*") == 0)
+		return true;
+
 	p = backtrace_function_list;
 	for (;;)
 	{
@@ -2131,6 +2134,12 @@ check_backtrace_functions(char **newval, void **extra, GucSource source)
 	int			i;
 	int			j;
 
+	if (strcmp(*newval, "*") == 0)
+	{
+		*extra = guc_strdup(ERROR, "*");
+		return true;
+	}
+
 	/*
 	 * Allow characters that can be C identifiers and commas as separators, as
 	 * well as some whitespace for readability.
-- 
2.34.1

From 1c89dd0312c6edb9bb663030522794c0b532582d Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Tue, 27 Feb 2024 17:31:24 +0100
Subject: [PATCH v5 1/2] Add backtrace_functions_min_level

Before this change a stacktrace would be attached to all logs messages
in a function that matched backtrace_functions. But in most cases people
only care about the stacktraces for messages with an ERROR level. This
changes that default to only log stacktraces for ERROR messages but
keeps the option open of logging stacktraces for different log levels
too by having users configure the new backtrace_functions_min_level GUC.
---
 doc/src/sgml/config.sgml            | 46 ++++++++++++++++++++++++++---
 src/backend/utils/error/elog.c      |  1 +
 src/backend/utils/misc/guc_tables.c | 29 ++++++++++++++++++
 src/include/utils/guc.h             |  1 +
 4 files changed, 73 insertions(+), 4 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 65a6e6c4086..254b75382f8 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11306,10 +11306,12 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       <listitem>
        <para>
         This parameter contains a comma-separated list of C function names.
-        If an error is raised and the name of the internal C function where
-        the error happens matches a value in the list, then a backtrace is
-        written to the server log together with the error message.  This can
-        be used to debug specific areas of the source code.
+        If a log entry is raised with a level equal to or higher than
+        <xref linkend="guc-backtrace-functions-min-level"/> and the name of the
+        internal C function where the error happens matches a value in the
+        list, then a backtrace is written to the server log together with the
+        error message. This can be used to debug specific areas of the source
+        code.
        </para>
 
        <para>
@@ -11324,6 +11326,42 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-backtrace-functions-min-level" xreflabel="backtrace_functions_min_level">
+      <term><varname>backtrace_functions_min_level</varname> (<type>string</type>)
+      <indexterm>
+        <primary><varname>backtrace_functions_min_level</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        Controls which <link linkend="runtime-config-severity-levels">message
+        levels</link> cause stack traces to be written to the log, for messages
+        raised from C functions that match the configured
+        <xref linkend="guc-backtrace-functions"/>.
+        Valid values are <literal>DEBUG5</literal>, <literal>DEBUG4</literal>,
+        <literal>DEBUG3</literal>, <literal>DEBUG2</literal>, <literal>DEBUG1</literal>,
+        <literal>LOG</literal>, <literal>INFO</literal>, <literal>NOTICE</literal>,
+        <literal>WARNING</literal>, <literal>ERROR</literal>, <literal>FATAL</literal>,
+        and <literal>PANIC</literal>.  Each level includes all the levels that
+        follow it.  The later the level, the fewer messages result in a
+        backtrace.  The default is <literal>ERROR</literal>.  Note that
+        <literal>LOG</literal> has a different rank here than in
+        <xref linkend="guc-log-min-messages"/>.
+       </para>
+
+       <para>
+        Backtrace support is not available on all platforms, and the quality
+        of the backtraces depends on compilation options.
+       </para>
+
+       <para>
+        Only superusers and users with the appropriate <literal>SET</literal>
+        privilege can change this setting.
+       </para>
+      </listitem>
+     </varlistentry>
+
+
      <varlistentry id="guc-backtrace-on-internal-error" xreflabel="backtrace_on_internal_error">
       <term><varname>backtrace_on_internal_error</varname> (<type>boolean</type>)
       <indexterm>
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index ed8aa5c9fa4..b214747500c 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -499,6 +499,7 @@ errfinish(const char *filename, int lineno, const char *funcname)
 	if (!edata->backtrace &&
 		((edata->funcname &&
 		  backtrace_functions &&
+		  edata->elevel >= backtrace_functions_min_level &&
 		  matches_backtrace_functions(edata->funcname)) ||
 		 (edata->sqlerrcode == ERRCODE_INTERNAL_ERROR &&
 		  backtrace_on_internal_error)))
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index d77214795de..ff799a296a8 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -162,6 +162,23 @@ static const struct config_enum_entry server_message_level_options[] = {
 	{NULL, 0, false}
 };
 
+static const struct config_enum_entry backtrace_functions_level_options[] = {
+	{"debug5", DEBUG5, false},
+	{"debug4", DEBUG4, false},
+	{"debug3", DEBUG3, false},
+	{"debug2", DEBUG2, false},
+	{"debug1", DEBUG1, false},
+	{"debug", DEBUG2, true},
+	{"log", LOG, false},
+	{"info", INFO, true},
+	{"notice", NOTICE, false},
+	{"warning", WARNING, false},
+	{"error", ERROR, false},
+	{"fatal", FATAL, false},
+	{"panic", PANIC, false},
+	{NULL, 0, false}
+};
+
 static const struct config_enum_entry intervalstyle_options[] = {
 	{"postgres", INTSTYLE_POSTGRES, false},
 	{"postgres_verbose", INTSTYLE_POSTGRES_VERBOSE, false},
@@ -530,6 +547,7 @@ double		log_statement_sample_rate = 1.0;
 double		log_xact_sample_rate = 0;
 char	   *backtrace_functions;
 bool		backtrace_on_internal_error = false;
+int			backtrace_functions_min_level = ERROR;
 
 int			temp_file_limit = -1;
 
@@ -4703,6 +4721,17 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"backtrace_functions_min_level", PGC_SUSET, DEVELOPER_OPTIONS,
+			gettext_noop("Sets the message levels that create backtraces when backtrace_functions is configured"),
+			NULL,
+			GUC_NOT_IN_SAMPLE
+		},
+		&backtrace_functions_min_level,
+		ERROR, backtrace_functions_level_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
 			gettext_noop("Sets the output format for bytea."),
diff --git a/src/include/utils/guc.h b/src/include/utils/guc.h
index 3712aba09b0..66dbf637c68 100644
--- a/src/include/utils/guc.h
+++ b/src/include/utils/guc.h
@@ -267,6 +267,7 @@ extern PGDLLIMPORT double log_statement_sample_rate;
 extern PGDLLIMPORT double log_xact_sample_rate;
 extern PGDLLIMPORT char *backtrace_functions;
 extern PGDLLIMPORT bool backtrace_on_internal_error;
+extern PGDLLIMPORT int backtrace_functions_min_level;
 
 extern PGDLLIMPORT int temp_file_limit;
 

base-commit: 6d9751fa8fd40c988541c9c72ac7a2095ba73c19
-- 
2.34.1

From 4edd05bb9c611989b832e6a01552b28b8b18486c Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Tue, 27 Feb 2024 17:31:24 +0100
Subject: [PATCH v6 1/2] Add backtrace_functions_min_level

Before this change a backtrace would be attached to all logs messages
in a function that matched backtrace_functions. But in most cases people
only care about the backtraces for messages with an ERROR level. This
changes that default to only log backtraces for ERROR messages but
keeps the option open of logging backtraces for different log levels
too by having users configure the new backtrace_functions_min_level GUC.
---
 doc/src/sgml/config.sgml            | 41 ++++++++++++++++++++++++++---
 src/backend/utils/error/elog.c      |  1 +
 src/backend/utils/misc/guc_tables.c | 29 ++++++++++++++++++++
 src/include/utils/guc.h             |  1 +
 4 files changed, 68 insertions(+), 4 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 65a6e6c4086..c76e97d2d33 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11306,10 +11306,12 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       <listitem>
        <para>
         This parameter contains a comma-separated list of C function names.
-        If an error is raised and the name of the internal C function where
-        the error happens matches a value in the list, then a backtrace is
-        written to the server log together with the error message.  This can
-        be used to debug specific areas of the source code.
+        If a log entry is raised with a level equal to or higher than
+        <xref linkend="guc-backtrace-functions-min-level"/> and the name of the
+        internal C function where the error happens matches a value in the
+        list, then a backtrace is written to the server log together with the
+        error message. This can be used to debug specific areas of the source
+        code.
        </para>
 
        <para>
@@ -11324,6 +11326,37 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-backtrace-functions-min-level" xreflabel="backtrace_functions_min_level">
+      <term><varname>backtrace_functions_min_level</varname> (<type>string</type>)
+      <indexterm>
+        <primary><varname>backtrace_functions_min_level</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        Controls which <link linkend="runtime-config-severity-levels">message
+        levels</link> cause backtraces to be written to the log, for messages
+        raised from C functions that match the configured
+        <xref linkend="guc-backtrace-functions"/>.
+        Valid values are <literal>DEBUG5</literal>, <literal>DEBUG4</literal>,
+        <literal>DEBUG3</literal>, <literal>DEBUG2</literal>, <literal>DEBUG1</literal>,
+        <literal>LOG</literal>, <literal>INFO</literal>, <literal>NOTICE</literal>,
+        <literal>WARNING</literal>, <literal>ERROR</literal>, <literal>FATAL</literal>,
+        and <literal>PANIC</literal>.  Each level includes all the levels that
+        follow it.  The later the level, the fewer messages result in a
+        backtrace.  The default is <literal>ERROR</literal>.  Note that
+        <literal>LOG</literal> has a different rank here than in
+        <xref linkend="guc-log-min-messages"/>.
+       </para>
+
+       <para>
+        Only superusers and users with the appropriate <literal>SET</literal>
+        privilege can change this setting.
+       </para>
+      </listitem>
+     </varlistentry>
+
+
      <varlistentry id="guc-backtrace-on-internal-error" xreflabel="backtrace_on_internal_error">
       <term><varname>backtrace_on_internal_error</varname> (<type>boolean</type>)
       <indexterm>
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index ed8aa5c9fa4..b214747500c 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -499,6 +499,7 @@ errfinish(const char *filename, int lineno, const char *funcname)
 	if (!edata->backtrace &&
 		((edata->funcname &&
 		  backtrace_functions &&
+		  edata->elevel >= backtrace_functions_min_level &&
 		  matches_backtrace_functions(edata->funcname)) ||
 		 (edata->sqlerrcode == ERRCODE_INTERNAL_ERROR &&
 		  backtrace_on_internal_error)))
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index d77214795de..aa81d763b16 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -162,6 +162,23 @@ static const struct config_enum_entry server_message_level_options[] = {
 	{NULL, 0, false}
 };
 
+static const struct config_enum_entry backtrace_functions_level_options[] = {
+	{"debug5", DEBUG5, false},
+	{"debug4", DEBUG4, false},
+	{"debug3", DEBUG3, false},
+	{"debug2", DEBUG2, false},
+	{"debug1", DEBUG1, false},
+	{"debug", DEBUG2, true},
+	{"log", LOG, false},
+	{"info", INFO, true},
+	{"notice", NOTICE, false},
+	{"warning", WARNING, false},
+	{"error", ERROR, false},
+	{"fatal", FATAL, false},
+	{"panic", PANIC, false},
+	{NULL, 0, false}
+};
+
 static const struct config_enum_entry intervalstyle_options[] = {
 	{"postgres", INTSTYLE_POSTGRES, false},
 	{"postgres_verbose", INTSTYLE_POSTGRES_VERBOSE, false},
@@ -530,6 +547,7 @@ double		log_statement_sample_rate = 1.0;
 double		log_xact_sample_rate = 0;
 char	   *backtrace_functions;
 bool		backtrace_on_internal_error = false;
+int			backtrace_functions_min_level = ERROR;
 
 int			temp_file_limit = -1;
 
@@ -4703,6 +4721,17 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"backtrace_functions_min_level", PGC_SUSET, DEVELOPER_OPTIONS,
+			gettext_noop("Sets the message levels that create backtraces when backtrace_functions is configured."),
+			gettext_noop("Each level includes all the levels that follow it. The later"
+						 " the level, the fewer backtraces are created.")
+		},
+		&backtrace_functions_min_level,
+		ERROR, backtrace_functions_level_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
 			gettext_noop("Sets the output format for bytea."),
diff --git a/src/include/utils/guc.h b/src/include/utils/guc.h
index 3712aba09b0..66dbf637c68 100644
--- a/src/include/utils/guc.h
+++ b/src/include/utils/guc.h
@@ -267,6 +267,7 @@ extern PGDLLIMPORT double log_statement_sample_rate;
 extern PGDLLIMPORT double log_xact_sample_rate;
 extern PGDLLIMPORT char *backtrace_functions;
 extern PGDLLIMPORT bool backtrace_on_internal_error;
+extern PGDLLIMPORT int backtrace_functions_min_level;
 
 extern PGDLLIMPORT int temp_file_limit;
 

base-commit: 6d9751fa8fd40c988541c9c72ac7a2095ba73c19
-- 
2.34.1

From 2dcea42f5583e773864fe7f84c0c218cdea68d76 Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Wed, 20 Dec 2023 11:41:18 +0100
Subject: [PATCH v6 2/2] Add wildcard support to backtrace_functions GUC

With this change setting backtrace_functions to '*' will start logging
backtraces for all errors (or more precisely all logs).
---
 doc/src/sgml/config.sgml       | 8 ++++++++
 src/backend/utils/error/elog.c | 9 +++++++++
 2 files changed, 17 insertions(+)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index c76e97d2d33..1fddc0fce04 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11314,6 +11314,14 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
         code.
        </para>
 
+       <para>
+        A single <literal>*</literal> character can be used instead of a list
+        of C functions. This <literal>*</literal> is interpreted as a wildcard
+        and will cause all log entries equal to or higher than
+        <xref linkend="guc-backtrace-functions-min-level"/> in the log to
+        contain backtraces.
+       </para>
+
        <para>
         Backtrace support is not available on all platforms, and the quality
         of the backtraces depends on compilation options.
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index b214747500c..ca621ea3fff 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -836,6 +836,9 @@ matches_backtrace_functions(const char *funcname)
 	if (!backtrace_function_list || funcname == NULL || funcname[0] == '\0')
 		return false;
 
+	if (strcmp(backtrace_function_list, "*") == 0)
+		return true;
+
 	p = backtrace_function_list;
 	for (;;)
 	{
@@ -2131,6 +2134,12 @@ check_backtrace_functions(char **newval, void **extra, GucSource source)
 	int			i;
 	int			j;
 
+	if (strcmp(*newval, "*") == 0)
+	{
+		*extra = guc_strdup(ERROR, "*");
+		return true;
+	}
+
 	/*
 	 * Allow characters that can be C identifiers and commas as separators, as
 	 * well as some whitespace for readability.
-- 
2.34.1

From b2ffab2a64243690e4031eb873fd233569fb83ba Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Wed, 20 Dec 2023 11:41:18 +0100
Subject: [PATCH v7 2/2] Add wildcard support to backtrace_functions GUC

With this change setting backtrace_functions to '*' will start logging
backtraces for all errors (or more precisely all logs).
---
 doc/src/sgml/config.sgml       | 8 ++++++++
 src/backend/utils/error/elog.c | 9 +++++++++
 2 files changed, 17 insertions(+)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index c76e97d2d33..1fddc0fce04 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11314,6 +11314,14 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
         code.
        </para>
 
+       <para>
+        A single <literal>*</literal> character can be used instead of a list
+        of C functions. This <literal>*</literal> is interpreted as a wildcard
+        and will cause all log entries equal to or higher than
+        <xref linkend="guc-backtrace-functions-min-level"/> in the log to
+        contain backtraces.
+       </para>
+
        <para>
         Backtrace support is not available on all platforms, and the quality
         of the backtraces depends on compilation options.
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index b214747500c..ca621ea3fff 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -836,6 +836,9 @@ matches_backtrace_functions(const char *funcname)
 	if (!backtrace_function_list || funcname == NULL || funcname[0] == '\0')
 		return false;
 
+	if (strcmp(backtrace_function_list, "*") == 0)
+		return true;
+
 	p = backtrace_function_list;
 	for (;;)
 	{
@@ -2131,6 +2134,12 @@ check_backtrace_functions(char **newval, void **extra, GucSource source)
 	int			i;
 	int			j;
 
+	if (strcmp(*newval, "*") == 0)
+	{
+		*extra = guc_strdup(ERROR, "*");
+		return true;
+	}
+
 	/*
 	 * Allow characters that can be C identifiers and commas as separators, as
 	 * well as some whitespace for readability.
-- 
2.34.1

From 91d002469c1fe87f459534860d2ba271c905025d Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Tue, 27 Feb 2024 17:31:24 +0100
Subject: [PATCH v7 1/2] Add backtrace_functions_min_level

Before this change a backtrace would be attached to all logs messages
in a function that matched backtrace_functions. But in most cases people
only care about the backtraces for messages with an ERROR level. This
changes that default to only log backtraces for ERROR messages but
keeps the option open of logging backtraces for different log levels
too by having users configure the new backtrace_functions_min_level GUC.
---
 doc/src/sgml/config.sgml            | 41 ++++++++++++++++++++++++++---
 src/backend/utils/error/elog.c      |  1 +
 src/backend/utils/misc/guc_tables.c | 30 +++++++++++++++++++++
 src/include/utils/guc.h             |  1 +
 4 files changed, 69 insertions(+), 4 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 65a6e6c4086..c76e97d2d33 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11306,10 +11306,12 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       <listitem>
        <para>
         This parameter contains a comma-separated list of C function names.
-        If an error is raised and the name of the internal C function where
-        the error happens matches a value in the list, then a backtrace is
-        written to the server log together with the error message.  This can
-        be used to debug specific areas of the source code.
+        If a log entry is raised with a level equal to or higher than
+        <xref linkend="guc-backtrace-functions-min-level"/> and the name of the
+        internal C function where the error happens matches a value in the
+        list, then a backtrace is written to the server log together with the
+        error message. This can be used to debug specific areas of the source
+        code.
        </para>
 
        <para>
@@ -11324,6 +11326,37 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-backtrace-functions-min-level" xreflabel="backtrace_functions_min_level">
+      <term><varname>backtrace_functions_min_level</varname> (<type>string</type>)
+      <indexterm>
+        <primary><varname>backtrace_functions_min_level</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        Controls which <link linkend="runtime-config-severity-levels">message
+        levels</link> cause backtraces to be written to the log, for messages
+        raised from C functions that match the configured
+        <xref linkend="guc-backtrace-functions"/>.
+        Valid values are <literal>DEBUG5</literal>, <literal>DEBUG4</literal>,
+        <literal>DEBUG3</literal>, <literal>DEBUG2</literal>, <literal>DEBUG1</literal>,
+        <literal>LOG</literal>, <literal>INFO</literal>, <literal>NOTICE</literal>,
+        <literal>WARNING</literal>, <literal>ERROR</literal>, <literal>FATAL</literal>,
+        and <literal>PANIC</literal>.  Each level includes all the levels that
+        follow it.  The later the level, the fewer messages result in a
+        backtrace.  The default is <literal>ERROR</literal>.  Note that
+        <literal>LOG</literal> has a different rank here than in
+        <xref linkend="guc-log-min-messages"/>.
+       </para>
+
+       <para>
+        Only superusers and users with the appropriate <literal>SET</literal>
+        privilege can change this setting.
+       </para>
+      </listitem>
+     </varlistentry>
+
+
      <varlistentry id="guc-backtrace-on-internal-error" xreflabel="backtrace_on_internal_error">
       <term><varname>backtrace_on_internal_error</varname> (<type>boolean</type>)
       <indexterm>
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index ed8aa5c9fa4..b214747500c 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -499,6 +499,7 @@ errfinish(const char *filename, int lineno, const char *funcname)
 	if (!edata->backtrace &&
 		((edata->funcname &&
 		  backtrace_functions &&
+		  edata->elevel >= backtrace_functions_min_level &&
 		  matches_backtrace_functions(edata->funcname)) ||
 		 (edata->sqlerrcode == ERRCODE_INTERNAL_ERROR &&
 		  backtrace_on_internal_error)))
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index d77214795de..7a19214ee0a 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -162,6 +162,23 @@ static const struct config_enum_entry server_message_level_options[] = {
 	{NULL, 0, false}
 };
 
+static const struct config_enum_entry backtrace_functions_level_options[] = {
+	{"debug5", DEBUG5, false},
+	{"debug4", DEBUG4, false},
+	{"debug3", DEBUG3, false},
+	{"debug2", DEBUG2, false},
+	{"debug1", DEBUG1, false},
+	{"debug", DEBUG2, true},
+	{"log", LOG, false},
+	{"info", INFO, true},
+	{"notice", NOTICE, false},
+	{"warning", WARNING, false},
+	{"error", ERROR, false},
+	{"fatal", FATAL, false},
+	{"panic", PANIC, false},
+	{NULL, 0, false}
+};
+
 static const struct config_enum_entry intervalstyle_options[] = {
 	{"postgres", INTSTYLE_POSTGRES, false},
 	{"postgres_verbose", INTSTYLE_POSTGRES_VERBOSE, false},
@@ -530,6 +547,7 @@ double		log_statement_sample_rate = 1.0;
 double		log_xact_sample_rate = 0;
 char	   *backtrace_functions;
 bool		backtrace_on_internal_error = false;
+int			backtrace_functions_min_level = ERROR;
 
 int			temp_file_limit = -1;
 
@@ -4703,6 +4721,18 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"backtrace_functions_min_level", PGC_SUSET, DEVELOPER_OPTIONS,
+			gettext_noop("Sets the message levels that create backtraces when backtrace_functions is configured."),
+			gettext_noop("Each level includes all the levels that follow it. The later"
+						 " the level, the fewer backtraces are created."),
+			GUC_NOT_IN_SAMPLE
+		},
+		&backtrace_functions_min_level,
+		ERROR, backtrace_functions_level_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
 			gettext_noop("Sets the output format for bytea."),
diff --git a/src/include/utils/guc.h b/src/include/utils/guc.h
index 3712aba09b0..66dbf637c68 100644
--- a/src/include/utils/guc.h
+++ b/src/include/utils/guc.h
@@ -267,6 +267,7 @@ extern PGDLLIMPORT double log_statement_sample_rate;
 extern PGDLLIMPORT double log_xact_sample_rate;
 extern PGDLLIMPORT char *backtrace_functions;
 extern PGDLLIMPORT bool backtrace_on_internal_error;
+extern PGDLLIMPORT int backtrace_functions_min_level;
 
 extern PGDLLIMPORT int temp_file_limit;
 

base-commit: 6d9751fa8fd40c988541c9c72ac7a2095ba73c19
-- 
2.34.1

From eb4f9871dd0cdd47d26811849a1b3d42b1273113 Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Thu, 21 Mar 2024 13:05:35 +0100
Subject: [PATCH v8 1/2] Add PGErrorVerbosity to typedefs.list

This one was missing, resulting in some strange alignment.
---
 src/include/utils/elog.h         | 2 +-
 src/tools/pgindent/typedefs.list | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/include/utils/elog.h b/src/include/utils/elog.h
index 054dd2bf62f..da1a7469fa5 100644
--- a/src/include/utils/elog.h
+++ b/src/include/utils/elog.h
@@ -493,7 +493,7 @@ typedef enum
 	PGERROR_TERSE,				/* single-line error messages */
 	PGERROR_DEFAULT,			/* recommended style */
 	PGERROR_VERBOSE,			/* all the facts, ma'am */
-}			PGErrorVerbosity;
+} PGErrorVerbosity;
 
 extern PGDLLIMPORT int Log_error_verbosity;
 extern PGDLLIMPORT char *Log_line_prefix;
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 3b8cec58abc..13048910e46 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -1737,6 +1737,7 @@ PGAsyncStatusType
 PGCALL2
 PGChecksummablePage
 PGContextVisibility
+PGErrorVerbosity
 PGEvent
 PGEventConnDestroy
 PGEventConnReset

base-commit: 1db689715d44276407dc4d6fadbc11da8d391bd9
-- 
2.34.1

From e70dc5571e825af563435204ea07be2bac64f86c Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Tue, 27 Feb 2024 17:31:24 +0100
Subject: [PATCH v8 2/2] Restructure backtrace related GUCs

Our GUCs that controlled backtraces were added a bit ad-hoc. This
restructures them in a more complete and more easily extendable design:

1. Replaces the `backtrace_on_internal_error` GUC with a `log_backtrace`
   one, which can be set to `internal` and `none` to match the previous
   behaviour of the `on` and `off` values of
   `backtrace_on_internal_error`. But it can also be set to `all`
2. Make `backtrace_functions` behave as an additional filter on top of
   `log_backtrace`. The empty string (the default) is now interpreted as
   doing no filtering based on function name.
3. Add a `backtrace_min_level` GUC, which limits for which log entries
   backtraces are written, based on their log level. This defaults to
   ERROR.

Being able to log backtraces for all ERROR logs was the trigger for this
redesign of the backtrace GUCs. This is now possible by simply setting
log_backtrace to "all".
---
 doc/src/sgml/config.sgml                      | 91 ++++++++++++++-----
 src/backend/utils/error/elog.c                | 32 +++++--
 src/backend/utils/misc/guc_tables.c           | 61 ++++++++++---
 src/backend/utils/misc/postgresql.conf.sample |  1 +
 src/include/utils/elog.h                      |  8 ++
 src/include/utils/guc.h                       |  2 +-
 src/tools/pgindent/typedefs.list              |  1 +
 7 files changed, 153 insertions(+), 43 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 65a6e6c4086..c3f343be00d 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -7270,6 +7270,44 @@ local0.*    /var/log/postgresql
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-log-backtrace" xreflabel="backtrace_on_internal_error">
+      <term><varname>log_backtrace</varname> (<type>boolean</type>)
+      <indexterm>
+        <primary><varname>log_backtrace</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        If this parameter is set to <literal>all</literal> then for all log
+        entries a backtrace is written to the server log together with the log
+        message. If this parameter is set to <literal>internal</literal> then
+        only such a backtrace is only written for logs with error code XX000
+        (internal error; see also <xref linkend="errcodes-appendix"/>).
+        This can be used to debug such internal errors (which should normally
+        not happen in production).  The default is <literal>none</literal>,
+        which means backtraces are never written to the server log.
+       </para>
+
+       <para>
+        The logs for which a backtrace is written can be further restricted
+        using <xref linkend="guc-backtrace-min-level"/> (default:
+        <literal>error</literal>) and <xref linkend="guc-backtrace-functions"/>
+        (default: empty string, meaning all).
+       </para>
+
+       <para>
+        Backtrace support is not available on all platforms, and the quality
+        of the backtraces depends on compilation options.
+       </para>
+
+       <para>
+        Only superusers and users with the appropriate <literal>SET</literal>
+        privilege can change this setting.
+       </para>
+      </listitem>
+     </varlistentry>
+
+
      <varlistentry id="guc-log-checkpoints" xreflabel="log_checkpoints">
       <term><varname>log_checkpoints</varname> (<type>boolean</type>)
       <indexterm>
@@ -11305,43 +11343,45 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </term>
       <listitem>
        <para>
-        This parameter contains a comma-separated list of C function names.
-        If an error is raised and the name of the internal C function where
-        the error happens matches a value in the list, then a backtrace is
-        written to the server log together with the error message.  This can
-        be used to debug specific areas of the source code.
-       </para>
-
-       <para>
-        Backtrace support is not available on all platforms, and the quality
-        of the backtraces depends on compilation options.
+        This parameter can contain a comma-separated list of C function names,
+        which can be used to filter for which logs a backtrace is written to
+        the server log.
+        If a log entry is raised and the name of the
+        internal C function where the error happens does not match any of the
+        values in the list, then no backtrace is written to the server log.
+        This can be used to only debug specific areas of the source code.
        </para>
 
        <para>
-        Only superusers and users with the appropriate <literal>SET</literal>
-        privilege can change this setting.
+        The empty string (the default) disables any such filtering. So for any
+        logs that match both <xref linkend="guc-log-backtrace"/> and
+        <xref linkend="guc-backtrace-min-level"/> a backtrace is
+        written to the server log.
        </para>
       </listitem>
      </varlistentry>
 
-     <varlistentry id="guc-backtrace-on-internal-error" xreflabel="backtrace_on_internal_error">
-      <term><varname>backtrace_on_internal_error</varname> (<type>boolean</type>)
+     <varlistentry id="guc-backtrace-min-level" xreflabel="backtrace_min_level">
+      <term><varname>backtrace_min_level</varname> (<type>string</type>)
       <indexterm>
-        <primary><varname>backtrace_on_internal_error</varname> configuration parameter</primary>
+        <primary><varname>backtrace_min_level</varname> configuration parameter</primary>
       </indexterm>
       </term>
       <listitem>
        <para>
-        If this parameter is on and an error with error code XX000 (internal
-        error; see also <xref linkend="errcodes-appendix"/>) is raised, then a
-        backtrace is written to the server log together with the error
-        message.  This can be used to debug such internal errors (which should
-        normally not happen in production).  The default is off.
-       </para>
-
-       <para>
-        Backtrace support is not available on all platforms, and the quality
-        of the backtraces depends on compilation options.
+        Controls which <link linkend="runtime-config-severity-levels">message
+        levels</link> cause backtraces to be written to the log, for log
+        messages that match both <xref linkend="guc-log-backtrace"/> and
+        <xref linkend="guc-backtrace-functions"/>.
+        Valid values are <literal>DEBUG5</literal>, <literal>DEBUG4</literal>,
+        <literal>DEBUG3</literal>, <literal>DEBUG2</literal>, <literal>DEBUG1</literal>,
+        <literal>LOG</literal>, <literal>INFO</literal>, <literal>NOTICE</literal>,
+        <literal>WARNING</literal>, <literal>ERROR</literal>, <literal>FATAL</literal>,
+        and <literal>PANIC</literal>.  Each level includes all the levels that
+        follow it.  The later the level, the fewer messages result in a
+        backtrace.  The default is <literal>ERROR</literal>.  Note that
+        <literal>LOG</literal> has a different rank here than in
+        <xref linkend="guc-log-min-messages"/>.
        </para>
 
        <para>
@@ -11351,6 +11391,7 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </listitem>
      </varlistentry>
 
+
      <varlistentry id="guc-debug-discard-caches" xreflabel="debug_discard_caches">
       <term><varname>debug_discard_caches</varname> (<type>integer</type>)
       <indexterm>
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index 52bc01058c5..8f6a107d285 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -111,6 +111,7 @@ int			Log_error_verbosity = PGERROR_DEFAULT;
 char	   *Log_line_prefix = NULL; /* format for extra log line info */
 int			Log_destination = LOG_DESTINATION_STDERR;
 char	   *Log_destination_string = NULL;
+int			log_backtrace = LOGBACKTRACE_NONE;
 bool		syslog_sequence_numbers = true;
 bool		syslog_split_messages = true;
 
@@ -181,6 +182,7 @@ static void set_stack_entry_domain(ErrorData *edata, const char *domain);
 static void set_stack_entry_location(ErrorData *edata,
 									 const char *filename, int lineno,
 									 const char *funcname);
+static bool matches_backtrace_gucs(ErrorData *edata);
 static bool matches_backtrace_functions(const char *funcname);
 static pg_noinline void set_backtrace(ErrorData *edata, int num_skip);
 static void set_errdata_field(MemoryContextData *cxt, char **ptr, const char *str);
@@ -496,12 +498,7 @@ errfinish(const char *filename, int lineno, const char *funcname)
 	oldcontext = MemoryContextSwitchTo(ErrorContext);
 
 	/* Collect backtrace, if enabled and we didn't already */
-	if (!edata->backtrace &&
-		((edata->funcname &&
-		  backtrace_functions &&
-		  matches_backtrace_functions(edata->funcname)) ||
-		 (edata->sqlerrcode == ERRCODE_INTERNAL_ERROR &&
-		  backtrace_on_internal_error)))
+	if (!edata->backtrace && matches_backtrace_gucs(edata))
 		set_backtrace(edata, 2);
 
 	/*
@@ -821,6 +818,26 @@ set_stack_entry_location(ErrorData *edata,
 	edata->funcname = funcname;
 }
 
+/*
+ * matches_backtrace_gucs --- checks whether the log entry matches
+ * log_backtrace, backtrace_min_level and backtrace_functions.
+ */
+static bool
+matches_backtrace_gucs(ErrorData *edata)
+{
+	if (log_backtrace == LOGBACKTRACE_NONE)
+		return false;
+
+	if (log_backtrace == LOGBACKTRACE_INTERNAL &&
+		edata->sqlerrcode != ERRCODE_INTERNAL_ERROR)
+		return false;
+
+	if (backtrace_min_level > edata->elevel)
+		return false;
+
+	return matches_backtrace_functions(edata->funcname);
+}
+
 /*
  * matches_backtrace_functions --- checks whether the given funcname matches
  * backtrace_functions
@@ -832,6 +849,9 @@ matches_backtrace_functions(const char *funcname)
 {
 	const char *p;
 
+	if (!backtrace_functions || backtrace_functions[0] == '\0')
+		return true;
+
 	if (!backtrace_function_list || funcname == NULL || funcname[0] == '\0')
 		return false;
 
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index 1e71e7db4a0..f6f4f0521e8 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -162,6 +162,23 @@ static const struct config_enum_entry server_message_level_options[] = {
 	{NULL, 0, false}
 };
 
+static const struct config_enum_entry backtrace_functions_level_options[] = {
+	{"debug5", DEBUG5, false},
+	{"debug4", DEBUG4, false},
+	{"debug3", DEBUG3, false},
+	{"debug2", DEBUG2, false},
+	{"debug1", DEBUG1, false},
+	{"debug", DEBUG2, true},
+	{"log", LOG, false},
+	{"info", INFO, true},
+	{"notice", NOTICE, false},
+	{"warning", WARNING, false},
+	{"error", ERROR, false},
+	{"fatal", FATAL, false},
+	{"panic", PANIC, false},
+	{NULL, 0, false}
+};
+
 static const struct config_enum_entry intervalstyle_options[] = {
 	{"postgres", INTSTYLE_POSTGRES, false},
 	{"postgres_verbose", INTSTYLE_POSTGRES_VERBOSE, false},
@@ -199,6 +216,16 @@ static const struct config_enum_entry log_error_verbosity_options[] = {
 StaticAssertDecl(lengthof(log_error_verbosity_options) == (PGERROR_VERBOSE + 2),
 				 "array length mismatch");
 
+static const struct config_enum_entry log_backtrace_options[] = {
+	{"none", LOGBACKTRACE_NONE, false},
+	{"internal", LOGBACKTRACE_INTERNAL, false},
+	{"all", LOGBACKTRACE_ALL, false},
+	{NULL, 0, false}
+};
+
+StaticAssertDecl(lengthof(log_backtrace_options) == (LOGBACKTRACE_ALL + 2),
+				 "array length mismatch");
+
 static const struct config_enum_entry log_statement_options[] = {
 	{"none", LOGSTMT_NONE, false},
 	{"ddl", LOGSTMT_DDL, false},
@@ -529,7 +556,7 @@ int			log_temp_files = -1;
 double		log_statement_sample_rate = 1.0;
 double		log_xact_sample_rate = 0;
 char	   *backtrace_functions;
-bool		backtrace_on_internal_error = false;
+int			backtrace_min_level = ERROR;
 
 int			temp_file_limit = -1;
 
@@ -768,16 +795,6 @@ StaticAssertDecl(lengthof(config_type_names) == (PGC_ENUM + 1),
 
 struct config_bool ConfigureNamesBool[] =
 {
-	{
-		{"backtrace_on_internal_error", PGC_SUSET, DEVELOPER_OPTIONS,
-			gettext_noop("Log backtrace for any error with error code XX000 (internal error)."),
-			NULL,
-			GUC_NOT_IN_SAMPLE
-		},
-		&backtrace_on_internal_error,
-		false,
-		NULL, NULL, NULL
-	},
 	{
 		{"enable_seqscan", PGC_USERSET, QUERY_TUNING_METHOD,
 			gettext_noop("Enables the planner's use of sequential-scan plans."),
@@ -4703,6 +4720,18 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"backtrace_min_level", PGC_SUSET, DEVELOPER_OPTIONS,
+			gettext_noop("Sets the message levels that create backtraces when log_backtrace is configured."),
+			gettext_noop("Each level includes all the levels that follow it. The later"
+						 " the level, the fewer backtraces are created."),
+			GUC_NOT_IN_SAMPLE
+		},
+		&backtrace_min_level,
+		ERROR, backtrace_functions_level_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
 			gettext_noop("Sets the output format for bytea."),
@@ -4799,6 +4828,16 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"log_backtrace", PGC_SUSET, LOGGING_WHAT,
+			gettext_noop("Sets if logs should include a backtrace."),
+			NULL
+		},
+		&log_backtrace,
+		LOGBACKTRACE_NONE, log_backtrace_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"log_error_verbosity", PGC_SUSET, LOGGING_WHAT,
 			gettext_noop("Sets the verbosity of logged messages."),
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index 2244ee52f79..46d21df6b60 100644
--- a/src/backend/utils/misc/postgresql.conf.sample
+++ b/src/backend/utils/misc/postgresql.conf.sample
@@ -574,6 +574,7 @@
 					# their durations, > 0 logs only
 					# actions running at least this number
 					# of milliseconds.
+#log_backtrace = 'none'
 #log_checkpoints = on
 #log_connections = off
 #log_disconnections = off
diff --git a/src/include/utils/elog.h b/src/include/utils/elog.h
index da1a7469fa5..6370f23f27d 100644
--- a/src/include/utils/elog.h
+++ b/src/include/utils/elog.h
@@ -495,9 +495,17 @@ typedef enum
 	PGERROR_VERBOSE,			/* all the facts, ma'am */
 } PGErrorVerbosity;
 
+typedef enum
+{
+	LOGBACKTRACE_NONE,			/* no backtrace */
+	LOGBACKTRACE_INTERNAL,		/* backtrace for internal error code */
+	LOGBACKTRACE_ALL,			/* backtrace for all logs */
+} LogBacktraceVerbosity;
+
 extern PGDLLIMPORT int Log_error_verbosity;
 extern PGDLLIMPORT char *Log_line_prefix;
 extern PGDLLIMPORT int Log_destination;
+extern PGDLLIMPORT int log_backtrace;
 extern PGDLLIMPORT char *Log_destination_string;
 extern PGDLLIMPORT bool syslog_sequence_numbers;
 extern PGDLLIMPORT bool syslog_split_messages;
diff --git a/src/include/utils/guc.h b/src/include/utils/guc.h
index 3712aba09b0..2398ab7d730 100644
--- a/src/include/utils/guc.h
+++ b/src/include/utils/guc.h
@@ -266,7 +266,7 @@ extern PGDLLIMPORT int log_temp_files;
 extern PGDLLIMPORT double log_statement_sample_rate;
 extern PGDLLIMPORT double log_xact_sample_rate;
 extern PGDLLIMPORT char *backtrace_functions;
-extern PGDLLIMPORT bool backtrace_on_internal_error;
+extern PGDLLIMPORT int backtrace_min_level;
 
 extern PGDLLIMPORT int temp_file_limit;
 
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 13048910e46..0123e347890 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -1489,6 +1489,7 @@ LockTupleMode
 LockViewRecurse_context
 LockWaitPolicy
 LockingClause
+LogBacktraceVerbosity
 LogOpts
 LogStmtLevel
 LogicalDecodeBeginCB
-- 
2.34.1

From 287accb62c25a960294d6054a1a97777a3625bdd Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Tue, 27 Feb 2024 17:31:24 +0100
Subject: [PATCH v9 2/3] Restructure backtrace related GUCs

Our GUCs that controlled backtraces were added a bit ad-hoc. This
restructures them in a more complete and more easily extendable design:

1. Replaces the `backtrace_on_internal_error` GUC with a `log_backtrace`
   one, which can be set to `internal` and `none` to match the previous
   behaviour of the `on` and `off` values of
   `backtrace_on_internal_error`. But it can also be set to `all`
2. Make `backtrace_functions` behave as an additional filter on top of
   `log_backtrace`. The empty string (the default) is now interpreted as
   doing no filtering based on function name.
3. Add a `backtrace_min_level` GUC, which limits for which log entries
   backtraces are written, based on their log level. This defaults to
   ERROR.

Being able to log backtraces for all ERROR logs was the trigger for this
redesign of the backtrace GUCs. This is now possible by simply setting
log_backtrace to "all".
---
 doc/src/sgml/config.sgml                      | 92 ++++++++++++++-----
 src/backend/utils/error/elog.c                | 32 +++++--
 src/backend/utils/misc/guc_tables.c           | 61 +++++++++---
 src/backend/utils/misc/postgresql.conf.sample |  1 +
 src/include/utils/elog.h                      |  8 ++
 src/include/utils/guc.h                       |  2 +-
 src/tools/pgindent/typedefs.list              |  1 +
 7 files changed, 154 insertions(+), 43 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 65a6e6c4086..b315c84ce98 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -7270,6 +7270,45 @@ local0.*    /var/log/postgresql
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-log-backtrace" xreflabel="backtrace_on_internal_error">
+      <term><varname>log_backtrace</varname> (<type>boolean</type>)
+      <indexterm>
+        <primary><varname>log_backtrace</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        If this parameter is set to <literal>all</literal> then for all log
+        entries a backtrace is written to the server log together with the log
+        message. If this parameter is set to <literal>internal</literal> then
+        such a backtrace is only written for logs with error code XX000
+        (internal error; see also <xref linkend="errcodes-appendix"/>).
+        This can be used to debug such internal errors (which should normally
+        not happen in production). Finally, if this parameter is set to
+        <literal>none</literal> (the default), no backtraces are ever written
+        to the server log.
+       </para>
+
+       <para>
+        The logs for which a backtrace is written can be further restricted
+        using <xref linkend="guc-backtrace-min-level"/> (default:
+        <literal>error</literal>) and <xref linkend="guc-backtrace-functions"/>
+        (default: empty string, meaning all).
+       </para>
+
+       <para>
+        Backtrace support is not available on all platforms, and the quality
+        of the backtraces depends on compilation options.
+       </para>
+
+       <para>
+        Only superusers and users with the appropriate <literal>SET</literal>
+        privilege can change this setting.
+       </para>
+      </listitem>
+     </varlistentry>
+
+
      <varlistentry id="guc-log-checkpoints" xreflabel="log_checkpoints">
       <term><varname>log_checkpoints</varname> (<type>boolean</type>)
       <indexterm>
@@ -11305,43 +11344,45 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </term>
       <listitem>
        <para>
-        This parameter contains a comma-separated list of C function names.
-        If an error is raised and the name of the internal C function where
-        the error happens matches a value in the list, then a backtrace is
-        written to the server log together with the error message.  This can
-        be used to debug specific areas of the source code.
-       </para>
-
-       <para>
-        Backtrace support is not available on all platforms, and the quality
-        of the backtraces depends on compilation options.
+        This parameter can contain a comma-separated list of C function names,
+        which can be used to filter for which logs a backtrace is written to
+        the server log.
+        If a log entry is raised and the name of the
+        internal C function where the error happens does not match any of the
+        values in the list, then no backtrace is written to the server log.
+        This can be used to only debug specific areas of the source code.
        </para>
 
        <para>
-        Only superusers and users with the appropriate <literal>SET</literal>
-        privilege can change this setting.
+        The empty string (the default) disables any such filtering. So for any
+        logs that match both <xref linkend="guc-log-backtrace"/> and
+        <xref linkend="guc-backtrace-min-level"/> a backtrace is
+        written to the server log.
        </para>
       </listitem>
      </varlistentry>
 
-     <varlistentry id="guc-backtrace-on-internal-error" xreflabel="backtrace_on_internal_error">
-      <term><varname>backtrace_on_internal_error</varname> (<type>boolean</type>)
+     <varlistentry id="guc-backtrace-min-level" xreflabel="backtrace_min_level">
+      <term><varname>backtrace_min_level</varname> (<type>string</type>)
       <indexterm>
-        <primary><varname>backtrace_on_internal_error</varname> configuration parameter</primary>
+        <primary><varname>backtrace_min_level</varname> configuration parameter</primary>
       </indexterm>
       </term>
       <listitem>
        <para>
-        If this parameter is on and an error with error code XX000 (internal
-        error; see also <xref linkend="errcodes-appendix"/>) is raised, then a
-        backtrace is written to the server log together with the error
-        message.  This can be used to debug such internal errors (which should
-        normally not happen in production).  The default is off.
-       </para>
-
-       <para>
-        Backtrace support is not available on all platforms, and the quality
-        of the backtraces depends on compilation options.
+        Controls which <link linkend="runtime-config-severity-levels">message
+        levels</link> cause backtraces to be written to the log, for log
+        messages that match both <xref linkend="guc-log-backtrace"/> and
+        <xref linkend="guc-backtrace-functions"/>.
+        Valid values are <literal>DEBUG5</literal>, <literal>DEBUG4</literal>,
+        <literal>DEBUG3</literal>, <literal>DEBUG2</literal>, <literal>DEBUG1</literal>,
+        <literal>LOG</literal>, <literal>INFO</literal>, <literal>NOTICE</literal>,
+        <literal>WARNING</literal>, <literal>ERROR</literal>, <literal>FATAL</literal>,
+        and <literal>PANIC</literal>.  Each level includes all the levels that
+        follow it.  The later the level, the fewer messages result in a
+        backtrace.  The default is <literal>ERROR</literal>.  Note that
+        <literal>LOG</literal> has a different rank here than in
+        <xref linkend="guc-log-min-messages"/>.
        </para>
 
        <para>
@@ -11351,6 +11392,7 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </listitem>
      </varlistentry>
 
+
      <varlistentry id="guc-debug-discard-caches" xreflabel="debug_discard_caches">
       <term><varname>debug_discard_caches</varname> (<type>integer</type>)
       <indexterm>
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index 52bc01058c5..8f6a107d285 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -111,6 +111,7 @@ int			Log_error_verbosity = PGERROR_DEFAULT;
 char	   *Log_line_prefix = NULL; /* format for extra log line info */
 int			Log_destination = LOG_DESTINATION_STDERR;
 char	   *Log_destination_string = NULL;
+int			log_backtrace = LOGBACKTRACE_NONE;
 bool		syslog_sequence_numbers = true;
 bool		syslog_split_messages = true;
 
@@ -181,6 +182,7 @@ static void set_stack_entry_domain(ErrorData *edata, const char *domain);
 static void set_stack_entry_location(ErrorData *edata,
 									 const char *filename, int lineno,
 									 const char *funcname);
+static bool matches_backtrace_gucs(ErrorData *edata);
 static bool matches_backtrace_functions(const char *funcname);
 static pg_noinline void set_backtrace(ErrorData *edata, int num_skip);
 static void set_errdata_field(MemoryContextData *cxt, char **ptr, const char *str);
@@ -496,12 +498,7 @@ errfinish(const char *filename, int lineno, const char *funcname)
 	oldcontext = MemoryContextSwitchTo(ErrorContext);
 
 	/* Collect backtrace, if enabled and we didn't already */
-	if (!edata->backtrace &&
-		((edata->funcname &&
-		  backtrace_functions &&
-		  matches_backtrace_functions(edata->funcname)) ||
-		 (edata->sqlerrcode == ERRCODE_INTERNAL_ERROR &&
-		  backtrace_on_internal_error)))
+	if (!edata->backtrace && matches_backtrace_gucs(edata))
 		set_backtrace(edata, 2);
 
 	/*
@@ -821,6 +818,26 @@ set_stack_entry_location(ErrorData *edata,
 	edata->funcname = funcname;
 }
 
+/*
+ * matches_backtrace_gucs --- checks whether the log entry matches
+ * log_backtrace, backtrace_min_level and backtrace_functions.
+ */
+static bool
+matches_backtrace_gucs(ErrorData *edata)
+{
+	if (log_backtrace == LOGBACKTRACE_NONE)
+		return false;
+
+	if (log_backtrace == LOGBACKTRACE_INTERNAL &&
+		edata->sqlerrcode != ERRCODE_INTERNAL_ERROR)
+		return false;
+
+	if (backtrace_min_level > edata->elevel)
+		return false;
+
+	return matches_backtrace_functions(edata->funcname);
+}
+
 /*
  * matches_backtrace_functions --- checks whether the given funcname matches
  * backtrace_functions
@@ -832,6 +849,9 @@ matches_backtrace_functions(const char *funcname)
 {
 	const char *p;
 
+	if (!backtrace_functions || backtrace_functions[0] == '\0')
+		return true;
+
 	if (!backtrace_function_list || funcname == NULL || funcname[0] == '\0')
 		return false;
 
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index 1e71e7db4a0..f6f4f0521e8 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -162,6 +162,23 @@ static const struct config_enum_entry server_message_level_options[] = {
 	{NULL, 0, false}
 };
 
+static const struct config_enum_entry backtrace_functions_level_options[] = {
+	{"debug5", DEBUG5, false},
+	{"debug4", DEBUG4, false},
+	{"debug3", DEBUG3, false},
+	{"debug2", DEBUG2, false},
+	{"debug1", DEBUG1, false},
+	{"debug", DEBUG2, true},
+	{"log", LOG, false},
+	{"info", INFO, true},
+	{"notice", NOTICE, false},
+	{"warning", WARNING, false},
+	{"error", ERROR, false},
+	{"fatal", FATAL, false},
+	{"panic", PANIC, false},
+	{NULL, 0, false}
+};
+
 static const struct config_enum_entry intervalstyle_options[] = {
 	{"postgres", INTSTYLE_POSTGRES, false},
 	{"postgres_verbose", INTSTYLE_POSTGRES_VERBOSE, false},
@@ -199,6 +216,16 @@ static const struct config_enum_entry log_error_verbosity_options[] = {
 StaticAssertDecl(lengthof(log_error_verbosity_options) == (PGERROR_VERBOSE + 2),
 				 "array length mismatch");
 
+static const struct config_enum_entry log_backtrace_options[] = {
+	{"none", LOGBACKTRACE_NONE, false},
+	{"internal", LOGBACKTRACE_INTERNAL, false},
+	{"all", LOGBACKTRACE_ALL, false},
+	{NULL, 0, false}
+};
+
+StaticAssertDecl(lengthof(log_backtrace_options) == (LOGBACKTRACE_ALL + 2),
+				 "array length mismatch");
+
 static const struct config_enum_entry log_statement_options[] = {
 	{"none", LOGSTMT_NONE, false},
 	{"ddl", LOGSTMT_DDL, false},
@@ -529,7 +556,7 @@ int			log_temp_files = -1;
 double		log_statement_sample_rate = 1.0;
 double		log_xact_sample_rate = 0;
 char	   *backtrace_functions;
-bool		backtrace_on_internal_error = false;
+int			backtrace_min_level = ERROR;
 
 int			temp_file_limit = -1;
 
@@ -768,16 +795,6 @@ StaticAssertDecl(lengthof(config_type_names) == (PGC_ENUM + 1),
 
 struct config_bool ConfigureNamesBool[] =
 {
-	{
-		{"backtrace_on_internal_error", PGC_SUSET, DEVELOPER_OPTIONS,
-			gettext_noop("Log backtrace for any error with error code XX000 (internal error)."),
-			NULL,
-			GUC_NOT_IN_SAMPLE
-		},
-		&backtrace_on_internal_error,
-		false,
-		NULL, NULL, NULL
-	},
 	{
 		{"enable_seqscan", PGC_USERSET, QUERY_TUNING_METHOD,
 			gettext_noop("Enables the planner's use of sequential-scan plans."),
@@ -4703,6 +4720,18 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"backtrace_min_level", PGC_SUSET, DEVELOPER_OPTIONS,
+			gettext_noop("Sets the message levels that create backtraces when log_backtrace is configured."),
+			gettext_noop("Each level includes all the levels that follow it. The later"
+						 " the level, the fewer backtraces are created."),
+			GUC_NOT_IN_SAMPLE
+		},
+		&backtrace_min_level,
+		ERROR, backtrace_functions_level_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
 			gettext_noop("Sets the output format for bytea."),
@@ -4799,6 +4828,16 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"log_backtrace", PGC_SUSET, LOGGING_WHAT,
+			gettext_noop("Sets if logs should include a backtrace."),
+			NULL
+		},
+		&log_backtrace,
+		LOGBACKTRACE_NONE, log_backtrace_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"log_error_verbosity", PGC_SUSET, LOGGING_WHAT,
 			gettext_noop("Sets the verbosity of logged messages."),
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index 2244ee52f79..46d21df6b60 100644
--- a/src/backend/utils/misc/postgresql.conf.sample
+++ b/src/backend/utils/misc/postgresql.conf.sample
@@ -574,6 +574,7 @@
 					# their durations, > 0 logs only
 					# actions running at least this number
 					# of milliseconds.
+#log_backtrace = 'none'
 #log_checkpoints = on
 #log_connections = off
 #log_disconnections = off
diff --git a/src/include/utils/elog.h b/src/include/utils/elog.h
index da1a7469fa5..6370f23f27d 100644
--- a/src/include/utils/elog.h
+++ b/src/include/utils/elog.h
@@ -495,9 +495,17 @@ typedef enum
 	PGERROR_VERBOSE,			/* all the facts, ma'am */
 } PGErrorVerbosity;
 
+typedef enum
+{
+	LOGBACKTRACE_NONE,			/* no backtrace */
+	LOGBACKTRACE_INTERNAL,		/* backtrace for internal error code */
+	LOGBACKTRACE_ALL,			/* backtrace for all logs */
+} LogBacktraceVerbosity;
+
 extern PGDLLIMPORT int Log_error_verbosity;
 extern PGDLLIMPORT char *Log_line_prefix;
 extern PGDLLIMPORT int Log_destination;
+extern PGDLLIMPORT int log_backtrace;
 extern PGDLLIMPORT char *Log_destination_string;
 extern PGDLLIMPORT bool syslog_sequence_numbers;
 extern PGDLLIMPORT bool syslog_split_messages;
diff --git a/src/include/utils/guc.h b/src/include/utils/guc.h
index 3712aba09b0..2398ab7d730 100644
--- a/src/include/utils/guc.h
+++ b/src/include/utils/guc.h
@@ -266,7 +266,7 @@ extern PGDLLIMPORT int log_temp_files;
 extern PGDLLIMPORT double log_statement_sample_rate;
 extern PGDLLIMPORT double log_xact_sample_rate;
 extern PGDLLIMPORT char *backtrace_functions;
-extern PGDLLIMPORT bool backtrace_on_internal_error;
+extern PGDLLIMPORT int backtrace_min_level;
 
 extern PGDLLIMPORT int temp_file_limit;
 
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index a2e6d4fdc6a..a6b1d9f11e7 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -1489,6 +1489,7 @@ LockTupleMode
 LockViewRecurse_context
 LockWaitPolicy
 LockingClause
+LogBacktraceVerbosity
 LogOpts
 LogStmtLevel
 LogicalDecodeBeginCB
-- 
2.34.1

From 8a9c67c8c60afff7341f5fa8dfc99d795b393dd3 Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Thu, 21 Mar 2024 13:05:35 +0100
Subject: [PATCH v9 1/3] Add PGErrorVerbosity to typedefs.list

This one was missing, resulting in some strange alignment.
---
 src/include/utils/elog.h         | 2 +-
 src/tools/pgindent/typedefs.list | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/include/utils/elog.h b/src/include/utils/elog.h
index 054dd2bf62f..da1a7469fa5 100644
--- a/src/include/utils/elog.h
+++ b/src/include/utils/elog.h
@@ -493,7 +493,7 @@ typedef enum
 	PGERROR_TERSE,				/* single-line error messages */
 	PGERROR_DEFAULT,			/* recommended style */
 	PGERROR_VERBOSE,			/* all the facts, ma'am */
-}			PGErrorVerbosity;
+} PGErrorVerbosity;
 
 extern PGDLLIMPORT int Log_error_verbosity;
 extern PGDLLIMPORT char *Log_line_prefix;
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index e2a0525dd4a..a2e6d4fdc6a 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -1737,6 +1737,7 @@ PGAsyncStatusType
 PGCALL2
 PGChecksummablePage
 PGContextVisibility
+PGErrorVerbosity
 PGEvent
 PGEventConnDestroy
 PGEventConnReset

base-commit: b4080fa3dcf6c6359e542169e0e81a0662c53ba8
-- 
2.34.1

From 71a31fc3ec25590f6a799118a923ab6366a37ad0 Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Fri, 22 Mar 2024 10:58:53 +0100
Subject: [PATCH v9 3/3] Change log_backtrace default to "internal"

Internal errors should not happen in production. When they do it is
likely a bug and it can be very useful to have a backtrace when trying
to determine it's exact cause. This changes the default for
log_backtrace to "internal" so that the bug reports we receive are much
more likely to include such a backtrace.
---
 doc/src/sgml/config.sgml            | 4 ++--
 src/backend/utils/error/elog.c      | 2 +-
 src/backend/utils/misc/guc_tables.c | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index b315c84ce98..223442afbe5 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -7280,12 +7280,12 @@ local0.*    /var/log/postgresql
        <para>
         If this parameter is set to <literal>all</literal> then for all log
         entries a backtrace is written to the server log together with the log
-        message. If this parameter is set to <literal>internal</literal> then
+        message. If this parameter is set to <literal>internal</literal> (the default) then
         such a backtrace is only written for logs with error code XX000
         (internal error; see also <xref linkend="errcodes-appendix"/>).
         This can be used to debug such internal errors (which should normally
         not happen in production). Finally, if this parameter is set to
-        <literal>none</literal> (the default), no backtraces are ever written
+        <literal>none</literal>, no backtraces are ever written
         to the server log.
        </para>
 
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index 8f6a107d285..c199538e270 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -111,7 +111,7 @@ int			Log_error_verbosity = PGERROR_DEFAULT;
 char	   *Log_line_prefix = NULL; /* format for extra log line info */
 int			Log_destination = LOG_DESTINATION_STDERR;
 char	   *Log_destination_string = NULL;
-int			log_backtrace = LOGBACKTRACE_NONE;
+int			log_backtrace = LOGBACKTRACE_INTERNAL;
 bool		syslog_sequence_numbers = true;
 bool		syslog_split_messages = true;
 
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index f6f4f0521e8..f2a79a0980a 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -4834,7 +4834,7 @@ struct config_enum ConfigureNamesEnum[] =
 			NULL
 		},
 		&log_backtrace,
-		LOGBACKTRACE_NONE, log_backtrace_options,
+		LOGBACKTRACE_INTERNAL, log_backtrace_options,
 		NULL, NULL, NULL
 	},
 
-- 
2.34.1

From 348c3d45ddf4c29163c6963cb640c372fdbe72d5 Mon Sep 17 00:00:00 2001
From: Michael Paquier <michael@paquier.xyz>
Date: Thu, 18 Apr 2024 15:57:10 +0900
Subject: [PATCH] backtrace_on_internal_error -> backtrace_mode

This currently supports two values:
- "none", to log no backtraces.
- "internal", to log a backtrace with an internal error.
---
 src/include/utils/elog.h            |  6 ++++++
 src/include/utils/guc.h             |  2 +-
 src/backend/utils/error/elog.c      |  2 +-
 src/backend/utils/misc/guc_tables.c | 33 +++++++++++++++++++----------
 doc/src/sgml/config.sgml            | 19 ++++++++++-------
 src/tools/pgindent/typedefs.list    |  1 +
 6 files changed, 42 insertions(+), 21 deletions(-)

diff --git a/src/include/utils/elog.h b/src/include/utils/elog.h
index 054dd2bf62..b132f89e98 100644
--- a/src/include/utils/elog.h
+++ b/src/include/utils/elog.h
@@ -495,6 +495,12 @@ typedef enum
 	PGERROR_VERBOSE,			/* all the facts, ma'am */
 }			PGErrorVerbosity;
 
+typedef enum
+{
+	BACKTRACE_MODE_NONE,		/* no backtraces */
+	BACKTRACE_MODE_INTERNAL,	/* backtraces for internal error code */
+} BacktraceMode;
+
 extern PGDLLIMPORT int Log_error_verbosity;
 extern PGDLLIMPORT char *Log_line_prefix;
 extern PGDLLIMPORT int Log_destination;
diff --git a/src/include/utils/guc.h b/src/include/utils/guc.h
index 8d1fe04078..53dd28222a 100644
--- a/src/include/utils/guc.h
+++ b/src/include/utils/guc.h
@@ -267,7 +267,7 @@ extern PGDLLIMPORT int log_temp_files;
 extern PGDLLIMPORT double log_statement_sample_rate;
 extern PGDLLIMPORT double log_xact_sample_rate;
 extern PGDLLIMPORT char *backtrace_functions;
-extern PGDLLIMPORT bool backtrace_on_internal_error;
+extern PGDLLIMPORT int backtrace_mode;
 
 extern PGDLLIMPORT int temp_file_limit;
 
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index 605ff3b045..1c108b86ec 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -501,7 +501,7 @@ errfinish(const char *filename, int lineno, const char *funcname)
 		  backtrace_functions &&
 		  matches_backtrace_functions(edata->funcname)) ||
 		 (edata->sqlerrcode == ERRCODE_INTERNAL_ERROR &&
-		  backtrace_on_internal_error)))
+		  backtrace_mode == BACKTRACE_MODE_INTERNAL)))
 		set_backtrace(edata, 2);
 
 	/*
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index c68fdc008b..d5a9f3b73e 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -79,6 +79,7 @@
 #include "tsearch/ts_cache.h"
 #include "utils/builtins.h"
 #include "utils/bytea.h"
+#include "utils/elog.h"
 #include "utils/float.h"
 #include "utils/guc_hooks.h"
 #include "utils/guc_tables.h"
@@ -117,6 +118,15 @@ extern bool optimize_bounded_sort;
  * NOTE! Option values may not contain double quotes!
  */
 
+static const struct config_enum_entry backtrace_mode_options[] = {
+	{"none", BACKTRACE_MODE_NONE, false},
+	{"internal", BACKTRACE_MODE_INTERNAL, false},
+	{NULL, 0, false}
+};
+
+StaticAssertDecl(lengthof(backtrace_mode_options) == (BACKTRACE_MODE_INTERNAL + 2),
+				 "array length mismatch");
+
 static const struct config_enum_entry bytea_output_options[] = {
 	{"escape", BYTEA_OUTPUT_ESCAPE, false},
 	{"hex", BYTEA_OUTPUT_HEX, false},
@@ -531,7 +541,7 @@ int			log_temp_files = -1;
 double		log_statement_sample_rate = 1.0;
 double		log_xact_sample_rate = 0;
 char	   *backtrace_functions;
-bool		backtrace_on_internal_error = false;
+int			backtrace_mode = BACKTRACE_MODE_NONE;
 
 int			temp_file_limit = -1;
 
@@ -770,16 +780,6 @@ StaticAssertDecl(lengthof(config_type_names) == (PGC_ENUM + 1),
 
 struct config_bool ConfigureNamesBool[] =
 {
-	{
-		{"backtrace_on_internal_error", PGC_SUSET, DEVELOPER_OPTIONS,
-			gettext_noop("Log backtrace for any error with error code XX000 (internal error)."),
-			NULL,
-			GUC_NOT_IN_SAMPLE
-		},
-		&backtrace_on_internal_error,
-		false,
-		NULL, NULL, NULL
-	},
 	{
 		{"enable_seqscan", PGC_USERSET, QUERY_TUNING_METHOD,
 			gettext_noop("Enables the planner's use of sequential-scan plans."),
@@ -4745,6 +4745,17 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"backtrace_mode", PGC_SUSET, DEVELOPER_OPTIONS,
+			gettext_noop("Controls backtrace logging."),
+			NULL,
+			GUC_NOT_IN_SAMPLE
+		},
+		&backtrace_mode,
+		BACKTRACE_MODE_NONE, backtrace_mode_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
 			gettext_noop("Sets the output format for bytea."),
diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index d8e1282e12..b9a317b15d 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -11381,19 +11381,22 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </listitem>
      </varlistentry>
 
-     <varlistentry id="guc-backtrace-on-internal-error" xreflabel="backtrace_on_internal_error">
-      <term><varname>backtrace_on_internal_error</varname> (<type>boolean</type>)
+     <varlistentry id="guc-backtrace-mode" xreflabel="backtrace_mode">
+      <term><varname>backtrace_mode</varname> (<type>enum</type>)
       <indexterm>
-        <primary><varname>backtrace_on_internal_error</varname> configuration parameter</primary>
+        <primary><varname>backtrace_mode</varname> configuration parameter</primary>
       </indexterm>
       </term>
       <listitem>
        <para>
-        If this parameter is on and an error with error code XX000 (internal
-        error; see also <xref linkend="errcodes-appendix"/>) is raised, then a
-        backtrace is written to the server log together with the error
-        message.  This can be used to debug such internal errors (which should
-        normally not happen in production).  The default is off.
+        Controls how backtraces should be logged.
+        If this parameter is <literal>internal</literal> and an error
+        with error code XX000 (internal error; see also
+        <xref linkend="errcodes-appendix"/>) is raised, then a backtrace
+        is written to the server log together with the error message.
+        This can be used to debug such internal errors (which should
+        normally not happen in production).  The default is
+        <literal>none</literal>, to not log backtraces.
        </para>
 
        <para>
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index d551ada325..6119a5afb3 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -240,6 +240,7 @@ BackgroundWorker
 BackgroundWorkerArray
 BackgroundWorkerHandle
 BackgroundWorkerSlot
+BacktraceMode
 BackupState
 Barrier
 BaseBackupCmd
-- 
2.43.0

From 85a894cc32381a4ff2a1c7aab31476b2bbf6bdf3 Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Thu, 21 Mar 2024 13:05:35 +0100
Subject: [PATCH 1/2] Add PGErrorVerbosity to typedefs.list

This one was missing, resulting in some strange alignment.
---
 src/include/utils/elog.h         | 2 +-
 src/tools/pgindent/typedefs.list | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/include/utils/elog.h b/src/include/utils/elog.h
index 054dd2bf62f..da1a7469fa5 100644
--- a/src/include/utils/elog.h
+++ b/src/include/utils/elog.h
@@ -493,7 +493,7 @@ typedef enum
 	PGERROR_TERSE,				/* single-line error messages */
 	PGERROR_DEFAULT,			/* recommended style */
 	PGERROR_VERBOSE,			/* all the facts, ma'am */
-}			PGErrorVerbosity;
+} PGErrorVerbosity;
 
 extern PGDLLIMPORT int Log_error_verbosity;
 extern PGDLLIMPORT char *Log_line_prefix;
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 61ad417cde6..67ec5408a98 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -1778,6 +1778,7 @@ PGAsyncStatusType
 PGCALL2
 PGChecksummablePage
 PGContextVisibility
+PGErrorVerbosity
 PGEvent
 PGEventConnDestroy
 PGEventConnReset

base-commit: 3e53492aa7084bceaa92757c90e067d79768797e
-- 
2.34.1

From 9a1256aa3e4f585e3f588122662050f2302585dc Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Thu, 27 Jun 2024 10:56:10 +0200
Subject: [PATCH 2/2] Allow logging backtraces in more cases

We previously only had the backtrace_functions GUC to control when
backtraces were logged. Based on mailinglist discussion there were two
common cases that people wanted backtraces that were not covered by this
GUC though:

1. Logging backtraces for all internal errors
2. Logging backtraces for all errors

To support those two usecases, as well as to allow users to continue to
log backtraces for specific warnings using `backtrace_functions`, this
modifies the GUCs in the following way:

1. Adds a `log_backtrace` GUC, which can be set to `none` (default),
   `internal_error` and `all` to log different types of backtraces.
2. Change `backtrace_functions` to behave as an additional filter on top
   of `log_backtrace`. The empty string (the default) is now interpreted
   as doing no filtering based on function name.
3. Add a `backtrace_min_level` GUC, which limits for which log entries
   backtraces are written, based on their log level. This defaults to
   ERROR.

This does mean that setting `backtrace_functions=some_func` alone is not
enough to get backtraces for some_func. You now need to combine that
with `log_backtrace_mode=all` and if you want to get backtraces for
non-errors (which you previously got), you also need to change
backtrace_min_level to whichever level you want backtraces for.
---
 doc/src/sgml/config.sgml                      | 82 +++++++++++++++++--
 src/backend/utils/error/elog.c                | 30 ++++++-
 src/backend/utils/misc/guc_tables.c           | 50 +++++++++++
 src/backend/utils/misc/postgresql.conf.sample |  1 +
 src/include/utils/elog.h                      |  8 ++
 src/include/utils/guc.h                       |  1 +
 src/tools/pgindent/typedefs.list              |  1 +
 7 files changed, 162 insertions(+), 11 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 0c7a9082c54..ff2222ef79c 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -7283,6 +7283,44 @@ local0.*    /var/log/postgresql
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-log-backtrace-mode" xreflabel="log_backtrace_mode">
+      <term><varname>log_backtrace_mode</varname> (<type>boolean</type>)
+      <indexterm>
+        <primary><varname>log_backtrace_mode</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        If this parameter is set to <literal>all</literal> then for all log
+        entries a backtrace is written to the server log together with the log
+        message. If this parameter is set to <literal>internal_error</literal> then
+        such a backtrace is only written for logs with error code XX000
+        (internal error; see also <xref linkend="errcodes-appendix"/>).
+        This can be used to debug such internal errors (which should normally
+        not happen in production). Finally, if this parameter is set to
+        <literal>none</literal> (the default), no backtraces are ever written
+        to the server log.
+       </para>
+
+       <para>
+        The logs for which a backtrace is written can be further restricted
+        using <xref linkend="guc-backtrace-min-level"/> (default:
+        <literal>ERROR</literal>) and <xref linkend="guc-backtrace-functions"/>
+        (default: empty string, meaning all).
+       </para>
+
+       <para>
+        Backtrace support is not available on all platforms, and the quality
+        of the backtraces depends on compilation options.
+       </para>
+
+       <para>
+        Only superusers and users with the appropriate <literal>SET</literal>
+        privilege can change this setting.
+       </para>
+      </listitem>
+     </varlistentry>
+
      <varlistentry id="guc-log-checkpoints" xreflabel="log_checkpoints">
       <term><varname>log_checkpoints</varname> (<type>boolean</type>)
       <indexterm>
@@ -11372,16 +11410,45 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </term>
       <listitem>
        <para>
-        This parameter contains a comma-separated list of C function names.
-        If an error is raised and the name of the internal C function where
-        the error happens matches a value in the list, then a backtrace is
-        written to the server log together with the error message.  This can
-        be used to debug specific areas of the source code.
+        This parameter can contain a comma-separated list of C function names,
+        which can be used to filter for which logs a backtrace is written to
+        the server log.
+        If a log entry is raised and the name of the
+        internal C function where the error happens does not match any of the
+        values in the list, then no backtrace is written to the server log.
+        This can be used to only debug specific areas of the source code.
        </para>
 
        <para>
-        Backtrace support is not available on all platforms, and the quality
-        of the backtraces depends on compilation options.
+        The empty string (the default) disables any such filtering. So for any
+        logs that match both <xref linkend="guc-log-backtrace-mode"/> and
+        <xref linkend="guc-backtrace-min-level"/> a backtrace is
+        written to the server log.
+       </para>
+      </listitem>
+     </varlistentry>
+
+     <varlistentry id="guc-backtrace-min-level" xreflabel="backtrace_min_level">
+      <term><varname>backtrace_min_level</varname> (<type>string</type>)
+      <indexterm>
+        <primary><varname>backtrace_min_level</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        Controls which <link linkend="runtime-config-severity-levels">message
+        levels</link> cause backtraces to be written to the log, for log
+        messages that match both <xref linkend="guc-log-backtrace-mode"/> and
+        <xref linkend="guc-backtrace-functions"/>.
+        Valid values are <literal>DEBUG5</literal>, <literal>DEBUG4</literal>,
+        <literal>DEBUG3</literal>, <literal>DEBUG2</literal>, <literal>DEBUG1</literal>,
+        <literal>LOG</literal>, <literal>INFO</literal>, <literal>NOTICE</literal>,
+        <literal>WARNING</literal>, <literal>ERROR</literal>, <literal>FATAL</literal>,
+        and <literal>PANIC</literal>.  Each level includes all the levels that
+        follow it.  The later the level, the fewer messages result in a
+        backtrace.  The default is <literal>ERROR</literal>.  Note that
+        <literal>LOG</literal> has a different rank here than in
+        <xref linkend="guc-log-min-messages"/>.
        </para>
 
        <para>
@@ -11391,6 +11458,7 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </listitem>
      </varlistentry>
 
+
      <varlistentry id="guc-debug-discard-caches" xreflabel="debug_discard_caches">
       <term><varname>debug_discard_caches</varname> (<type>integer</type>)
       <indexterm>
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index d91a85cb2d7..08ee899f6bc 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -111,6 +111,7 @@ int			Log_error_verbosity = PGERROR_DEFAULT;
 char	   *Log_line_prefix = NULL; /* format for extra log line info */
 int			Log_destination = LOG_DESTINATION_STDERR;
 char	   *Log_destination_string = NULL;
+int			log_backtrace = LOGBACKTRACE_NONE;
 bool		syslog_sequence_numbers = true;
 bool		syslog_split_messages = true;
 
@@ -181,6 +182,7 @@ static void set_stack_entry_domain(ErrorData *edata, const char *domain);
 static void set_stack_entry_location(ErrorData *edata,
 									 const char *filename, int lineno,
 									 const char *funcname);
+static bool matches_backtrace_gucs(ErrorData *edata);
 static bool matches_backtrace_functions(const char *funcname);
 static pg_noinline void set_backtrace(ErrorData *edata, int num_skip);
 static void set_errdata_field(MemoryContextData *cxt, char **ptr, const char *str);
@@ -496,10 +498,7 @@ errfinish(const char *filename, int lineno, const char *funcname)
 	oldcontext = MemoryContextSwitchTo(ErrorContext);
 
 	/* Collect backtrace, if enabled and we didn't already */
-	if (!edata->backtrace &&
-		edata->funcname &&
-		backtrace_functions &&
-		matches_backtrace_functions(edata->funcname))
+	if (!edata->backtrace && matches_backtrace_gucs(edata))
 		set_backtrace(edata, 2);
 
 	/*
@@ -819,6 +818,26 @@ set_stack_entry_location(ErrorData *edata,
 	edata->funcname = funcname;
 }
 
+/*
+ * matches_backtrace_gucs --- checks whether the log entry matches
+ * log_backtrace_mode, backtrace_min_level and backtrace_functions.
+ */
+static bool
+matches_backtrace_gucs(ErrorData *edata)
+{
+	if (log_backtrace == LOGBACKTRACE_NONE)
+		return false;
+
+	if (log_backtrace == LOGBACKTRACE_INTERNAL_ERROR &&
+		edata->sqlerrcode != ERRCODE_INTERNAL_ERROR)
+		return false;
+
+	if (backtrace_min_level > edata->elevel)
+		return false;
+
+	return matches_backtrace_functions(edata->funcname);
+}
+
 /*
  * matches_backtrace_functions --- checks whether the given funcname matches
  * backtrace_functions
@@ -830,6 +849,9 @@ matches_backtrace_functions(const char *funcname)
 {
 	const char *p;
 
+	if (!backtrace_functions || backtrace_functions[0] == '\0')
+		return true;
+
 	if (!backtrace_function_list || funcname == NULL || funcname[0] == '\0')
 		return false;
 
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index 46c258be282..87826a32cfb 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -163,6 +163,23 @@ static const struct config_enum_entry server_message_level_options[] = {
 	{NULL, 0, false}
 };
 
+static const struct config_enum_entry backtrace_level_options[] = {
+	{"debug5", DEBUG5, false},
+	{"debug4", DEBUG4, false},
+	{"debug3", DEBUG3, false},
+	{"debug2", DEBUG2, false},
+	{"debug1", DEBUG1, false},
+	{"debug", DEBUG2, true},
+	{"log", LOG, false},
+	{"info", INFO, true},
+	{"notice", NOTICE, false},
+	{"warning", WARNING, false},
+	{"error", ERROR, false},
+	{"fatal", FATAL, false},
+	{"panic", PANIC, false},
+	{NULL, 0, false}
+};
+
 static const struct config_enum_entry intervalstyle_options[] = {
 	{"postgres", INTSTYLE_POSTGRES, false},
 	{"postgres_verbose", INTSTYLE_POSTGRES_VERBOSE, false},
@@ -200,6 +217,16 @@ static const struct config_enum_entry log_error_verbosity_options[] = {
 StaticAssertDecl(lengthof(log_error_verbosity_options) == (PGERROR_VERBOSE + 2),
 				 "array length mismatch");
 
+static const struct config_enum_entry log_backtrace_options[] = {
+	{"none", LOGBACKTRACE_NONE, false},
+	{"internal_error", LOGBACKTRACE_INTERNAL_ERROR, false},
+	{"all", LOGBACKTRACE_ALL, false},
+	{NULL, 0, false}
+};
+
+StaticAssertDecl(lengthof(log_backtrace_options) == (LOGBACKTRACE_ALL + 2),
+				 "array length mismatch");
+
 static const struct config_enum_entry log_statement_options[] = {
 	{"none", LOGSTMT_NONE, false},
 	{"ddl", LOGSTMT_DDL, false},
@@ -531,6 +558,7 @@ int			log_temp_files = -1;
 double		log_statement_sample_rate = 1.0;
 double		log_xact_sample_rate = 0;
 char	   *backtrace_functions;
+int			backtrace_min_level = ERROR;
 
 int			temp_file_limit = -1;
 
@@ -4724,6 +4752,18 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"backtrace_min_level", PGC_SUSET, DEVELOPER_OPTIONS,
+			gettext_noop("Sets the message levels that create backtraces when log_backtrace is configured."),
+			gettext_noop("Each level includes all the levels that follow it. The later"
+						 " the level, the fewer backtraces are created."),
+			GUC_NOT_IN_SAMPLE
+		},
+		&backtrace_min_level,
+		ERROR, backtrace_level_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
 			gettext_noop("Sets the output format for bytea."),
@@ -4820,6 +4860,16 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"log_backtrace", PGC_SUSET, LOGGING_WHAT,
+			gettext_noop("Sets if logs should include a backtrace."),
+			NULL
+		},
+		&log_backtrace,
+		LOGBACKTRACE_NONE, log_backtrace_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"log_error_verbosity", PGC_SUSET, LOGGING_WHAT,
 			gettext_noop("Sets the verbosity of logged messages."),
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index e0567de2190..33bde793cdc 100644
--- a/src/backend/utils/misc/postgresql.conf.sample
+++ b/src/backend/utils/misc/postgresql.conf.sample
@@ -575,6 +575,7 @@
 					# their durations, > 0 logs only
 					# actions running at least this number
 					# of milliseconds.
+#log_backtrace = 'none'
 #log_checkpoints = on
 #log_connections = off
 #log_disconnections = off
diff --git a/src/include/utils/elog.h b/src/include/utils/elog.h
index da1a7469fa5..c6796cf0265 100644
--- a/src/include/utils/elog.h
+++ b/src/include/utils/elog.h
@@ -495,9 +495,17 @@ typedef enum
 	PGERROR_VERBOSE,			/* all the facts, ma'am */
 } PGErrorVerbosity;
 
+typedef enum
+{
+	LOGBACKTRACE_NONE,			/* no backtrace */
+	LOGBACKTRACE_INTERNAL_ERROR,	/* backtrace for internal error code */
+	LOGBACKTRACE_ALL,			/* backtrace for all logs */
+} LogBacktraceVerbosity;
+
 extern PGDLLIMPORT int Log_error_verbosity;
 extern PGDLLIMPORT char *Log_line_prefix;
 extern PGDLLIMPORT int Log_destination;
+extern PGDLLIMPORT int log_backtrace;
 extern PGDLLIMPORT char *Log_destination_string;
 extern PGDLLIMPORT bool syslog_sequence_numbers;
 extern PGDLLIMPORT bool syslog_split_messages;
diff --git a/src/include/utils/guc.h b/src/include/utils/guc.h
index ff506bf48d9..8417f203891 100644
--- a/src/include/utils/guc.h
+++ b/src/include/utils/guc.h
@@ -267,6 +267,7 @@ extern PGDLLIMPORT int log_temp_files;
 extern PGDLLIMPORT double log_statement_sample_rate;
 extern PGDLLIMPORT double log_xact_sample_rate;
 extern PGDLLIMPORT char *backtrace_functions;
+extern PGDLLIMPORT int backtrace_min_level;
 
 extern PGDLLIMPORT int temp_file_limit;
 
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 67ec5408a98..15c596e33a7 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -1531,6 +1531,7 @@ LockTupleMode
 LockViewRecurse_context
 LockWaitPolicy
 LockingClause
+LogBacktraceVerbosity
 LogOpts
 LogStmtLevel
 LogicalDecodeBeginCB
-- 
2.34.1

From bfc9c9741898e033e3eb117a85c06564120ce898 Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Thu, 21 Mar 2024 13:05:35 +0100
Subject: [PATCH v11 1/2] Add PGErrorVerbosity to typedefs.list

This one was missing, resulting in some strange alignment.
---
 src/include/utils/elog.h         | 2 +-
 src/tools/pgindent/typedefs.list | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/include/utils/elog.h b/src/include/utils/elog.h
index 7161f5c6ad6..a0244bff1fc 100644
--- a/src/include/utils/elog.h
+++ b/src/include/utils/elog.h
@@ -494,7 +494,7 @@ typedef enum
 	PGERROR_TERSE,				/* single-line error messages */
 	PGERROR_DEFAULT,			/* recommended style */
 	PGERROR_VERBOSE,			/* all the facts, ma'am */
-}			PGErrorVerbosity;
+} PGErrorVerbosity;
 
 extern PGDLLIMPORT int Log_error_verbosity;
 extern PGDLLIMPORT char *Log_line_prefix;
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index bce4214503d..80aa50d55a4 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -1792,6 +1792,7 @@ PGAsyncStatusType
 PGCALL2
 PGChecksummablePage
 PGContextVisibility
+PGErrorVerbosity
 PGEvent
 PGEventConnDestroy
 PGEventConnReset

base-commit: 217919dd0954f54402e8d0a38cd203a740754077
-- 
2.43.0

From 0cb321f0a570116a89afa1b1f78a3adcad3fe6e4 Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <jelte.fennema@microsoft.com>
Date: Thu, 27 Jun 2024 10:56:10 +0200
Subject: [PATCH v11 2/2] Allow logging backtraces in more cases

We previously only had the backtrace_functions GUC to control when
backtraces were logged. Based on mailinglist discussion there were two
common cases that people wanted backtraces that were not covered by this
GUC though:

1. Logging backtraces for all internal errors
2. Logging backtraces for all errors

To support those two usecases, as well as to allow users to continue to
log backtraces for specific warnings using `backtrace_functions`, this
modifies the GUCs in the following way:

1. Adds a `log_backtrace` GUC, which can be set to `none` (default),
   `internal_error` and `all` to log different types of backtraces.
2. Change `backtrace_functions` to behave as an additional filter on top
   of `log_backtrace`. The empty string (the default) is now interpreted
   as doing no filtering based on function name.
3. Add a `backtrace_min_level` GUC, which limits for which log entries
   backtraces are written, based on their log level. This defaults to
   ERROR.

This does mean that setting `backtrace_functions=some_func` alone is not
enough to get backtraces for some_func. You now need to combine that
with `log_backtrace_mode=all` and if you want to get backtraces for
non-errors (which you previously got), you also need to change
backtrace_min_level to whichever level you want backtraces for.
---
 doc/src/sgml/config.sgml                      | 82 +++++++++++++++++--
 src/backend/utils/error/elog.c                | 30 ++++++-
 src/backend/utils/misc/guc_tables.c           | 50 +++++++++++
 src/backend/utils/misc/postgresql.conf.sample |  1 +
 src/include/utils/elog.h                      |  8 ++
 src/include/utils/guc.h                       |  1 +
 src/tools/pgindent/typedefs.list              |  1 +
 7 files changed, 162 insertions(+), 11 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 336630ce417..257a1e4006a 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -7231,6 +7231,44 @@ local0.*    /var/log/postgresql
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-log-backtrace-mode" xreflabel="log_backtrace_mode">
+      <term><varname>log_backtrace_mode</varname> (<type>boolean</type>)
+      <indexterm>
+        <primary><varname>log_backtrace_mode</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        If this parameter is set to <literal>all</literal> then for all log
+        entries a backtrace is written to the server log together with the log
+        message. If this parameter is set to <literal>internal_error</literal> then
+        such a backtrace is only written for logs with error code XX000
+        (internal error; see also <xref linkend="errcodes-appendix"/>).
+        This can be used to debug such internal errors (which should normally
+        not happen in production). Finally, if this parameter is set to
+        <literal>none</literal> (the default), no backtraces are ever written
+        to the server log.
+       </para>
+
+       <para>
+        The logs for which a backtrace is written can be further restricted
+        using <xref linkend="guc-backtrace-min-level"/> (default:
+        <literal>ERROR</literal>) and <xref linkend="guc-backtrace-functions"/>
+        (default: empty string, meaning all).
+       </para>
+
+       <para>
+        Backtrace support is not available on all platforms, and the quality
+        of the backtraces depends on compilation options.
+       </para>
+
+       <para>
+        Only superusers and users with the appropriate <literal>SET</literal>
+        privilege can change this setting.
+       </para>
+      </listitem>
+     </varlistentry>
+
      <varlistentry id="guc-log-checkpoints" xreflabel="log_checkpoints">
       <term><varname>log_checkpoints</varname> (<type>boolean</type>)
       <indexterm>
@@ -11671,16 +11709,45 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </term>
       <listitem>
        <para>
-        This parameter contains a comma-separated list of C function names.
-        If an error is raised and the name of the internal C function where
-        the error happens matches a value in the list, then a backtrace is
-        written to the server log together with the error message.  This can
-        be used to debug specific areas of the source code.
+        This parameter can contain a comma-separated list of C function names,
+        which can be used to filter for which logs a backtrace is written to
+        the server log.
+        If a log entry is raised and the name of the
+        internal C function where the error happens does not match any of the
+        values in the list, then no backtrace is written to the server log.
+        This can be used to only debug specific areas of the source code.
        </para>
 
        <para>
-        Backtrace support is not available on all platforms, and the quality
-        of the backtraces depends on compilation options.
+        The empty string (the default) disables any such filtering. So for any
+        logs that match both <xref linkend="guc-log-backtrace-mode"/> and
+        <xref linkend="guc-backtrace-min-level"/> a backtrace is
+        written to the server log.
+       </para>
+      </listitem>
+     </varlistentry>
+
+     <varlistentry id="guc-backtrace-min-level" xreflabel="backtrace_min_level">
+      <term><varname>backtrace_min_level</varname> (<type>string</type>)
+      <indexterm>
+        <primary><varname>backtrace_min_level</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        Controls which <link linkend="runtime-config-severity-levels">message
+        levels</link> cause backtraces to be written to the log, for log
+        messages that match both <xref linkend="guc-log-backtrace-mode"/> and
+        <xref linkend="guc-backtrace-functions"/>.
+        Valid values are <literal>DEBUG5</literal>, <literal>DEBUG4</literal>,
+        <literal>DEBUG3</literal>, <literal>DEBUG2</literal>, <literal>DEBUG1</literal>,
+        <literal>LOG</literal>, <literal>INFO</literal>, <literal>NOTICE</literal>,
+        <literal>WARNING</literal>, <literal>ERROR</literal>, <literal>FATAL</literal>,
+        and <literal>PANIC</literal>.  Each level includes all the levels that
+        follow it.  The later the level, the fewer messages result in a
+        backtrace.  The default is <literal>ERROR</literal>.  Note that
+        <literal>LOG</literal> has a different rank here than in
+        <xref linkend="guc-log-min-messages"/>.
        </para>
 
        <para>
@@ -11713,6 +11780,7 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </listitem>
      </varlistentry>
 
+
      <varlistentry id="guc-debug-discard-caches" xreflabel="debug_discard_caches">
       <term><varname>debug_discard_caches</varname> (<type>integer</type>)
       <indexterm>
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index 860bbd40d42..d5501f68313 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -109,6 +109,7 @@ int			Log_error_verbosity = PGERROR_DEFAULT;
 char	   *Log_line_prefix = NULL; /* format for extra log line info */
 int			Log_destination = LOG_DESTINATION_STDERR;
 char	   *Log_destination_string = NULL;
+int			log_backtrace = LOGBACKTRACE_NONE;
 bool		syslog_sequence_numbers = true;
 bool		syslog_split_messages = true;
 
@@ -177,6 +178,7 @@ static void set_stack_entry_domain(ErrorData *edata, const char *domain);
 static void set_stack_entry_location(ErrorData *edata,
 									 const char *filename, int lineno,
 									 const char *funcname);
+static bool matches_backtrace_gucs(ErrorData *edata);
 static bool matches_backtrace_functions(const char *funcname);
 static pg_noinline void set_backtrace(ErrorData *edata, int num_skip);
 static void set_errdata_field(MemoryContextData *cxt, char **ptr, const char *str);
@@ -492,10 +494,7 @@ errfinish(const char *filename, int lineno, const char *funcname)
 	oldcontext = MemoryContextSwitchTo(ErrorContext);
 
 	/* Collect backtrace, if enabled and we didn't already */
-	if (!edata->backtrace &&
-		edata->funcname &&
-		backtrace_functions &&
-		matches_backtrace_functions(edata->funcname))
+	if (!edata->backtrace && matches_backtrace_gucs(edata))
 		set_backtrace(edata, 2);
 
 	/*
@@ -815,6 +814,26 @@ set_stack_entry_location(ErrorData *edata,
 	edata->funcname = funcname;
 }
 
+/*
+ * matches_backtrace_gucs --- checks whether the log entry matches
+ * log_backtrace_mode, backtrace_min_level and backtrace_functions.
+ */
+static bool
+matches_backtrace_gucs(ErrorData *edata)
+{
+	if (log_backtrace == LOGBACKTRACE_NONE)
+		return false;
+
+	if (log_backtrace == LOGBACKTRACE_INTERNAL_ERROR &&
+		edata->sqlerrcode != ERRCODE_INTERNAL_ERROR)
+		return false;
+
+	if (backtrace_min_level > edata->elevel)
+		return false;
+
+	return matches_backtrace_functions(edata->funcname);
+}
+
 /*
  * matches_backtrace_functions --- checks whether the given funcname matches
  * backtrace_functions
@@ -826,6 +845,9 @@ matches_backtrace_functions(const char *funcname)
 {
 	const char *p;
 
+	if (!backtrace_functions || backtrace_functions[0] == '\0')
+		return true;
+
 	if (!backtrace_function_list || funcname == NULL || funcname[0] == '\0')
 		return false;
 
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index cce73314609..052b9d16aa6 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -154,6 +154,23 @@ static const struct config_enum_entry server_message_level_options[] = {
 	{NULL, 0, false}
 };
 
+static const struct config_enum_entry backtrace_level_options[] = {
+	{"debug5", DEBUG5, false},
+	{"debug4", DEBUG4, false},
+	{"debug3", DEBUG3, false},
+	{"debug2", DEBUG2, false},
+	{"debug1", DEBUG1, false},
+	{"debug", DEBUG2, true},
+	{"log", LOG, false},
+	{"info", INFO, true},
+	{"notice", NOTICE, false},
+	{"warning", WARNING, false},
+	{"error", ERROR, false},
+	{"fatal", FATAL, false},
+	{"panic", PANIC, false},
+	{NULL, 0, false}
+};
+
 static const struct config_enum_entry intervalstyle_options[] = {
 	{"postgres", INTSTYLE_POSTGRES, false},
 	{"postgres_verbose", INTSTYLE_POSTGRES_VERBOSE, false},
@@ -191,6 +208,16 @@ static const struct config_enum_entry log_error_verbosity_options[] = {
 StaticAssertDecl(lengthof(log_error_verbosity_options) == (PGERROR_VERBOSE + 2),
 				 "array length mismatch");
 
+static const struct config_enum_entry log_backtrace_options[] = {
+	{"none", LOGBACKTRACE_NONE, false},
+	{"internal_error", LOGBACKTRACE_INTERNAL_ERROR, false},
+	{"all", LOGBACKTRACE_ALL, false},
+	{NULL, 0, false}
+};
+
+StaticAssertDecl(lengthof(log_backtrace_options) == (LOGBACKTRACE_ALL + 2),
+				 "array length mismatch");
+
 static const struct config_enum_entry log_statement_options[] = {
 	{"none", LOGSTMT_NONE, false},
 	{"ddl", LOGSTMT_DDL, false},
@@ -529,6 +556,7 @@ int			log_temp_files = -1;
 double		log_statement_sample_rate = 1.0;
 double		log_xact_sample_rate = 0;
 char	   *backtrace_functions;
+int			backtrace_min_level = ERROR;
 
 int			temp_file_limit = -1;
 
@@ -4880,6 +4908,18 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"backtrace_min_level", PGC_SUSET, DEVELOPER_OPTIONS,
+			gettext_noop("Sets the message levels that create backtraces when log_backtrace is configured."),
+			gettext_noop("Each level includes all the levels that follow it. The later"
+						 " the level, the fewer backtraces are created."),
+			GUC_NOT_IN_SAMPLE
+		},
+		&backtrace_min_level,
+		ERROR, backtrace_level_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
 			gettext_noop("Sets the output format for bytea."),
@@ -4976,6 +5016,16 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"log_backtrace", PGC_SUSET, LOGGING_WHAT,
+			gettext_noop("Sets if logs should include a backtrace."),
+			NULL
+		},
+		&log_backtrace,
+		LOGBACKTRACE_NONE, log_backtrace_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"log_error_verbosity", PGC_SUSET, LOGGING_WHAT,
 			gettext_noop("Sets the verbosity of logged messages."),
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index d472987ed46..5736e02cc47 100644
--- a/src/backend/utils/misc/postgresql.conf.sample
+++ b/src/backend/utils/misc/postgresql.conf.sample
@@ -573,6 +573,7 @@
 					# their durations, > 0 logs only
 					# actions running at least this number
 					# of milliseconds.
+#log_backtrace = 'none'
 #log_checkpoints = on
 #log_connections = off
 #log_disconnections = off
diff --git a/src/include/utils/elog.h b/src/include/utils/elog.h
index a0244bff1fc..f065c3951ea 100644
--- a/src/include/utils/elog.h
+++ b/src/include/utils/elog.h
@@ -496,9 +496,17 @@ typedef enum
 	PGERROR_VERBOSE,			/* all the facts, ma'am */
 } PGErrorVerbosity;
 
+typedef enum
+{
+	LOGBACKTRACE_NONE,			/* no backtrace */
+	LOGBACKTRACE_INTERNAL_ERROR,	/* backtrace for internal error code */
+	LOGBACKTRACE_ALL,			/* backtrace for all logs */
+} LogBacktraceVerbosity;
+
 extern PGDLLIMPORT int Log_error_verbosity;
 extern PGDLLIMPORT char *Log_line_prefix;
 extern PGDLLIMPORT int Log_destination;
+extern PGDLLIMPORT int log_backtrace;
 extern PGDLLIMPORT char *Log_destination_string;
 extern PGDLLIMPORT bool syslog_sequence_numbers;
 extern PGDLLIMPORT bool syslog_split_messages;
diff --git a/src/include/utils/guc.h b/src/include/utils/guc.h
index 1233e07d7da..f9f9ad710d1 100644
--- a/src/include/utils/guc.h
+++ b/src/include/utils/guc.h
@@ -279,6 +279,7 @@ extern PGDLLIMPORT int log_temp_files;
 extern PGDLLIMPORT double log_statement_sample_rate;
 extern PGDLLIMPORT double log_xact_sample_rate;
 extern PGDLLIMPORT char *backtrace_functions;
+extern PGDLLIMPORT int backtrace_min_level;
 
 extern PGDLLIMPORT int temp_file_limit;
 
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 80aa50d55a4..25a636969ee 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -1544,6 +1544,7 @@ LockTupleMode
 LockViewRecurse_context
 LockWaitPolicy
 LockingClause
+LogBacktraceVerbosity
 LogOpts
 LogStmtLevel
 LogicalDecodeBeginCB
-- 
2.43.0

From 579ac166ab91f5b5e7c2d79d2c9a7f5e4a52fc6e Mon Sep 17 00:00:00 2001
From: Jelte Fennema-Nio <github-tech@jeltef.nl>
Date: Tue, 18 Mar 2025 01:31:57 +0100
Subject: [PATCH v12] Allow logging backtraces in more cases

We previously only had the backtrace_functions GUC to control when
backtraces were logged. Based on mailinglist discussion there were two
common cases that people wanted backtraces that were not covered by this
GUC though:

1. Logging backtraces for all internal errors
2. Logging backtraces for all errors

To support those two usecases, as well as to allow users to continue to
log backtraces for specific warnings using `backtrace_functions`, this
modifies the GUCs in the following way:

1. Adds a `log_backtrace` GUC, which can be set to `none` (default),
   `internal_error` and `all` to log different types of backtraces.
2. Change `backtrace_functions` to behave as an additional filter on top
   of `log_backtrace`. The empty string (the default) is now interpreted
   as doing no filtering based on function name.
3. Add a `backtrace_min_level` GUC, which limits for which log entries
   backtraces are written, based on their log level. This defaults to
   ERROR.

This does mean that setting `backtrace_functions=some_func` alone is not
enough to get backtraces for some_func. You now need to combine that
with `log_backtrace_mode=all` and if you want to get backtraces for
non-errors (which you previously got), you also need to change
backtrace_min_level to whichever level you want backtraces for.
---
 doc/src/sgml/config.sgml                      | 82 +++++++++++++++++--
 src/backend/utils/error/elog.c                | 30 ++++++-
 src/backend/utils/misc/guc_tables.c           | 50 +++++++++++
 src/backend/utils/misc/postgresql.conf.sample |  1 +
 src/include/utils/elog.h                      |  8 ++
 src/include/utils/guc.h                       |  1 +
 6 files changed, 161 insertions(+), 11 deletions(-)

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 3d62c8bd274..da8cbb09d69 100644
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -7291,6 +7291,44 @@ local0.*    /var/log/postgresql
       </listitem>
      </varlistentry>
 
+     <varlistentry id="guc-log-backtrace-mode" xreflabel="log_backtrace_mode">
+      <term><varname>log_backtrace_mode</varname> (<type>boolean</type>)
+      <indexterm>
+        <primary><varname>log_backtrace_mode</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        If this parameter is set to <literal>all</literal> then for all log
+        entries a backtrace is written to the server log together with the log
+        message. If this parameter is set to <literal>internal_error</literal> then
+        such a backtrace is only written for logs with error code XX000
+        (internal error; see also <xref linkend="errcodes-appendix"/>).
+        This can be used to debug such internal errors (which should normally
+        not happen in production). Finally, if this parameter is set to
+        <literal>none</literal> (the default), no backtraces are ever written
+        to the server log.
+       </para>
+
+       <para>
+        The logs for which a backtrace is written can be further restricted
+        using <xref linkend="guc-backtrace-min-level"/> (default:
+        <literal>ERROR</literal>) and <xref linkend="guc-backtrace-functions"/>
+        (default: empty string, meaning all).
+       </para>
+
+       <para>
+        Backtrace support is not available on all platforms, and the quality
+        of the backtraces depends on compilation options.
+       </para>
+
+       <para>
+        Only superusers and users with the appropriate <literal>SET</literal>
+        privilege can change this setting.
+       </para>
+      </listitem>
+     </varlistentry>
+
      <varlistentry id="guc-log-checkpoints" xreflabel="log_checkpoints">
       <term><varname>log_checkpoints</varname> (<type>boolean</type>)
       <indexterm>
@@ -11841,16 +11879,45 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </term>
       <listitem>
        <para>
-        This parameter contains a comma-separated list of C function names.
-        If an error is raised and the name of the internal C function where
-        the error happens matches a value in the list, then a backtrace is
-        written to the server log together with the error message.  This can
-        be used to debug specific areas of the source code.
+        This parameter can contain a comma-separated list of C function names,
+        which can be used to filter for which logs a backtrace is written to
+        the server log.
+        If a log entry is raised and the name of the
+        internal C function where the error happens does not match any of the
+        values in the list, then no backtrace is written to the server log.
+        This can be used to only debug specific areas of the source code.
        </para>
 
        <para>
-        Backtrace support is not available on all platforms, and the quality
-        of the backtraces depends on compilation options.
+        The empty string (the default) disables any such filtering. So for any
+        logs that match both <xref linkend="guc-log-backtrace-mode"/> and
+        <xref linkend="guc-backtrace-min-level"/> a backtrace is
+        written to the server log.
+       </para>
+      </listitem>
+     </varlistentry>
+
+     <varlistentry id="guc-backtrace-min-level" xreflabel="backtrace_min_level">
+      <term><varname>backtrace_min_level</varname> (<type>string</type>)
+      <indexterm>
+        <primary><varname>backtrace_min_level</varname> configuration parameter</primary>
+      </indexterm>
+      </term>
+      <listitem>
+       <para>
+        Controls which <link linkend="runtime-config-severity-levels">message
+        levels</link> cause backtraces to be written to the log, for log
+        messages that match both <xref linkend="guc-log-backtrace-mode"/> and
+        <xref linkend="guc-backtrace-functions"/>.
+        Valid values are <literal>DEBUG5</literal>, <literal>DEBUG4</literal>,
+        <literal>DEBUG3</literal>, <literal>DEBUG2</literal>, <literal>DEBUG1</literal>,
+        <literal>LOG</literal>, <literal>INFO</literal>, <literal>NOTICE</literal>,
+        <literal>WARNING</literal>, <literal>ERROR</literal>, <literal>FATAL</literal>,
+        and <literal>PANIC</literal>.  Each level includes all the levels that
+        follow it.  The later the level, the fewer messages result in a
+        backtrace.  The default is <literal>ERROR</literal>.  Note that
+        <literal>LOG</literal> has a different rank here than in
+        <xref linkend="guc-log-min-messages"/>.
        </para>
 
        <para>
@@ -11883,6 +11950,7 @@ dynamic_library_path = 'C:\tools\postgresql;H:\my_project\lib;$libdir'
       </listitem>
      </varlistentry>
 
+
      <varlistentry id="guc-debug-discard-caches" xreflabel="debug_discard_caches">
       <term><varname>debug_discard_caches</varname> (<type>integer</type>)
       <indexterm>
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
index 860bbd40d42..d5501f68313 100644
--- a/src/backend/utils/error/elog.c
+++ b/src/backend/utils/error/elog.c
@@ -109,6 +109,7 @@ int			Log_error_verbosity = PGERROR_DEFAULT;
 char	   *Log_line_prefix = NULL; /* format for extra log line info */
 int			Log_destination = LOG_DESTINATION_STDERR;
 char	   *Log_destination_string = NULL;
+int			log_backtrace = LOGBACKTRACE_NONE;
 bool		syslog_sequence_numbers = true;
 bool		syslog_split_messages = true;
 
@@ -177,6 +178,7 @@ static void set_stack_entry_domain(ErrorData *edata, const char *domain);
 static void set_stack_entry_location(ErrorData *edata,
 									 const char *filename, int lineno,
 									 const char *funcname);
+static bool matches_backtrace_gucs(ErrorData *edata);
 static bool matches_backtrace_functions(const char *funcname);
 static pg_noinline void set_backtrace(ErrorData *edata, int num_skip);
 static void set_errdata_field(MemoryContextData *cxt, char **ptr, const char *str);
@@ -492,10 +494,7 @@ errfinish(const char *filename, int lineno, const char *funcname)
 	oldcontext = MemoryContextSwitchTo(ErrorContext);
 
 	/* Collect backtrace, if enabled and we didn't already */
-	if (!edata->backtrace &&
-		edata->funcname &&
-		backtrace_functions &&
-		matches_backtrace_functions(edata->funcname))
+	if (!edata->backtrace && matches_backtrace_gucs(edata))
 		set_backtrace(edata, 2);
 
 	/*
@@ -815,6 +814,26 @@ set_stack_entry_location(ErrorData *edata,
 	edata->funcname = funcname;
 }
 
+/*
+ * matches_backtrace_gucs --- checks whether the log entry matches
+ * log_backtrace_mode, backtrace_min_level and backtrace_functions.
+ */
+static bool
+matches_backtrace_gucs(ErrorData *edata)
+{
+	if (log_backtrace == LOGBACKTRACE_NONE)
+		return false;
+
+	if (log_backtrace == LOGBACKTRACE_INTERNAL_ERROR &&
+		edata->sqlerrcode != ERRCODE_INTERNAL_ERROR)
+		return false;
+
+	if (backtrace_min_level > edata->elevel)
+		return false;
+
+	return matches_backtrace_functions(edata->funcname);
+}
+
 /*
  * matches_backtrace_functions --- checks whether the given funcname matches
  * backtrace_functions
@@ -826,6 +845,9 @@ matches_backtrace_functions(const char *funcname)
 {
 	const char *p;
 
+	if (!backtrace_functions || backtrace_functions[0] == '\0')
+		return true;
+
 	if (!backtrace_function_list || funcname == NULL || funcname[0] == '\0')
 		return false;
 
diff --git a/src/backend/utils/misc/guc_tables.c b/src/backend/utils/misc/guc_tables.c
index 9c0b10ad4dc..b97a551a35a 100644
--- a/src/backend/utils/misc/guc_tables.c
+++ b/src/backend/utils/misc/guc_tables.c
@@ -156,6 +156,23 @@ static const struct config_enum_entry server_message_level_options[] = {
 	{NULL, 0, false}
 };
 
+static const struct config_enum_entry backtrace_level_options[] = {
+	{"debug5", DEBUG5, false},
+	{"debug4", DEBUG4, false},
+	{"debug3", DEBUG3, false},
+	{"debug2", DEBUG2, false},
+	{"debug1", DEBUG1, false},
+	{"debug", DEBUG2, true},
+	{"log", LOG, false},
+	{"info", INFO, true},
+	{"notice", NOTICE, false},
+	{"warning", WARNING, false},
+	{"error", ERROR, false},
+	{"fatal", FATAL, false},
+	{"panic", PANIC, false},
+	{NULL, 0, false}
+};
+
 static const struct config_enum_entry intervalstyle_options[] = {
 	{"postgres", INTSTYLE_POSTGRES, false},
 	{"postgres_verbose", INTSTYLE_POSTGRES_VERBOSE, false},
@@ -193,6 +210,16 @@ static const struct config_enum_entry log_error_verbosity_options[] = {
 StaticAssertDecl(lengthof(log_error_verbosity_options) == (PGERROR_VERBOSE + 2),
 				 "array length mismatch");
 
+static const struct config_enum_entry log_backtrace_options[] = {
+	{"none", LOGBACKTRACE_NONE, false},
+	{"internal_error", LOGBACKTRACE_INTERNAL_ERROR, false},
+	{"all", LOGBACKTRACE_ALL, false},
+	{NULL, 0, false}
+};
+
+StaticAssertDecl(lengthof(log_backtrace_options) == (LOGBACKTRACE_ALL + 2),
+				 "array length mismatch");
+
 static const struct config_enum_entry log_statement_options[] = {
 	{"none", LOGSTMT_NONE, false},
 	{"ddl", LOGSTMT_DDL, false},
@@ -531,6 +558,7 @@ int			log_temp_files = -1;
 double		log_statement_sample_rate = 1.0;
 double		log_xact_sample_rate = 0;
 char	   *backtrace_functions;
+int			backtrace_min_level = ERROR;
 
 int			temp_file_limit = -1;
 
@@ -4917,6 +4945,18 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"backtrace_min_level", PGC_SUSET, DEVELOPER_OPTIONS,
+			gettext_noop("Sets the message levels that create backtraces when log_backtrace is configured."),
+			gettext_noop("Each level includes all the levels that follow it. The later"
+						 " the level, the fewer backtraces are created."),
+			GUC_NOT_IN_SAMPLE
+		},
+		&backtrace_min_level,
+		ERROR, backtrace_level_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"bytea_output", PGC_USERSET, CLIENT_CONN_STATEMENT,
 			gettext_noop("Sets the output format for bytea."),
@@ -5013,6 +5053,16 @@ struct config_enum ConfigureNamesEnum[] =
 		NULL, NULL, NULL
 	},
 
+	{
+		{"log_backtrace", PGC_SUSET, LOGGING_WHAT,
+			gettext_noop("Sets if logs should include a backtrace."),
+			NULL
+		},
+		&log_backtrace,
+		LOGBACKTRACE_NONE, log_backtrace_options,
+		NULL, NULL, NULL
+	},
+
 	{
 		{"log_error_verbosity", PGC_SUSET, LOGGING_WHAT,
 			gettext_noop("Sets the verbosity of logged messages."),
diff --git a/src/backend/utils/misc/postgresql.conf.sample b/src/backend/utils/misc/postgresql.conf.sample
index 8de86e0c945..baa9bc63360 100644
--- a/src/backend/utils/misc/postgresql.conf.sample
+++ b/src/backend/utils/misc/postgresql.conf.sample
@@ -577,6 +577,7 @@
 					# their durations, > 0 logs only
 					# actions running at least this number
 					# of milliseconds.
+#log_backtrace = 'none'
 #log_checkpoints = on
 #log_connections = '' # log aspects of connection setup
           # options include receipt, authentication, authorization,
diff --git a/src/include/utils/elog.h b/src/include/utils/elog.h
index 855c147325b..6e0e86c8ee0 100644
--- a/src/include/utils/elog.h
+++ b/src/include/utils/elog.h
@@ -487,9 +487,17 @@ typedef enum
 	PGERROR_VERBOSE,			/* all the facts, ma'am */
 } PGErrorVerbosity;
 
+enum
+{
+	LOGBACKTRACE_NONE,			/* no backtrace */
+	LOGBACKTRACE_INTERNAL_ERROR,	/* backtrace for internal error code */
+	LOGBACKTRACE_ALL,			/* backtrace for all logs */
+};
+
 extern PGDLLIMPORT int Log_error_verbosity;
 extern PGDLLIMPORT char *Log_line_prefix;
 extern PGDLLIMPORT int Log_destination;
+extern PGDLLIMPORT int log_backtrace;
 extern PGDLLIMPORT char *Log_destination_string;
 extern PGDLLIMPORT bool syslog_sequence_numbers;
 extern PGDLLIMPORT bool syslog_split_messages;
diff --git a/src/include/utils/guc.h b/src/include/utils/guc.h
index 24444cbc365..de20db170ae 100644
--- a/src/include/utils/guc.h
+++ b/src/include/utils/guc.h
@@ -279,6 +279,7 @@ extern PGDLLIMPORT int log_temp_files;
 extern PGDLLIMPORT double log_statement_sample_rate;
 extern PGDLLIMPORT double log_xact_sample_rate;
 extern PGDLLIMPORT char *backtrace_functions;
+extern PGDLLIMPORT int backtrace_min_level;
 
 extern PGDLLIMPORT int temp_file_limit;
 

base-commit: 65db3963ae7154b8f01e4d73dc6b1ffd81c70e1e
-- 
2.43.0