Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * jsonlog.c
4 : : * JSON logging
5 : : *
6 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : : * Portions Copyright (c) 1994, Regents of the University of California
8 : : *
9 : : *
10 : : * IDENTIFICATION
11 : : * src/backend/utils/error/jsonlog.c
12 : : *
13 : : *-------------------------------------------------------------------------
14 : : */
15 : :
16 : : #include "postgres.h"
17 : :
18 : : #include "access/xact.h"
19 : : #include "libpq/libpq-be.h"
20 : : #include "lib/stringinfo.h"
21 : : #include "miscadmin.h"
22 : : #include "postmaster/syslogger.h"
23 : : #include "storage/lock.h"
24 : : #include "storage/proc.h"
25 : : #include "tcop/tcopprot.h"
26 : : #include "utils/backend_status.h"
27 : : #include "utils/guc.h"
28 : : #include "utils/json.h"
29 : : #include "utils/ps_status.h"
30 : :
31 : : static void appendJSONKeyValueFmt(StringInfo buf, const char *key,
32 : : bool escape_key,
33 : : const char *fmt, ...) pg_attribute_printf(4, 5);
34 : :
35 : : /*
36 : : * appendJSONKeyValue
37 : : *
38 : : * Append to a StringInfo a comma followed by a JSON key and a value.
39 : : * The key is always escaped. The value can be escaped optionally, that
40 : : * is dependent on the data type of the key.
41 : : */
42 : : static void
43 : 259 : appendJSONKeyValue(StringInfo buf, const char *key, const char *value,
44 : : bool escape_value)
45 : : {
46 : : Assert(key != NULL);
47 : :
48 [ + + ]: 259 : if (value == NULL)
49 : 20 : return;
50 : :
51 : 239 : appendStringInfoChar(buf, ',');
52 : 239 : escape_json(buf, key);
53 : 239 : appendStringInfoChar(buf, ':');
54 : :
55 [ + + ]: 239 : if (escape_value)
56 : 158 : escape_json(buf, value);
57 : : else
58 : 81 : appendStringInfoString(buf, value);
59 : : }
60 : :
61 : :
62 : : /*
63 : : * appendJSONKeyValueFmt
64 : : *
65 : : * Evaluate the fmt string and then invoke appendJSONKeyValue() as the
66 : : * value of the JSON property. Both the key and value will be escaped by
67 : : * appendJSONKeyValue().
68 : : */
69 : : static void
70 : 110 : appendJSONKeyValueFmt(StringInfo buf, const char *key,
71 : : bool escape_key, const char *fmt, ...)
72 : : {
73 : 110 : int save_errno = errno;
74 : 110 : size_t len = 128; /* initial assumption about buffer size */
75 : : char *value;
76 : :
77 : : for (;;)
78 : 0 : {
79 : : va_list args;
80 : : size_t newlen;
81 : :
82 : : /* Allocate result buffer */
83 : 110 : value = (char *) palloc(len);
84 : :
85 : : /* Try to format the data. */
86 : 110 : errno = save_errno;
87 : 110 : va_start(args, fmt);
88 : 110 : newlen = pvsnprintf(value, len, fmt, args);
89 : 110 : va_end(args);
90 : :
91 [ + - ]: 110 : if (newlen < len)
92 : 110 : break; /* success */
93 : :
94 : : /* Release buffer and loop around to try again with larger len. */
95 : 0 : pfree(value);
96 : 0 : len = newlen;
97 : : }
98 : :
99 : 110 : appendJSONKeyValue(buf, key, value, escape_key);
100 : :
101 : : /* Clean up */
102 : 110 : pfree(value);
103 : 110 : }
104 : :
105 : : /*
106 : : * Write logs in json format.
107 : : */
108 : : void
109 : 20 : write_jsonlog(ErrorData *edata)
110 : : {
111 : : StringInfoData buf;
112 : : char *start_time;
113 : : char *log_time;
114 : :
115 : : /* static counter for line numbers */
116 : : static long log_line_number = 0;
117 : :
118 : : /* Has the counter been reset in the current process? */
119 : : static int log_my_pid = 0;
120 : :
121 : : /*
122 : : * This is one of the few places where we'd rather not inherit a static
123 : : * variable's value from the postmaster. But since we will, reset it when
124 : : * MyProcPid changes.
125 : : */
126 [ + + ]: 20 : if (log_my_pid != MyProcPid)
127 : : {
128 : 11 : log_line_number = 0;
129 : 11 : log_my_pid = MyProcPid;
130 : 11 : reset_formatted_start_time();
131 : : }
132 : 20 : log_line_number++;
133 : :
134 : 20 : initStringInfo(&buf);
135 : :
136 : : /* Initialize string */
137 : 20 : appendStringInfoChar(&buf, '{');
138 : :
139 : : /* timestamp with milliseconds */
140 : 20 : log_time = get_formatted_log_time();
141 : :
142 : : /*
143 : : * First property does not use appendJSONKeyValue as it does not have
144 : : * comma prefix.
145 : : */
146 : 20 : escape_json(&buf, "timestamp");
147 : 20 : appendStringInfoChar(&buf, ':');
148 : 20 : escape_json(&buf, log_time);
149 : :
150 : : /* username */
151 [ + + ]: 20 : if (MyProcPort)
152 : 9 : appendJSONKeyValue(&buf, "user", MyProcPort->user_name, true);
153 : :
154 : : /* database name */
155 [ + + ]: 20 : if (MyProcPort)
156 : 9 : appendJSONKeyValue(&buf, "dbname", MyProcPort->database_name, true);
157 : :
158 : : /* Process ID */
159 [ + - ]: 20 : if (MyProcPid != 0)
160 : 20 : appendJSONKeyValueFmt(&buf, "pid", false, "%d", MyProcPid);
161 : :
162 : : /* Remote host and port */
163 [ + + + - ]: 20 : if (MyProcPort && MyProcPort->remote_host)
164 : : {
165 : 9 : appendJSONKeyValue(&buf, "remote_host", MyProcPort->remote_host, true);
166 [ + - - + ]: 9 : if (MyProcPort->remote_port && MyProcPort->remote_port[0] != '\0')
167 : 0 : appendJSONKeyValue(&buf, "remote_port", MyProcPort->remote_port, false);
168 : : }
169 : :
170 : : /* Session id */
171 : 20 : appendJSONKeyValueFmt(&buf, "session_id", true, "%" PRIx64 ".%x",
172 : : MyStartTime, MyProcPid);
173 : :
174 : : /* Line number */
175 : 20 : appendJSONKeyValueFmt(&buf, "line_num", false, "%ld", log_line_number);
176 : :
177 : : /* PS display */
178 [ + + ]: 20 : if (MyProcPort)
179 : : {
180 : : StringInfoData msgbuf;
181 : : const char *psdisp;
182 : : int displen;
183 : :
184 : 9 : initStringInfo(&msgbuf);
185 : 9 : psdisp = get_ps_display(&displen);
186 : 9 : appendBinaryStringInfo(&msgbuf, psdisp, displen);
187 : 9 : appendJSONKeyValue(&buf, "ps", msgbuf.data, true);
188 : :
189 : 9 : pfree(msgbuf.data);
190 : : }
191 : :
192 : : /* session start timestamp */
193 : 20 : start_time = get_formatted_start_time();
194 : 20 : appendJSONKeyValue(&buf, "session_start", start_time, true);
195 : :
196 : : /* Virtual transaction id */
197 : : /* keep VXID format in sync with lockfuncs.c */
198 [ + + + + ]: 20 : if (MyProc != NULL && MyProc->vxid.procNumber != INVALID_PROC_NUMBER)
199 : 9 : appendJSONKeyValueFmt(&buf, "vxid", true, "%d/%u",
200 : 9 : MyProc->vxid.procNumber, MyProc->vxid.lxid);
201 : :
202 : : /* Transaction id */
203 : 20 : appendJSONKeyValueFmt(&buf, "txid", false, "%u",
204 : : GetTopTransactionIdIfAny());
205 : :
206 : : /* Error severity */
207 [ + - ]: 20 : if (edata->elevel)
208 : 20 : appendJSONKeyValue(&buf, "error_severity",
209 : : error_severity(edata->elevel), true);
210 : :
211 : : /* SQL state code */
212 [ + + ]: 20 : if (edata->sqlerrcode)
213 : 2 : appendJSONKeyValue(&buf, "state_code",
214 : 2 : unpack_sql_state(edata->sqlerrcode), true);
215 : :
216 : : /* errmessage */
217 : 20 : appendJSONKeyValue(&buf, "message", edata->message, true);
218 : :
219 : : /* errdetail or error_detail log */
220 [ - + ]: 20 : if (edata->detail_log)
221 : 0 : appendJSONKeyValue(&buf, "detail", edata->detail_log, true);
222 : : else
223 : 20 : appendJSONKeyValue(&buf, "detail", edata->detail, true);
224 : :
225 : : /* errhint */
226 [ - + ]: 20 : if (edata->hint)
227 : 0 : appendJSONKeyValue(&buf, "hint", edata->hint, true);
228 : :
229 : : /* internal query */
230 [ - + ]: 20 : if (edata->internalquery)
231 : 0 : appendJSONKeyValue(&buf, "internal_query", edata->internalquery,
232 : : true);
233 : :
234 : : /* if printed internal query, print internal pos too */
235 [ - + - - ]: 20 : if (edata->internalpos > 0 && edata->internalquery != NULL)
236 : 0 : appendJSONKeyValueFmt(&buf, "internal_position", false, "%d",
237 : : edata->internalpos);
238 : :
239 : : /* errcontext */
240 [ - + - - ]: 20 : if (edata->context && !edata->hide_ctx)
241 : 0 : appendJSONKeyValue(&buf, "context", edata->context, true);
242 : :
243 : : /* user query --- only reported if not disabled by the caller */
244 [ + + ]: 20 : if (check_log_of_query(edata))
245 : : {
246 : 2 : appendJSONKeyValue(&buf, "statement", debug_query_string, true);
247 [ + + ]: 2 : if (edata->cursorpos > 0)
248 : 1 : appendJSONKeyValueFmt(&buf, "cursor_position", false, "%d",
249 : : edata->cursorpos);
250 : : }
251 : :
252 : : /* file error location */
253 [ - + ]: 20 : if (Log_error_verbosity >= PGERROR_VERBOSE)
254 : : {
255 [ # # ]: 0 : if (edata->funcname)
256 : 0 : appendJSONKeyValue(&buf, "func_name", edata->funcname, true);
257 [ # # ]: 0 : if (edata->filename)
258 : : {
259 : 0 : appendJSONKeyValue(&buf, "file_name", edata->filename, true);
260 : 0 : appendJSONKeyValueFmt(&buf, "file_line_num", false, "%d",
261 : : edata->lineno);
262 : : }
263 : : }
264 : :
265 : : /* Application name */
266 [ + - + + ]: 20 : if (application_name && application_name[0] != '\0')
267 : 9 : appendJSONKeyValue(&buf, "application_name", application_name, true);
268 : :
269 : : /* backend type */
270 : 20 : appendJSONKeyValue(&buf, "backend_type", get_backend_type_for_log(), true);
271 : :
272 : : /* leader PID */
273 [ + + ]: 20 : if (MyProc)
274 : : {
275 : 13 : PGPROC *leader = MyProc->lockGroupLeader;
276 : :
277 : : /*
278 : : * Show the leader only for active parallel workers. This leaves out
279 : : * the leader of a parallel group.
280 : : */
281 [ - + - - ]: 13 : if (leader && leader->pid != MyProcPid)
282 : 0 : appendJSONKeyValueFmt(&buf, "leader_pid", false, "%d",
283 : : leader->pid);
284 : : }
285 : :
286 : : /* query id */
287 : 20 : appendJSONKeyValueFmt(&buf, "query_id", false, "%" PRId64,
288 : : pgstat_get_my_query_id());
289 : :
290 : : /* Finish string */
291 : 20 : appendStringInfoChar(&buf, '}');
292 : 20 : appendStringInfoChar(&buf, '\n');
293 : :
294 : : /* If in the syslogger process, try to write messages direct to file */
295 [ - + ]: 20 : if (syslogger_setup_done)
296 : 0 : write_syslogger_file(buf.data, buf.len, LOG_DESTINATION_JSONLOG);
297 : : else
298 : 20 : write_pipe_chunks(buf.data, buf.len, LOG_DESTINATION_JSONLOG);
299 : :
300 : 20 : pfree(buf.data);
301 : 20 : }
|
