PostgreSQL Source Code: src/common/logging.c Source File (original) (raw)

1

2

3

4

5

6

7

8

9

10

11#ifndef FRONTEND

12#error "This file is not expected to be compiled for backend code"

13#endif

14

16

18

20

22

25

28

33

34#define SGR_ERROR_DEFAULT "01;31"

35#define SGR_WARNING_DEFAULT "01;35"

36#define SGR_NOTE_DEFAULT "01;36"

37#define SGR_LOCUS_DEFAULT "01"

38

39#define ANSI_ESCAPE_FMT "\x1b[%sm"

40#define ANSI_ESCAPE_RESET "\x1b[0m"

41

42#ifdef WIN32

43

44#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING

45#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004

46#endif

47

48

49

50

51

52

53static bool

54enable_vt_processing(void)

55{

56

57 HANDLE hOut = GetStdHandle(STD_ERROR_HANDLE);

58 DWORD dwMode = 0;

59

60 if (hOut == INVALID_HANDLE_VALUE)

61 return false;

62

63

64

65

66

67 if (!GetConsoleMode(hOut, &dwMode))

68 return false;

69 if ((dwMode & ENABLE_VIRTUAL_TERMINAL_PROCESSING) != 0)

70 return true;

71

72 dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;

73 if (!SetConsoleMode(hOut, dwMode))

74 return false;

75 return true;

76}

77#endif

78

79

80

81

82void

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

93

94

95 if (color_terminal)

96 color_terminal = enable_vt_processing();

97#endif

98

99

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 {

123 char *cp = colors;

124

126 {

127 char *e = strchr(token, '=');

128

129 if (e)

130 {

133

134 *e = '\0';

137

138 if (strcmp(name, "error") == 0)

140 if (strcmp(name, "warning") == 0)

142 if (strcmp(name, "note") == 0)

144 if (strcmp(name, "locus") == 0)

146 }

147 }

148

149 free(colors);

150 }

151 }

152 else

153 {

158 }

159 }

160}

161

162

163

164

165void

167{

169}

170

171

172

173

174

175void

177{

179}

180

181

182

183

184void

186{

187

188

189

190

193}

194

195void

197{

199}

200

201void

203{

205}

206

207void

209 const char *pg_restrict fmt,...)

210{

211 va_list ap;

212

213 va_start(ap, fmt);

215 va_end(ap);

216}

217

218void

220 const char *pg_restrict fmt, va_list ap)

221{

222 int save_errno = errno;

225 va_list ap2;

226 size_t required_len;

227 char *buf;

228

232 Assert(fmt[strlen(fmt) - 1] != '\n');

233

234

236 return;

237

238

239

240

241

243

246

249

250 fmt = _(fmt);

251

253 {

259 {

261 if (lineno > 0)

263 }

267 }

268

270 {

271 switch (part)

272 {

274 switch (level)

275 {

279 fprintf(stderr, _("error: "));

282 break;

286 fprintf(stderr, _("warning: "));

289 break;

290 default:

291 break;

292 }

293 break;

297 fprintf(stderr, _("detail: "));

300 break;

304 fprintf(stderr, _("hint: "));

307 break;

308 }

309 }

310

311 errno = save_errno;

312

313 va_copy(ap2, ap);

314 required_len = vsnprintf(NULL, 0, fmt, ap2) + 1;

315 va_end(ap2);

316

318

319 errno = save_errno;

320

321 if (buf)

322 {

323

325 return;

326 }

327

329

330

331 if (required_len >= 2 && buf[required_len - 2] == '\n')

332 buf[required_len - 2] = '\0';

333

335

337}

#define fprintf(file, fmt, msg)

void * pg_malloc_extended(size_t size, int flags)

#define MCXT_ALLOC_NO_OOM

Assert(PointerIsAligned(start, uint64))

void pg_logging_increase_verbosity(void)

#define SGR_WARNING_DEFAULT

static const char * sgr_note

static const char * sgr_error

#define SGR_LOCUS_DEFAULT

void pg_logging_init(const char *argv0)

#define SGR_ERROR_DEFAULT

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

static const char * sgr_warning

static void(* log_pre_callback)(void)

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

static const char * sgr_locus

void pg_logging_config(int new_flags)

void pg_logging_set_level(enum pg_log_level new_level)

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

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

static const char * progname

enum pg_log_level __pg_log_level

#define ANSI_ESCAPE_RESET

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

#define PG_LOG_FLAG_TERSE

char * strsep(char **stringp, const char *delim)

const char * get_progname(const char *argv0)