PostgreSQL Source Code  git master
logging.c File Reference
#include "postgres_fe.h"
#include <unistd.h>
#include "common/logging.h"
Include dependency graph for logging.c:

Go to the source code of this file.

Macros

#define SGR_ERROR_DEFAULT   "01;31"
 
#define SGR_WARNING_DEFAULT   "01;35"
 
#define SGR_NOTE_DEFAULT   "01;36"
 
#define SGR_LOCUS_DEFAULT   "01"
 
#define ANSI_ESCAPE_FMT   "\x1b[%sm"
 
#define ANSI_ESCAPE_RESET   "\x1b[0m"
 

Functions

void pg_logging_init (const char *argv0)
 
void pg_logging_config (int new_flags)
 
void pg_logging_set_level (enum pg_log_level new_level)
 
void pg_logging_increase_verbosity (void)
 
void pg_logging_set_pre_callback (void(*cb)(void))
 
void pg_logging_set_locus_callback (void(*cb)(const char **filename, uint64 *lineno))
 
void pg_log_generic (enum pg_log_level level, enum pg_log_part part, const char *pg_restrict fmt,...)
 
void pg_log_generic_v (enum pg_log_level level, enum pg_log_part part, const char *pg_restrict fmt, va_list ap)
 

Variables

enum pg_log_level __pg_log_level
 
static const char * progname
 
static int log_flags
 
static void(* log_pre_callback )(void)
 
static void(* log_locus_callback )(const char **, uint64 *)
 
static const char * sgr_error = NULL
 
static const char * sgr_warning = NULL
 
static const char * sgr_note = NULL
 
static const char * sgr_locus = NULL
 

Macro Definition Documentation

◆ ANSI_ESCAPE_FMT

#define ANSI_ESCAPE_FMT   "\x1b[%sm"

Definition at line 39 of file logging.c.

◆ ANSI_ESCAPE_RESET

#define ANSI_ESCAPE_RESET   "\x1b[0m"

Definition at line 40 of file logging.c.

◆ SGR_ERROR_DEFAULT

#define SGR_ERROR_DEFAULT   "01;31"

Definition at line 34 of file logging.c.

◆ SGR_LOCUS_DEFAULT

#define SGR_LOCUS_DEFAULT   "01"

Definition at line 37 of file logging.c.

◆ SGR_NOTE_DEFAULT

#define SGR_NOTE_DEFAULT   "01;36"

Definition at line 36 of file logging.c.

◆ SGR_WARNING_DEFAULT

#define SGR_WARNING_DEFAULT   "01;35"

Definition at line 35 of file logging.c.

Function Documentation

◆ pg_log_generic()

void pg_log_generic ( enum pg_log_level  level,
enum pg_log_part  part,
const char *pg_restrict  fmt,
  ... 
)

Definition at line 205 of file logging.c.

207 {
208  va_list ap;
209 
210  va_start(ap, fmt);
211  pg_log_generic_v(level, part, fmt, ap);
212  va_end(ap);
213 }
va_end(args)
static void const char * fmt
va_start(args, fmt)
void pg_log_generic_v(enum pg_log_level level, enum pg_log_part part, const char *pg_restrict fmt, va_list ap)
Definition: logging.c:216

References fmt, pg_log_generic_v(), va_end(), and va_start().

Referenced by get_dirent_type().

◆ pg_log_generic_v()

void pg_log_generic_v ( enum pg_log_level  level,
enum pg_log_part  part,
const char *pg_restrict  fmt,
va_list  ap 
)

Definition at line 216 of file logging.c.

218 {
219  int save_errno = errno;
220  const char *filename = NULL;
221  uint64 lineno = 0;
222  va_list ap2;
223  size_t required_len;
224  char *buf;
225 
226  Assert(progname);
227  Assert(level);
228  Assert(fmt);
229  Assert(fmt[strlen(fmt) - 1] != '\n');
230 
231  /* Do nothing if log level is too low. */
232  if (level < __pg_log_level)
233  return;
234 
235  /*
236  * Flush stdout before output to stderr, to ensure sync even when stdout
237  * is buffered.
238  */
239  fflush(stdout);
240 
241  if (log_pre_callback)
243 
244  if (log_locus_callback)
245  log_locus_callback(&filename, &lineno);
246 
247  fmt = _(fmt);
248 
250  {
251  if (sgr_locus)
253  if (!(log_flags & PG_LOG_FLAG_TERSE))
254  fprintf(stderr, "%s:", progname);
255  if (filename)
256  {
257  fprintf(stderr, "%s:", filename);
258  if (lineno > 0)
259  fprintf(stderr, UINT64_FORMAT ":", lineno);
260  }
261  fprintf(stderr, " ");
262  if (sgr_locus)
263  fprintf(stderr, ANSI_ESCAPE_RESET);
264  }
265 
266  if (!(log_flags & PG_LOG_FLAG_TERSE))
267  {
268  switch (part)
269  {
270  case PG_LOG_PRIMARY:
271  switch (level)
272  {
273  case PG_LOG_ERROR:
274  if (sgr_error)
276  fprintf(stderr, _("error: "));
277  if (sgr_error)
278  fprintf(stderr, ANSI_ESCAPE_RESET);
279  break;
280  case PG_LOG_WARNING:
281  if (sgr_warning)
283  fprintf(stderr, _("warning: "));
284  if (sgr_warning)
285  fprintf(stderr, ANSI_ESCAPE_RESET);
286  break;
287  default:
288  break;
289  }
290  break;
291  case PG_LOG_DETAIL:
292  if (sgr_note)
293  fprintf(stderr, ANSI_ESCAPE_FMT, sgr_note);
294  fprintf(stderr, _("detail: "));
295  if (sgr_note)
296  fprintf(stderr, ANSI_ESCAPE_RESET);
297  break;
298  case PG_LOG_HINT:
299  if (sgr_note)
300  fprintf(stderr, ANSI_ESCAPE_FMT, sgr_note);
301  fprintf(stderr, _("hint: "));
302  if (sgr_note)
303  fprintf(stderr, ANSI_ESCAPE_RESET);
304  break;
305  }
306  }
307 
308  errno = save_errno;
309 
310  va_copy(ap2, ap);
311  required_len = vsnprintf(NULL, 0, fmt, ap2) + 1;
312  va_end(ap2);
313 
314  buf = pg_malloc_extended(required_len, MCXT_ALLOC_NO_OOM);
315 
316  errno = save_errno; /* malloc might change errno */
317 
318  if (!buf)
319  {
320  /* memory trouble, just print what we can and get out of here */
321  vfprintf(stderr, fmt, ap);
322  return;
323  }
324 
325  vsnprintf(buf, required_len, fmt, ap);
326 
327  /* strip one newline, for PQerrorMessage() */
328  if (required_len >= 2 && buf[required_len - 2] == '\n')
329  buf[required_len - 2] = '\0';
330 
331  fprintf(stderr, "%s\n", buf);
332 
333  free(buf);
334 }
#define UINT64_FORMAT
Definition: c.h:484
#define _(x)
Definition: elog.c:89
void * pg_malloc_extended(size_t size, int flags)
Definition: fe_memutils.c:59
#define MCXT_ALLOC_NO_OOM
Definition: fe_memutils.h:17
#define free(a)
Definition: header.h:65
static void const char fflush(stdout)
vfprintf(stderr, fmt, args)
Assert(fmt[strlen(fmt) - 1] !='\n')
static int log_flags
Definition: logging.c:24
static const char * sgr_note
Definition: logging.c:31
static const char * sgr_error
Definition: logging.c:29
static const char * sgr_warning
Definition: logging.c:30
static void(* log_pre_callback)(void)
Definition: logging.c:26
static void(* log_locus_callback)(const char **, uint64 *)
Definition: logging.c:27
static const char * sgr_locus
Definition: logging.c:32
static const char * progname
Definition: logging.c:23
enum pg_log_level __pg_log_level
Definition: logging.c:21
#define ANSI_ESCAPE_RESET
Definition: logging.c:40
#define ANSI_ESCAPE_FMT
Definition: logging.c:39
#define PG_LOG_FLAG_TERSE
Definition: logging.h:86
@ PG_LOG_PRIMARY
Definition: logging.h:67
@ PG_LOG_HINT
Definition: logging.h:79
@ PG_LOG_DETAIL
Definition: logging.h:73
@ PG_LOG_WARNING
Definition: logging.h:38
@ PG_LOG_ERROR
Definition: logging.h:43
static char * filename
Definition: pg_dumpall.c:94
static char * buf
Definition: pg_test_fsync.c:67
#define vsnprintf
Definition: port.h:224
#define fprintf
Definition: port.h:229

References _, __pg_log_level, ANSI_ESCAPE_FMT, ANSI_ESCAPE_RESET, Assert(), buf, fflush(), filename, fmt, fprintf, free, log_flags, log_locus_callback, log_pre_callback, MCXT_ALLOC_NO_OOM, PG_LOG_DETAIL, PG_LOG_ERROR, PG_LOG_FLAG_TERSE, PG_LOG_HINT, PG_LOG_PRIMARY, PG_LOG_WARNING, pg_malloc_extended(), progname, sgr_error, sgr_locus, sgr_note, sgr_warning, generate_unaccent_rules::stdout, UINT64_FORMAT, va_end(), vfprintf(), and vsnprintf.

Referenced by pg_log_generic(), report_backup_error(), report_fatal_error(), report_manifest_error(), and warn_or_exit_horribly().

◆ pg_logging_config()

void pg_logging_config ( int  new_flags)

Definition at line 163 of file logging.c.

164 {
165  log_flags = new_flags;
166 }

References log_flags.

Referenced by main(), and process_file().

◆ pg_logging_increase_verbosity()

void pg_logging_increase_verbosity ( void  )

Definition at line 182 of file logging.c.

183 {
184  /*
185  * The enum values are chosen such that we have to decrease __pg_log_level
186  * in order to become more verbose.
187  */
188  if (__pg_log_level > PG_LOG_NOTSET + 1)
189  __pg_log_level--;
190 }
@ PG_LOG_NOTSET
Definition: logging.h:21

References __pg_log_level, and PG_LOG_NOTSET.

Referenced by main().

◆ pg_logging_init()

void pg_logging_init ( const char *  argv0)

Definition at line 83 of file logging.c.

84 {
85  const char *pg_color_env = getenv("PG_COLOR");
86  bool log_color = false;
87  bool color_terminal = isatty(fileno(stderr));
88 
89 #ifdef WIN32
90 
91  /*
92  * On Windows, check if environment is VT100-compatible if using a
93  * terminal.
94  */
95  if (color_terminal)
96  color_terminal = enable_vt_processing();
97 #endif
98 
99  /* usually the default, but not on Windows */
100  setvbuf(stderr, NULL, _IONBF, 0);
101 
104 
105  if (pg_color_env)
106  {
107  if (strcmp(pg_color_env, "always") == 0 ||
108  (strcmp(pg_color_env, "auto") == 0 && color_terminal))
109  log_color = true;
110  }
111 
112  if (log_color)
113  {
114  const char *pg_colors_env = getenv("PG_COLORS");
115 
116  if (pg_colors_env)
117  {
118  char *colors = strdup(pg_colors_env);
119 
120  if (colors)
121  {
122  for (char *token = strtok(colors, ":"); token; token = strtok(NULL, ":"))
123  {
124  char *e = strchr(token, '=');
125 
126  if (e)
127  {
128  char *name;
129  char *value;
130 
131  *e = '\0';
132  name = token;
133  value = e + 1;
134 
135  if (strcmp(name, "error") == 0)
136  sgr_error = strdup(value);
137  if (strcmp(name, "warning") == 0)
138  sgr_warning = strdup(value);
139  if (strcmp(name, "note") == 0)
140  sgr_note = strdup(value);
141  if (strcmp(name, "locus") == 0)
142  sgr_locus = strdup(value);
143  }
144  }
145 
146  free(colors);
147  }
148  }
149  else
150  {
155  }
156  }
157 }
const char * name
Definition: encode.c:561
static struct @151 value
#define SGR_WARNING_DEFAULT
Definition: logging.c:35
#define SGR_NOTE_DEFAULT
Definition: logging.c:36
#define SGR_LOCUS_DEFAULT
Definition: logging.c:37
#define SGR_ERROR_DEFAULT
Definition: logging.c:34
@ PG_LOG_INFO
Definition: logging.h:33
static char * argv0
Definition: pg_ctl.c:97
const char * get_progname(const char *argv0)
Definition: path.c:574
e
Definition: preproc-init.c:82

References __pg_log_level, argv0, free, get_progname(), name, PG_LOG_INFO, progname, sgr_error, SGR_ERROR_DEFAULT, sgr_locus, SGR_LOCUS_DEFAULT, sgr_note, SGR_NOTE_DEFAULT, sgr_warning, SGR_WARNING_DEFAULT, and value.

Referenced by get_opts(), main(), and regression_main().

◆ pg_logging_set_level()

void pg_logging_set_level ( enum pg_log_level  new_level)

Definition at line 173 of file logging.c.

174 {
175  __pg_log_level = new_level;
176 }

References __pg_log_level.

Referenced by main().

◆ pg_logging_set_locus_callback()

void pg_logging_set_locus_callback ( void(*)(const char **filename, uint64 *lineno)  cb)

Definition at line 199 of file logging.c.

200 {
201  log_locus_callback = cb;
202 }

References log_locus_callback.

Referenced by main().

◆ pg_logging_set_pre_callback()

void pg_logging_set_pre_callback ( void(*)(void)  cb)

Definition at line 193 of file logging.c.

194 {
195  log_pre_callback = cb;
196 }

References log_pre_callback.

Referenced by main().

Variable Documentation

◆ __pg_log_level

◆ log_flags

int log_flags
static

Definition at line 24 of file logging.c.

Referenced by pg_log_generic_v(), and pg_logging_config().

◆ log_locus_callback

void(* log_locus_callback) (const char **, uint64 *) ( const char **  ,
uint64 *   
)
static

Definition at line 27 of file logging.c.

Referenced by pg_log_generic_v(), and pg_logging_set_locus_callback().

◆ log_pre_callback

void(* log_pre_callback) (void) ( void  )
static

Definition at line 26 of file logging.c.

Referenced by pg_log_generic_v(), and pg_logging_set_pre_callback().

◆ progname

const char* progname
static

Definition at line 23 of file logging.c.

Referenced by pg_log_generic_v(), and pg_logging_init().

◆ sgr_error

const char* sgr_error = NULL
static

Definition at line 29 of file logging.c.

Referenced by pg_log_generic_v(), and pg_logging_init().

◆ sgr_locus

const char* sgr_locus = NULL
static

Definition at line 32 of file logging.c.

Referenced by pg_log_generic_v(), and pg_logging_init().

◆ sgr_note

const char* sgr_note = NULL
static

Definition at line 31 of file logging.c.

Referenced by pg_log_generic_v(), and pg_logging_init().

◆ sgr_warning

const char* sgr_warning = NULL
static

Definition at line 30 of file logging.c.

Referenced by pg_log_generic_v(), and pg_logging_init().