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 207 of file logging.c.

{
    va_list     ap;
 
    va_start(ap, fmt);
    pg_log_generic_v(level, part, fmt, ap);
    va_end(ap);
}

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 218 of file logging.c.

{
    int         save_errno = errno;
    const char *filename = NULL;
    uint64      lineno = 0;
    va_list     ap2;
    size_t      required_len;
    char       *buf;
 
    Assert(progname);
    Assert(level);
    Assert(fmt);
    Assert(fmt[strlen(fmt) - 1] != '\n');
 
    /* Do nothing if log level is too low. */
    if (level < __pg_log_level)
        return;
 
    /*
     * Flush stdout before output to stderr, to ensure sync even when stdout
     * is buffered.
     */
    fflush(stdout);
 
    if (log_pre_callback)
        log_pre_callback();
 
    if (log_locus_callback)
        log_locus_callback(&filename, &lineno);
 
    fmt = _(fmt);
 
    if (!(log_flags & PG_LOG_FLAG_TERSE) || filename)
    {
        if (sgr_locus)
            fprintf(stderr, ANSI_ESCAPE_FMT, sgr_locus);
        if (!(log_flags & PG_LOG_FLAG_TERSE))
            fprintf(stderr, "%s:", progname);
        if (filename)
        {
            fprintf(stderr, "%s:", filename);
            if (lineno > 0)
                fprintf(stderr, UINT64_FORMAT ":", lineno);
        }
        fprintf(stderr, " ");
        if (sgr_locus)
            fprintf(stderr, ANSI_ESCAPE_RESET);
    }
 
    if (!(log_flags & PG_LOG_FLAG_TERSE))
    {
        switch (part)
        {
            case PG_LOG_PRIMARY:
                switch (level)
                {
                    case PG_LOG_ERROR:
                        if (sgr_error)
                            fprintf(stderr, ANSI_ESCAPE_FMT, sgr_error);
                        fprintf(stderr, _("error: "));
                        if (sgr_error)
                            fprintf(stderr, ANSI_ESCAPE_RESET);
                        break;
                    case PG_LOG_WARNING:
                        if (sgr_warning)
                            fprintf(stderr, ANSI_ESCAPE_FMT, sgr_warning);
                        fprintf(stderr, _("warning: "));
                        if (sgr_warning)
                            fprintf(stderr, ANSI_ESCAPE_RESET);
                        break;
                    default:
                        break;
                }
                break;
            case PG_LOG_DETAIL:
                if (sgr_note)
                    fprintf(stderr, ANSI_ESCAPE_FMT, sgr_note);
                fprintf(stderr, _("detail: "));
                if (sgr_note)
                    fprintf(stderr, ANSI_ESCAPE_RESET);
                break;
            case PG_LOG_HINT:
                if (sgr_note)
                    fprintf(stderr, ANSI_ESCAPE_FMT, sgr_note);
                fprintf(stderr, _("hint: "));
                if (sgr_note)
                    fprintf(stderr, ANSI_ESCAPE_RESET);
                break;
        }
    }
 
    errno = save_errno;
 
    va_copy(ap2, ap);
    required_len = vsnprintf(NULL, 0, fmt, ap2) + 1;
    va_end(ap2);
 
    buf = pg_malloc_extended(required_len, MCXT_ALLOC_NO_OOM);
 
    errno = save_errno;         /* malloc might change errno */
 
    if (!buf)
    {
        /* memory trouble, just print what we can and get out of here */
        vfprintf(stderr, fmt, ap);
        return;
    }
 
    vsnprintf(buf, required_len, fmt, ap);
 
    /* strip one newline, for PQerrorMessage() */
    if (required_len >= 2 && buf[required_len - 2] == '\n')
        buf[required_len - 2] = '\0';
 
    fprintf(stderr, "%s\n", buf);
 
    free(buf);
}

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(), walsummary_error_callback(), and warn_or_exit_horribly().

pg_logging_config()

void pg_logging_config

(

int

new_flags

)

Definition at line 165 of file logging.c.

{
    log_flags = new_flags;
}

References log_flags.

Referenced by main(), and process_file().

pg_logging_increase_verbosity()

void pg_logging_increase_verbosity

(

void

)

Definition at line 184 of file logging.c.

{
    /*
     * The enum values are chosen such that we have to decrease __pg_log_level
     * in order to become more verbose.
     */
    if (__pg_log_level > PG_LOG_NOTSET + 1)
        __pg_log_level--;
}

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.

{
    const char *pg_color_env = getenv("PG_COLOR");
    bool        log_color = false;
    bool        color_terminal = isatty(fileno(stderr));
 
#ifdef WIN32
 
    /*
     * On Windows, check if environment is VT100-compatible if using a
     * terminal.
     */
    if (color_terminal)
        color_terminal = enable_vt_processing();
#endif
 
    /* usually the default, but not on Windows */
    setvbuf(stderr, NULL, _IONBF, 0);
 
    progname = get_progname(argv0);
    __pg_log_level = PG_LOG_INFO;
 
    if (pg_color_env)
    {
        if (strcmp(pg_color_env, "always") == 0 ||
            (strcmp(pg_color_env, "auto") == 0 && color_terminal))
            log_color = true;
    }
 
    if (log_color)
    {
        const char *pg_colors_env = getenv("PG_COLORS");
 
        if (pg_colors_env)
        {
            char       *colors = strdup(pg_colors_env);
 
            if (colors)
            {
                char       *token;
 
                while ((token = strsep(&colors, ":")))
                {
                    char       *e = strchr(token, '=');
 
                    if (e)
                    {
                        char       *name;
                        char       *value;
 
                        *e = '\0';
                        name = token;
                        value = e + 1;
 
                        if (strcmp(name, "error") == 0)
                            sgr_error = strdup(value);
                        if (strcmp(name, "warning") == 0)
                            sgr_warning = strdup(value);
                        if (strcmp(name, "note") == 0)
                            sgr_note = strdup(value);
                        if (strcmp(name, "locus") == 0)
                            sgr_locus = strdup(value);
                    }
                }
 
                free(colors);
            }
        }
        else
        {
            sgr_error = SGR_ERROR_DEFAULT;
            sgr_warning = SGR_WARNING_DEFAULT;
            sgr_note = SGR_NOTE_DEFAULT;
            sgr_locus = SGR_LOCUS_DEFAULT;
        }
    }
}

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, strsep(), token, 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 175 of file logging.c.

{
    __pg_log_level = new_level;
}

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 201 of file logging.c.

{
    log_locus_callback = cb;
}

References log_locus_callback.

Referenced by main().

pg_logging_set_pre_callback()

void pg_logging_set_pre_callback

(

void(*)(void)

cb

)

Definition at line 195 of file logging.c.

{
    log_pre_callback = cb;
}

References log_pre_callback.

Referenced by main().

Variable Documentation

__pg_log_level

enum pg_log_level __pg_log_level

Definition at line 1 of file logging.c.

Referenced by executeMetaCommand(), pg_log_generic_v(), pg_logging_increase_verbosity(), pg_logging_init(), and pg_logging_set_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().