jsonlog.c File Reference

#include "postgres.h"
#include "access/xact.h"
#include "libpq/libpq.h"
#include "lib/stringinfo.h"
#include "miscadmin.h"
#include "postmaster/bgworker.h"
#include "postmaster/syslogger.h"
#include "storage/lock.h"
#include "storage/proc.h"
#include "tcop/tcopprot.h"
#include "utils/backend_status.h"
#include "utils/elog.h"
#include "utils/guc.h"
#include "utils/json.h"
#include "utils/ps_status.h"

Include dependency graph for jsonlog.c:

Go to the source code of this file.

Functions
static void	appendJSONKeyValueFmt (StringInfo buf, const char *key, bool escape_key, const char *fmt,...) pg_attribute_printf(4
static void static void	appendJSONKeyValue (StringInfo buf, const char *key, const char *value, bool escape_value)
void	write_jsonlog (ErrorData *edata)

Function Documentation

appendJSONKeyValue()

static void static void appendJSONKeyValue ( StringInfo  buf, const char *  key, const char *  value, bool  escape_value  )

static

Definition at line 45 of file jsonlog.c.

{
    Assert(key != NULL);
 
    if (value == NULL)
        return;
 
    appendStringInfoChar(buf, ',');
    escape_json(buf, key);
    appendStringInfoChar(buf, ':');
 
    if (escape_value)
        escape_json(buf, value);
    else
        appendStringInfoString(buf, value);
}

References appendStringInfoChar(), appendStringInfoString(), Assert(), buf, escape_json(), sort-test::key, and value.

Referenced by appendJSONKeyValueFmt(), and write_jsonlog().

appendJSONKeyValueFmt()

static void appendJSONKeyValueFmt ( StringInfo  buf, const char *  key, bool  escape_key, const char *  fmt,   ...  )

static

Definition at line 72 of file jsonlog.c.

{
    int         save_errno = errno;
    size_t      len = 128;      /* initial assumption about buffer size */
    char       *value;
 
    for (;;)
    {
        va_list     args;
        size_t      newlen;
 
        /* Allocate result buffer */
        value = (char *) palloc(len);
 
        /* Try to format the data. */
        errno = save_errno;
        va_start(args, fmt);
        newlen = pvsnprintf(value, len, fmt, args);
        va_end(args);
 
        if (newlen < len)
            break;              /* success */
 
        /* Release buffer and loop around to try again with larger len. */
        pfree(value);
        len = newlen;
    }
 
    appendJSONKeyValue(buf, key, value, escape_key);
 
    /* Clean up */
    pfree(value);
}

References appendJSONKeyValue(), generate_unaccent_rules::args, buf, fmt, sort-test::key, len, palloc(), pfree(), pvsnprintf(), va_end(), va_start(), and value.

Referenced by write_jsonlog().

write_jsonlog()

void write_jsonlog

(

ErrorData *

edata

)

Definition at line 111 of file jsonlog.c.

{
    StringInfoData buf;
    char       *start_time;
    char       *log_time;
 
    /* static counter for line numbers */
    static long log_line_number = 0;
 
    /* Has the counter been reset in the current process? */
    static int  log_my_pid = 0;
 
    /*
     * This is one of the few places where we'd rather not inherit a static
     * variable's value from the postmaster.  But since we will, reset it when
     * MyProcPid changes.
     */
    if (log_my_pid != MyProcPid)
    {
        log_line_number = 0;
        log_my_pid = MyProcPid;
        reset_formatted_start_time();
    }
    log_line_number++;
 
    initStringInfo(&buf);
 
    /* Initialize string */
    appendStringInfoChar(&buf, '{');
 
    /* timestamp with milliseconds */
    log_time = get_formatted_log_time();
 
    /*
     * First property does not use appendJSONKeyValue as it does not have
     * comma prefix.
     */
    escape_json(&buf, "timestamp");
    appendStringInfoChar(&buf, ':');
    escape_json(&buf, log_time);
 
    /* username */
    if (MyProcPort)
        appendJSONKeyValue(&buf, "user", MyProcPort->user_name, true);
 
    /* database name */
    if (MyProcPort)
        appendJSONKeyValue(&buf, "dbname", MyProcPort->database_name, true);
 
    /* Process ID */
    if (MyProcPid != 0)
        appendJSONKeyValueFmt(&buf, "pid", false, "%d", MyProcPid);
 
    /* Remote host and port */
    if (MyProcPort && MyProcPort->remote_host)
    {
        appendJSONKeyValue(&buf, "remote_host", MyProcPort->remote_host, true);
        if (MyProcPort->remote_port && MyProcPort->remote_port[0] != '\0')
            appendJSONKeyValue(&buf, "remote_port", MyProcPort->remote_port, false);
    }
 
    /* Session id */
    appendJSONKeyValueFmt(&buf, "session_id", true, "%lx.%x",
                          (long) MyStartTime, MyProcPid);
 
    /* Line number */
    appendJSONKeyValueFmt(&buf, "line_num", false, "%ld", log_line_number);
 
    /* PS display */
    if (MyProcPort)
    {
        StringInfoData msgbuf;
        const char *psdisp;
        int         displen;
 
        initStringInfo(&msgbuf);
        psdisp = get_ps_display(&displen);
        appendBinaryStringInfo(&msgbuf, psdisp, displen);
        appendJSONKeyValue(&buf, "ps", msgbuf.data, true);
 
        pfree(msgbuf.data);
    }
 
    /* session start timestamp */
    start_time = get_formatted_start_time();
    appendJSONKeyValue(&buf, "session_start", start_time, true);
 
    /* Virtual transaction id */
    /* keep VXID format in sync with lockfuncs.c */
    if (MyProc != NULL && MyProc->backendId != InvalidBackendId)
        appendJSONKeyValueFmt(&buf, "vxid", true, "%d/%u", MyProc->backendId,
                              MyProc->lxid);
 
    /* Transaction id */
    appendJSONKeyValueFmt(&buf, "txid", false, "%u",
                          GetTopTransactionIdIfAny());
 
    /* Error severity */
    if (edata->elevel)
        appendJSONKeyValue(&buf, "error_severity",
                           (char *) error_severity(edata->elevel), true);
 
    /* SQL state code */
    if (edata->sqlerrcode)
        appendJSONKeyValue(&buf, "state_code",
                           unpack_sql_state(edata->sqlerrcode), true);
 
    /* errmessage */
    appendJSONKeyValue(&buf, "message", edata->message, true);
 
    /* errdetail or error_detail log */
    if (edata->detail_log)
        appendJSONKeyValue(&buf, "detail", edata->detail_log, true);
    else
        appendJSONKeyValue(&buf, "detail", edata->detail, true);
 
    /* errhint */
    if (edata->hint)
        appendJSONKeyValue(&buf, "hint", edata->hint, true);
 
    /* internal query */
    if (edata->internalquery)
        appendJSONKeyValue(&buf, "internal_query", edata->internalquery,
                           true);
 
    /* if printed internal query, print internal pos too */
    if (edata->internalpos > 0 && edata->internalquery != NULL)
        appendJSONKeyValueFmt(&buf, "internal_position", false, "%d",
                              edata->internalpos);
 
    /* errcontext */
    if (edata->context && !edata->hide_ctx)
        appendJSONKeyValue(&buf, "context", edata->context, true);
 
    /* user query --- only reported if not disabled by the caller */
    if (check_log_of_query(edata))
    {
        appendJSONKeyValue(&buf, "statement", debug_query_string, true);
        if (edata->cursorpos > 0)
            appendJSONKeyValueFmt(&buf, "cursor_position", false, "%d",
                                  edata->cursorpos);
    }
 
    /* file error location */
    if (Log_error_verbosity >= PGERROR_VERBOSE)
    {
        if (edata->funcname)
            appendJSONKeyValue(&buf, "func_name", edata->funcname, true);
        if (edata->filename)
        {
            appendJSONKeyValue(&buf, "file_name", edata->filename, true);
            appendJSONKeyValueFmt(&buf, "file_line_num", false, "%d",
                                  edata->lineno);
        }
    }
 
    /* Application name */
    if (application_name && application_name[0] != '\0')
        appendJSONKeyValue(&buf, "application_name", application_name, true);
 
    /* backend type */
    appendJSONKeyValue(&buf, "backend_type", get_backend_type_for_log(), true);
 
    /* leader PID */
    if (MyProc)
    {
        PGPROC     *leader = MyProc->lockGroupLeader;
 
        /*
         * Show the leader only for active parallel workers.  This leaves out
         * the leader of a parallel group.
         */
        if (leader && leader->pid != MyProcPid)
            appendJSONKeyValueFmt(&buf, "leader_pid", false, "%d",
                                  leader->pid);
    }
 
    /* query id */
    appendJSONKeyValueFmt(&buf, "query_id", false, "%lld",
                          (long long) pgstat_get_my_query_id());
 
    /* Finish string */
    appendStringInfoChar(&buf, '}');
    appendStringInfoChar(&buf, '\n');
 
    /* If in the syslogger process, try to write messages direct to file */
    if (MyBackendType == B_LOGGER)
        write_syslogger_file(buf.data, buf.len, LOG_DESTINATION_JSONLOG);
    else
        write_pipe_chunks(buf.data, buf.len, LOG_DESTINATION_JSONLOG);
 
    pfree(buf.data);
}

References appendBinaryStringInfo(), appendJSONKeyValue(), appendJSONKeyValueFmt(), appendStringInfoChar(), application_name, B_LOGGER, PGPROC::backendId, buf, check_log_of_query(), ErrorData::context, ErrorData::cursorpos, StringInfoData::data, Port::database_name, debug_query_string, ErrorData::detail, ErrorData::detail_log, ErrorData::elevel, error_severity(), escape_json(), ErrorData::filename, ErrorData::funcname, get_backend_type_for_log(), get_formatted_log_time(), get_formatted_start_time(), get_ps_display(), GetTopTransactionIdIfAny(), ErrorData::hide_ctx, ErrorData::hint, initStringInfo(), ErrorData::internalpos, ErrorData::internalquery, InvalidBackendId, ErrorData::lineno, PGPROC::lockGroupLeader, LOG_DESTINATION_JSONLOG, Log_error_verbosity, PGPROC::lxid, ErrorData::message, MyBackendType, MyProc, MyProcPid, MyProcPort, MyStartTime, pfree(), PGERROR_VERBOSE, pgstat_get_my_query_id(), PGPROC::pid, Port::remote_host, Port::remote_port, reset_formatted_start_time(), ErrorData::sqlerrcode, start_time, unpack_sql_state(), Port::user_name, write_pipe_chunks(), and write_syslogger_file().

Referenced by send_message_to_server_log().