[thirdparty/git.git] / trace2 / tr2_tgt_normal.c

#include "cache.h"
#include "config.h"
#include "run-command.h"
#include "quote.h"
#include "version.h"
#include "trace2/tr2_dst.h"
#include "trace2/tr2_tbuf.h"
#include "trace2/tr2_tgt.h"
#include "trace2/tr2_tls.h"

static struct tr2_dst tr2dst_normal = { "GIT_TR2", 0, 0, 0 };

/*
 * Set this environment variable to true to omit the "<time> <file>:<line>"
 * fields from each line written to the builtin normal target.
 *
 * Unit tests may want to use this to help with testing.
 */
#define TR2_ENVVAR_NORMAL_BRIEF "GIT_TR2_BRIEF"
static int tr2env_normal_brief;

#define TR2FMT_NORMAL_FL_WIDTH (50)

static int fn_init(void)
{
	int want = tr2_dst_trace_want(&tr2dst_normal);
	int want_brief;
	char *brief;

	if (!want)
		return want;

	brief = getenv(TR2_ENVVAR_NORMAL_BRIEF);
	if (brief && *brief &&
	    ((want_brief = git_parse_maybe_bool(brief)) != -1))
		tr2env_normal_brief = want_brief;

	return want;
}

static void fn_term(void)
{
	tr2_dst_trace_disable(&tr2dst_normal);
}

static void normal_fmt_prepare(const char *file, int line, struct strbuf *buf)
{
	strbuf_setlen(buf, 0);

	if (!tr2env_normal_brief) {
		struct tr2_tbuf tb_now;

		tr2_tbuf_local_time(&tb_now);
		strbuf_addstr(buf, tb_now.buf);
		strbuf_addch(buf, ' ');

		if (file && *file)
			strbuf_addf(buf, "%s:%d ", file, line);
		while (buf->len < TR2FMT_NORMAL_FL_WIDTH)
			strbuf_addch(buf, ' ');
	}
}

static void normal_io_write_fl(const char *file, int line,
			       const struct strbuf *buf_payload)
{
	struct strbuf buf_line = STRBUF_INIT;

	normal_fmt_prepare(file, line, &buf_line);
	strbuf_addbuf(&buf_line, buf_payload);
	tr2_dst_write_line(&tr2dst_normal, &buf_line);
	strbuf_release(&buf_line);
}

static void fn_version_fl(const char *file, int line)
{
	struct strbuf buf_payload = STRBUF_INIT;

	strbuf_addf(&buf_payload, "version %s", git_version_string);
	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_start_fl(const char *file, int line, const char **argv)
{
	struct strbuf buf_payload = STRBUF_INIT;

	strbuf_addstr(&buf_payload, "start ");
	sq_quote_argv_pretty(&buf_payload, argv);
	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_exit_fl(const char *file, int line, uint64_t us_elapsed_absolute,
		       int code)
{
	struct strbuf buf_payload = STRBUF_INIT;
	double elapsed = (double)us_elapsed_absolute / 1000000.0;

	strbuf_addf(&buf_payload, "exit elapsed:%.6f code:%d", elapsed, code);
	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_signal(uint64_t us_elapsed_absolute, int signo)
{
	struct strbuf buf_payload = STRBUF_INIT;
	double elapsed = (double)us_elapsed_absolute / 1000000.0;

	strbuf_addf(&buf_payload, "signal elapsed:%.6f code:%d", elapsed,
		    signo);
	normal_io_write_fl(__FILE__, __LINE__, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_atexit(uint64_t us_elapsed_absolute, int code)
{
	struct strbuf buf_payload = STRBUF_INIT;
	double elapsed = (double)us_elapsed_absolute / 1000000.0;

	strbuf_addf(&buf_payload, "atexit elapsed:%.6f code:%d", elapsed, code);
	normal_io_write_fl(__FILE__, __LINE__, &buf_payload);
	strbuf_release(&buf_payload);
}

static void maybe_append_string_va(struct strbuf *buf, const char *fmt,
				   va_list ap)
{
	if (fmt && *fmt && ap) {
		va_list copy_ap;

		va_copy(copy_ap, ap);
		strbuf_vaddf(buf, fmt, copy_ap);
		va_end(copy_ap);
		return;
	}

	if (fmt && *fmt) {
		strbuf_addstr(buf, fmt);
		return;
	}
}

static void fn_error_va_fl(const char *file, int line, const char *fmt,
			   va_list ap)
{
	struct strbuf buf_payload = STRBUF_INIT;

	strbuf_addstr(&buf_payload, "error ");
	maybe_append_string_va(&buf_payload, fmt, ap);
	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_command_path_fl(const char *file, int line, const char *pathname)
{
	struct strbuf buf_payload = STRBUF_INIT;

	strbuf_addf(&buf_payload, "cmd_path %s", pathname);
	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_command_name_fl(const char *file, int line, const char *name,
			       const char *hierarchy)
{
	struct strbuf buf_payload = STRBUF_INIT;

	strbuf_addf(&buf_payload, "cmd_name %s", name);
	if (hierarchy && *hierarchy)
		strbuf_addf(&buf_payload, " (%s)", hierarchy);
	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_command_mode_fl(const char *file, int line, const char *mode)
{
	struct strbuf buf_payload = STRBUF_INIT;

	strbuf_addf(&buf_payload, "cmd_mode %s", mode);
	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_alias_fl(const char *file, int line, const char *alias,
			const char **argv)
{
	struct strbuf buf_payload = STRBUF_INIT;

	strbuf_addf(&buf_payload, "alias %s ->", alias);
	sq_quote_argv_pretty(&buf_payload, argv);
	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_child_start_fl(const char *file, int line,
			      uint64_t us_elapsed_absolute,
			      const struct child_process *cmd)
{
	struct strbuf buf_payload = STRBUF_INIT;

	strbuf_addf(&buf_payload, "child_start[%d] ", cmd->trace2_child_id);

	if (cmd->dir) {
		strbuf_addstr(&buf_payload, " cd");
		sq_quote_buf_pretty(&buf_payload, cmd->dir);
		strbuf_addstr(&buf_payload, "; ");
	}

	/*
	 * TODO if (cmd->env) { Consider dumping changes to environment. }
	 * See trace_add_env() in run-command.c as used by original trace.c
	 */

	if (cmd->git_cmd)
		strbuf_addstr(&buf_payload, "git");
	sq_quote_argv_pretty(&buf_payload, cmd->argv);

	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_child_exit_fl(const char *file, int line,
			     uint64_t us_elapsed_absolute, int cid, int pid,
			     int code, uint64_t us_elapsed_child)
{
	struct strbuf buf_payload = STRBUF_INIT;
	double elapsed = (double)us_elapsed_child / 1000000.0;

	strbuf_addf(&buf_payload, "child_exit[%d] pid:%d code:%d elapsed:%.6f",
		    cid, pid, code, elapsed);
	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_exec_fl(const char *file, int line, uint64_t us_elapsed_absolute,
		       int exec_id, const char *exe, const char **argv)
{
	struct strbuf buf_payload = STRBUF_INIT;

	strbuf_addf(&buf_payload, "exec[%d] ", exec_id);
	if (exe)
		strbuf_addstr(&buf_payload, exe);
	sq_quote_argv_pretty(&buf_payload, argv);
	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_exec_result_fl(const char *file, int line,
			      uint64_t us_elapsed_absolute, int exec_id,
			      int code)
{
	struct strbuf buf_payload = STRBUF_INIT;

	strbuf_addf(&buf_payload, "exec_result[%d] code:%d", exec_id, code);
	if (code > 0)
		strbuf_addf(&buf_payload, " err:%s", strerror(code));
	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_param_fl(const char *file, int line, const char *param,
			const char *value)
{
	struct strbuf buf_payload = STRBUF_INIT;

	strbuf_addf(&buf_payload, "def_param %s=%s", param, value);
	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_repo_fl(const char *file, int line,
		       const struct repository *repo)
{
	struct strbuf buf_payload = STRBUF_INIT;

	strbuf_addstr(&buf_payload, "worktree ");
	sq_quote_buf_pretty(&buf_payload, repo->worktree);
	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

static void fn_printf_va_fl(const char *file, int line,
			    uint64_t us_elapsed_absolute, const char *fmt,
			    va_list ap)
{
	struct strbuf buf_payload = STRBUF_INIT;

	maybe_append_string_va(&buf_payload, fmt, ap);
	normal_io_write_fl(file, line, &buf_payload);
	strbuf_release(&buf_payload);
}

struct tr2_tgt tr2_tgt_normal = {
	&tr2dst_normal,

	fn_init,
	fn_term,

	fn_version_fl,
	fn_start_fl,
	fn_exit_fl,
	fn_signal,
	fn_atexit,
	fn_error_va_fl,
	fn_command_path_fl,
	fn_command_name_fl,
	fn_command_mode_fl,
	fn_alias_fl,
	fn_child_start_fl,
	fn_child_exit_fl,
	NULL, /* thread_start */
	NULL, /* thread_exit */
	fn_exec_fl,
	fn_exec_result_fl,
	fn_param_fl,
	fn_repo_fl,
	NULL, /* region_enter */
	NULL, /* region_leave */
	NULL, /* data */
	NULL, /* data_json */
	fn_printf_va_fl,
};
Commit	Line	Data
ee4512ed JH	1	#include "cache.h"
	2	#include "config.h"
	3	#include "run-command.h"
	4	#include "quote.h"
	5	#include "version.h"
	6	#include "trace2/tr2_dst.h"
	7	#include "trace2/tr2_tbuf.h"
	8	#include "trace2/tr2_tgt.h"
	9	#include "trace2/tr2_tls.h"
	10
	11	static struct tr2_dst tr2dst_normal = { "GIT_TR2", 0, 0, 0 };
	12
	13	/*
	14	* Set this environment variable to true to omit the "<time> <file>:<line>"
	15	* fields from each line written to the builtin normal target.
	16	*
	17	* Unit tests may want to use this to help with testing.
	18	*/
	19	#define TR2_ENVVAR_NORMAL_BRIEF "GIT_TR2_BRIEF"
	20	static int tr2env_normal_brief;
	21
	22	#define TR2FMT_NORMAL_FL_WIDTH (50)
	23
	24	static int fn_init(void)
	25	{
	26	int want = tr2_dst_trace_want(&tr2dst_normal);
	27	int want_brief;
	28	char *brief;
	29
	30	if (!want)
	31	return want;
	32
	33	brief = getenv(TR2_ENVVAR_NORMAL_BRIEF);
	34	if (brief && *brief &&
	35	((want_brief = git_parse_maybe_bool(brief)) != -1))
	36	tr2env_normal_brief = want_brief;
	37
	38	return want;
	39	}
	40
	41	static void fn_term(void)
	42	{
	43	tr2_dst_trace_disable(&tr2dst_normal);
	44	}
	45
	46	static void normal_fmt_prepare(const char file, int line, struct strbuf buf)
	47	{
	48	strbuf_setlen(buf, 0);
	49
	50	if (!tr2env_normal_brief) {
	51	struct tr2_tbuf tb_now;
	52
	53	tr2_tbuf_local_time(&tb_now);
	54	strbuf_addstr(buf, tb_now.buf);
	55	strbuf_addch(buf, ' ');
	56
	57	if (file && *file)
	58	strbuf_addf(buf, "%s:%d ", file, line);
	59	while (buf->len < TR2FMT_NORMAL_FL_WIDTH)
	60	strbuf_addch(buf, ' ');
	61	}
	62	}
	63
	64	static void normal_io_write_fl(const char *file, int line,
65	const struct strbuf *buf_payload)
66	{
67	struct strbuf buf_line = STRBUF_INIT;
68
69	normal_fmt_prepare(file, line, &buf_line);
70	strbuf_addbuf(&buf_line, buf_payload);
71	tr2_dst_write_line(&tr2dst_normal, &buf_line);
72	strbuf_release(&buf_line);
73	}
74
75	static void fn_version_fl(const char *file, int line)
76	{
77	struct strbuf buf_payload = STRBUF_INIT;
78
79	strbuf_addf(&buf_payload, "version %s", git_version_string);
80	normal_io_write_fl(file, line, &buf_payload);
81	strbuf_release(&buf_payload);
82	}
83
84	static void fn_start_fl(const char file, int line, const char *argv)
85	{
86	struct strbuf buf_payload = STRBUF_INIT;
87
88	strbuf_addstr(&buf_payload, "start ");
89	sq_quote_argv_pretty(&buf_payload, argv);
90	normal_io_write_fl(file, line, &buf_payload);
91	strbuf_release(&buf_payload);
92	}
93
94	static void fn_exit_fl(const char *file, int line, uint64_t us_elapsed_absolute,
95	int code)
96	{
97	struct strbuf buf_payload = STRBUF_INIT;
98	double elapsed = (double)us_elapsed_absolute / 1000000.0;
99
100	strbuf_addf(&buf_payload, "exit elapsed:%.6f code:%d", elapsed, code);
101	normal_io_write_fl(file, line, &buf_payload);
102	strbuf_release(&buf_payload);
103	}
104
105	static void fn_signal(uint64_t us_elapsed_absolute, int signo)
106	{
107	struct strbuf buf_payload = STRBUF_INIT;
108	double elapsed = (double)us_elapsed_absolute / 1000000.0;
109
110	strbuf_addf(&buf_payload, "signal elapsed:%.6f code:%d", elapsed,
111	signo);
112	normal_io_write_fl(__FILE__, __LINE__, &buf_payload);
113	strbuf_release(&buf_payload);
114	}
115
116	static void fn_atexit(uint64_t us_elapsed_absolute, int code)
117	{
118	struct strbuf buf_payload = STRBUF_INIT;
119	double elapsed = (double)us_elapsed_absolute / 1000000.0;
120
121	strbuf_addf(&buf_payload, "atexit elapsed:%.6f code:%d", elapsed, code);
122	normal_io_write_fl(__FILE__, __LINE__, &buf_payload);
123	strbuf_release(&buf_payload);
124	}
125
126	static void maybe_append_string_va(struct strbuf buf, const char fmt,
127	va_list ap)
128	{
129	if (fmt && *fmt && ap) {
130	va_list copy_ap;
131
132	va_copy(copy_ap, ap);
133	strbuf_vaddf(buf, fmt, copy_ap);
134	va_end(copy_ap);
135	return;
136	}
137
138	if (fmt && *fmt) {
139	strbuf_addstr(buf, fmt);
140	return;
141	}
142	}
143
144	static void fn_error_va_fl(const char file, int line, const char fmt,
145	va_list ap)
146	{
147	struct strbuf buf_payload = STRBUF_INIT;
148
149	strbuf_addstr(&buf_payload, "error ");
150	maybe_append_string_va(&buf_payload, fmt, ap);
151	normal_io_write_fl(file, line, &buf_payload);
152	strbuf_release(&buf_payload);
153	}
154
155	static void fn_command_path_fl(const char file, int line, const char pathname)
156	{
157	struct strbuf buf_payload = STRBUF_INIT;
158
159	strbuf_addf(&buf_payload, "cmd_path %s", pathname);
160	normal_io_write_fl(file, line, &buf_payload);
161	strbuf_release(&buf_payload);
162	}
163
164	static void fn_command_name_fl(const char file, int line, const char name,
165	const char *hierarchy)
166	{
167	struct strbuf buf_payload = STRBUF_INIT;
168
169	strbuf_addf(&buf_payload, "cmd_name %s", name);
170	if (hierarchy && *hierarchy)
171	strbuf_addf(&buf_payload, " (%s)", hierarchy);
172	normal_io_write_fl(file, line, &buf_payload);
173	strbuf_release(&buf_payload);
174	}
175
176	static void fn_command_mode_fl(const char file, int line, const char mode)
177	{
178	struct strbuf buf_payload = STRBUF_INIT;
179
180	strbuf_addf(&buf_payload, "cmd_mode %s", mode);
181	normal_io_write_fl(file, line, &buf_payload);
182	strbuf_release(&buf_payload);
183	}
184
185	static void fn_alias_fl(const char file, int line, const char alias,
186	const char **argv)
187	{
188	struct strbuf buf_payload = STRBUF_INIT;
189
190	strbuf_addf(&buf_payload, "alias %s ->", alias);
191	sq_quote_argv_pretty(&buf_payload, argv);
192	normal_io_write_fl(file, line, &buf_payload);
193	strbuf_release(&buf_payload);
194	}
195
196	static void fn_child_start_fl(const char *file, int line,
197	uint64_t us_elapsed_absolute,
198	const struct child_process *cmd)
199	{
200	struct strbuf buf_payload = STRBUF_INIT;
201
202	strbuf_addf(&buf_payload, "child_start[%d] ", cmd->trace2_child_id);
203
204	if (cmd->dir) {
205	strbuf_addstr(&buf_payload, " cd");
206	sq_quote_buf_pretty(&buf_payload, cmd->dir);
207	strbuf_addstr(&buf_payload, "; ");
208	}
209
210	/*
211	* TODO if (cmd->env) { Consider dumping changes to environment. }
212	* See trace_add_env() in run-command.c as used by original trace.c
213	*/
214
215	if (cmd->git_cmd)
216	strbuf_addstr(&buf_payload, "git");
217	sq_quote_argv_pretty(&buf_payload, cmd->argv);
218
219	normal_io_write_fl(file, line, &buf_payload);
220	strbuf_release(&buf_payload);
221	}
222
223	static void fn_child_exit_fl(const char *file, int line,
224	uint64_t us_elapsed_absolute, int cid, int pid,
225	int code, uint64_t us_elapsed_child)
226	{
227	struct strbuf buf_payload = STRBUF_INIT;
228	double elapsed = (double)us_elapsed_child / 1000000.0;
229
230	strbuf_addf(&buf_payload, "child_exit[%d] pid:%d code:%d elapsed:%.6f",
231	cid, pid, code, elapsed);
232	normal_io_write_fl(file, line, &buf_payload);
233	strbuf_release(&buf_payload);
234	}
235
236	static void fn_exec_fl(const char *file, int line, uint64_t us_elapsed_absolute,
237	int exec_id, const char exe, const char *argv)
238	{
239	struct strbuf buf_payload = STRBUF_INIT;
240
241	strbuf_addf(&buf_payload, "exec[%d] ", exec_id);
242	if (exe)
243	strbuf_addstr(&buf_payload, exe);
244	sq_quote_argv_pretty(&buf_payload, argv);
245	normal_io_write_fl(file, line, &buf_payload);
246	strbuf_release(&buf_payload);
247	}
248
249	static void fn_exec_result_fl(const char *file, int line,
250	uint64_t us_elapsed_absolute, int exec_id,
251	int code)
252	{
253	struct strbuf buf_payload = STRBUF_INIT;
254
255	strbuf_addf(&buf_payload, "exec_result[%d] code:%d", exec_id, code);
256	if (code > 0)
257	strbuf_addf(&buf_payload, " err:%s", strerror(code));
258	normal_io_write_fl(file, line, &buf_payload);
259	strbuf_release(&buf_payload);
260	}
261
262	static void fn_param_fl(const char file, int line, const char param,
263	const char *value)
264	{
265	struct strbuf buf_payload = STRBUF_INIT;
266
267	strbuf_addf(&buf_payload, "def_param %s=%s", param, value);
268	normal_io_write_fl(file, line, &buf_payload);
269	strbuf_release(&buf_payload);
270	}
271
272	static void fn_repo_fl(const char *file, int line,
273	const struct repository *repo)
274	{
275	struct strbuf buf_payload = STRBUF_INIT;
276
277	strbuf_addstr(&buf_payload, "worktree ");
278	sq_quote_buf_pretty(&buf_payload, repo->worktree);
279	normal_io_write_fl(file, line, &buf_payload);
280	strbuf_release(&buf_payload);
281	}
282
283	static void fn_printf_va_fl(const char *file, int line,
284	uint64_t us_elapsed_absolute, const char *fmt,
285	va_list ap)
286	{
287	struct strbuf buf_payload = STRBUF_INIT;
288
289	maybe_append_string_va(&buf_payload, fmt, ap);
290	normal_io_write_fl(file, line, &buf_payload);
291	strbuf_release(&buf_payload);
292	}
293
294	struct tr2_tgt tr2_tgt_normal = {
295	&tr2dst_normal,
296
297	fn_init,
298	fn_term,
299
300	fn_version_fl,
301	fn_start_fl,
302	fn_exit_fl,
303	fn_signal,
304	fn_atexit,
305	fn_error_va_fl,
306	fn_command_path_fl,
307	fn_command_name_fl,
308	fn_command_mode_fl,
309	fn_alias_fl,
310	fn_child_start_fl,
311	fn_child_exit_fl,
312	NULL, /* thread_start */
313	NULL, /* thread_exit */
314	fn_exec_fl,
315	fn_exec_result_fl,
316	fn_param_fl,
317	fn_repo_fl,
318	NULL, /* region_enter */
319	NULL, /* region_leave */
320	NULL, /* data */
321	NULL, /* data_json */
322	fn_printf_va_fl,
323	};