projects / babeltrace.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
lib: introduce bt_message_iterator_class
[babeltrace.git] / src / plugins / text / pretty / pretty.c
CommitLineData
7a278c8e 1/*
2e339de1 2 * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
f504043c 3 * Copyright 2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
7a278c8e
JG		 4 *
5 * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23 * SOFTWARE.
24 */
25
88488ff5
SM		 26#define BT_COMP_LOG_SELF_COMP self_comp
27#define BT_LOG_OUTPUT_LEVEL log_level
28#define BT_LOG_TAG "PLUGIN/SINK.TEXT.PRETTY"
29#include "logging/comp-logging.h"
30
3fadfbc0 31#include <babeltrace2/babeltrace.h>
578e048b
MJ		 32#include "compat/compiler.h"
33#include "common/common.h"
bfd20a42 34#include <stdio.h>
39cfa40f 35#include <stdbool.h>
bac67f0f 36#include <glib.h>
9957b01a 37#include <string.h>
578e048b 38#include "common/assert.h"
88488ff5 39#include "plugins/common/param-validation/param-validation.h"
6405967d 40
3228cc1d
PP		 41#include "pretty.h"
42
5badd463
PP		 43static
44const char * const in_port_name = "in";
45
bfd20a42 46static
3228cc1d 47void destroy_pretty_data(struct pretty_component *pretty)
bac67f0f 48{
27a1afa7
SM		 49 if (!pretty) {
50 goto end;
51 }
52
96eccbbc
SM		 53 bt_self_component_port_input_message_iterator_put_ref(pretty->iterator);
54
5280f742
PP		 55 if (pretty->string) {
56 (void) g_string_free(pretty->string, TRUE);
57 }
58
59 if (pretty->tmp_string) {
60 (void) g_string_free(pretty->tmp_string, TRUE);
61 }
62
3228cc1d 63 if (pretty->out != stdout) {
77986bad
JD		 64 int ret;
65
3228cc1d 66 ret = fclose(pretty->out);
77986bad
JD		 67 if (ret) {
68 perror("close output file");
69 }
70 }
3228cc1d 71 g_free(pretty->options.output_path);
3228cc1d 72 g_free(pretty);
27a1afa7
SM		 73
74end:
75 return;
bac67f0f
JG		 76}
77
b25bd455 78static
3228cc1d 79struct pretty_component *create_pretty(void)
bac67f0f 80{
3228cc1d 81 struct pretty_component *pretty;
541b0a11 82
3228cc1d
PP		 83 pretty = g_new0(struct pretty_component, 1);
84 if (!pretty) {
541b0a11
JG		 85 goto end;
86 }
3228cc1d
PP		 87 pretty->string = g_string_new("");
88 if (!pretty->string) {
6a18b281
MD		 89 goto error;
90 }
5280f742
PP		 91 pretty->tmp_string = g_string_new("");
92 if (!pretty->tmp_string) {
93 goto error;
94 }
541b0a11 95end:
3228cc1d 96 return pretty;
6a18b281
MD		 97
98error:
3228cc1d 99 g_free(pretty);
6a18b281 100 return NULL;
bac67f0f
JG		 101}
102
3228cc1d 103BT_HIDDEN
b19ff26f 104void pretty_finalize(bt_self_component_sink *comp)
b25bd455 105{
d94d92ac
PP		 106 destroy_pretty_data(
107 bt_self_component_get_data(
707b7d35 108 bt_self_component_sink_as_self_component(comp)));
b25bd455
JG		 109}
110
bac67f0f 111static
a3f0c7db 112bt_message_iterator_class_next_method_status handle_message(
d94d92ac 113 struct pretty_component *pretty,
d6e69534 114 const bt_message *message)
4c1456f0 115{
a3f0c7db
SM		 116 bt_message_iterator_class_next_method_status ret =
117 BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
541b0a11 118
98b15851 119 BT_ASSERT_DBG(pretty);
541b0a11 120
d6e69534 121 switch (bt_message_get_type(message)) {
d6e69534
PP		 122 case BT_MESSAGE_TYPE_EVENT:
123 if (pretty_print_event(pretty, message)) {
a3f0c7db 124 ret = BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
d94d92ac 125 }
7cdc2bab 126 break;
8e53bed4
PP		 127 case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
128 case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
129 if (pretty_print_discarded_items(pretty, message)) {
a3f0c7db 130 ret = BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
8e53bed4
PP		 131 }
132 break;
7cdc2bab 133 default:
f42867e2 134 break;
78586d8a 135 }
b5e978f4 136
541b0a11 137 return ret;
4c1456f0 138}
bac67f0f 139
3228cc1d 140BT_HIDDEN
d24d5663
PP		 141bt_component_class_sink_graph_is_configured_method_status
142pretty_graph_is_configured(bt_self_component_sink *comp)
75e1829b 143{
e803df70
SM		 144 bt_component_class_sink_graph_is_configured_method_status status;
145 bt_self_component_port_input_message_iterator_create_from_sink_component_status
146 msg_iter_status;
3228cc1d 147 struct pretty_component *pretty;
75e1829b 148
d94d92ac 149 pretty = bt_self_component_get_data(
707b7d35 150 bt_self_component_sink_as_self_component(comp));
f6ccaed9 151 BT_ASSERT(pretty);
d94d92ac 152 BT_ASSERT(!pretty->iterator);
e803df70 153 msg_iter_status = bt_self_component_port_input_message_iterator_create_from_sink_component(
ca02df0a 154 comp, bt_self_component_sink_borrow_input_port_by_name(comp,
e803df70
SM		 155 in_port_name), &pretty->iterator);
156 if (msg_iter_status != BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_CREATE_FROM_SINK_COMPONENT_STATUS_OK) {
157 status = (int) msg_iter_status;
158 goto end;
75e1829b 159 }
72b913fb 160
e803df70
SM		 161 status = BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK;
162
163end:
bf55043c 164 return status;
75e1829b
JG		 165}
166
3228cc1d 167BT_HIDDEN
d24d5663 168bt_component_class_sink_consume_method_status pretty_consume(
b19ff26f 169 bt_self_component_sink *comp)
fec2a9f2 170{
b51acf23
JR		 171 bt_component_class_sink_consume_method_status ret =
172 BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
d6e69534
PP		 173 bt_message_array_const msgs;
174 bt_self_component_port_input_message_iterator *it;
d94d92ac 175 struct pretty_component *pretty = bt_self_component_get_data(
707b7d35 176 bt_self_component_sink_as_self_component(comp));
d24d5663 177 bt_message_iterator_next_status next_status;
d4393e08
PP		 178 uint64_t count = 0;
179 uint64_t i = 0;
fec2a9f2 180
d94d92ac 181 it = pretty->iterator;
d24d5663 182 next_status = bt_self_component_port_input_message_iterator_next(it,
d6e69534 183 &msgs, &count);
0d8b4d8e 184
d24d5663
PP		 185 switch (next_status) {
186 case BT_MESSAGE_ITERATOR_NEXT_STATUS_OK:
d94d92ac 187 break;
d24d5663
PP		 188 case BT_MESSAGE_ITERATOR_NEXT_STATUS_MEMORY_ERROR:
189 case BT_MESSAGE_ITERATOR_NEXT_STATUS_AGAIN:
190 ret = (int) next_status;
d94d92ac 191 goto end;
d24d5663
PP		 192 case BT_MESSAGE_ITERATOR_NEXT_STATUS_END:
193 ret = (int) next_status;
d6e69534 194 BT_SELF_COMPONENT_PORT_INPUT_MESSAGE_ITERATOR_PUT_REF_AND_RESET(
c5b9b441 195 pretty->iterator);
dfa6653c 196 goto end;
dfa6653c 197 default:
d24d5663 198 ret = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_ERROR;
dfa6653c 199 goto end;
fec2a9f2
JG		 200 }
201
98b15851 202 BT_ASSERT_DBG(next_status == BT_MESSAGE_ITERATOR_NEXT_STATUS_OK);
d4393e08
PP		 203
204 for (i = 0; i < count; i++) {
9275bef4 205 ret = (int) handle_message(pretty, msgs[i]);
d4393e08
PP		 206 if (ret) {
207 goto end;
208 }
209
d6e69534 210 bt_message_put_ref(msgs[i]);
d4393e08 211 }
dfa6653c 212
fec2a9f2 213end:
d4393e08 214 for (; i < count; i++) {
d6e69534 215 bt_message_put_ref(msgs[i]);
d4393e08
PP		 216 }
217
fec2a9f2
JG		 218 return ret;
219}
220
6e1bc0df 221static
b19ff26f 222void apply_one_string(const char *key, const bt_value *params, char **option)
6e1bc0df 223{
b19ff26f 224 const bt_value *value = NULL;
6e1bc0df
MD		 225 const char *str;
226
05e21286 227 value = bt_value_map_borrow_entry_value_const(params, key);
6e1bc0df
MD		 228 if (!value) {
229 goto end;
230 }
88488ff5 231
601b0d3c 232 str = bt_value_string_get(value);
6e1bc0df 233 *option = g_strdup(str);
601b0d3c 234
6e1bc0df 235end:
d94d92ac 236 return;
6e1bc0df
MD		 237}
238
88488ff5
SM		 239/*
240 * Apply parameter with key `key` to `option`. Use `def` as the value, if
241 * the parameter is not specified.
242 */
243
6e1bc0df 244static
88488ff5
SM		 245void apply_one_bool_with_default(const char *key, const bt_value *params,
246 bool *option, bool def)
6e1bc0df 247{
88488ff5 248 const bt_value *value;
6e1bc0df 249
05e21286 250 value = bt_value_map_borrow_entry_value_const(params, key);
88488ff5
SM		 251 if (value) {
252 bt_bool bool_val = bt_value_bool_get(value);
a82e90e8 253
88488ff5
SM		 254 *option = (bool) bool_val;
255 } else {
256 *option = def;
257 }
6e1bc0df
MD		 258}
259
ad96d936 260static
88488ff5 261void apply_one_bool_if_specified(const char *key, const bt_value *params, bool *option)
ad96d936 262{
88488ff5
SM		 263 const bt_value *value;
264
265 value = bt_value_map_borrow_entry_value_const(params, key);
266 if (value) {
267 bt_bool bool_val = bt_value_bool_get(value);
268
269 *option = (bool) bool_val;
270 }
ad96d936
PP		 271}
272
77986bad 273static
d94d92ac 274int open_output_file(struct pretty_component *pretty)
77986bad 275{
d94d92ac 276 int ret = 0;
77986bad 277
3228cc1d 278 if (!pretty->options.output_path) {
77986bad
JD		 279 goto end;
280 }
281
3228cc1d
PP		 282 pretty->out = fopen(pretty->options.output_path, "w");
283 if (!pretty->out) {
77986bad
JD		 284 goto error;
285 }
286
287 goto end;
288
289error:
d94d92ac
PP		 290 ret = -1;
291
77986bad
JD		 292end:
293 return ret;
294}
295
88488ff5
SM		 296static const char *color_choices[] = { "never", "auto", "always", NULL };
297static const char *show_hide_choices[] = { "show", "hide", NULL };
298
d9120ccb 299static
88488ff5
SM		 300struct bt_param_validation_map_value_entry_descr pretty_params[] = {
301 { "color", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { BT_VALUE_TYPE_STRING, .string = {
302 .choices = color_choices,
303 } } },
304 { "path", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_STRING } },
305 { "no-delta", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
306 { "clock-cycles", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
307 { "clock-seconds", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
308 { "clock-date", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
309 { "clock-gmt", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
310 { "verbose", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
311
312 { "name-default", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { BT_VALUE_TYPE_STRING, .string = {
313 .choices = show_hide_choices,
314 } } },
315 { "name-payload", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
316 { "name-context", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
317 { "name-scope", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
318 { "name-header", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
319
320 { "field-default", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { BT_VALUE_TYPE_STRING, .string = {
321 .choices = show_hide_choices,
322 } } },
323 { "field-trace", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
324 { "field-trace:hostname", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
325 { "field-trace:domain", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
326 { "field-trace:procname", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
327 { "field-trace:vpid", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
328 { "field-loglevel", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
329 { "field-emf", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
330 { "field-callsite", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
331 BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_END
332};
333
6e1bc0df 334static
88488ff5
SM		 335bt_component_class_initialize_method_status apply_params(
336 struct pretty_component *pretty, const bt_value *params,
337 bt_self_component *self_comp, bt_logging_level log_level)
6e1bc0df 338{
88488ff5
SM		 339 int ret;
340 const bt_value *value;
341 bt_component_class_initialize_method_status status;
342 enum bt_param_validation_status validation_status;
343 gchar *validate_error = NULL;
344
345 validation_status = bt_param_validation_validate(params,
346 pretty_params, &validate_error);
347 if (validation_status == BT_PARAM_VALIDATION_STATUS_MEMORY_ERROR) {
348 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
6e1bc0df 349 goto end;
88488ff5
SM		 350 } else if (validation_status == BT_PARAM_VALIDATION_STATUS_VALIDATION_ERROR) {
351 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
352 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "%s", validate_error);
6e1bc0df
MD		 353 goto end;
354 }
d24d5663 355
6e1bc0df 356 /* Known parameters. */
3228cc1d 357 pretty->options.color = PRETTY_COLOR_OPT_AUTO;
88488ff5
SM		 358 value = bt_value_map_borrow_entry_value_const(params, "color");
359 if (value) {
360 const char *color = bt_value_string_get(value);
601b0d3c
PP		 361
362 if (strcmp(color, "never") == 0) {
363 pretty->options.color = PRETTY_COLOR_OPT_NEVER;
364 } else if (strcmp(color, "auto") == 0) {
365 pretty->options.color = PRETTY_COLOR_OPT_AUTO;
ad96d936 366 } else {
88488ff5
SM		 367 BT_ASSERT(strcmp(color, "always") == 0);
368 pretty->options.color = PRETTY_COLOR_OPT_ALWAYS;
ad96d936 369 }
ad96d936
PP		 370 }
371
d94d92ac 372 apply_one_string("path", params, &pretty->options.output_path);
3228cc1d 373 ret = open_output_file(pretty);
d94d92ac 374 if (ret) {
88488ff5 375 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
77986bad
JD		 376 goto end;
377 }
6e1bc0df 378
88488ff5
SM		 379 apply_one_bool_with_default("no-delta", params,
380 &pretty->options.print_delta_field, false);
381 /* Reverse logic. */
382 pretty->options.print_delta_field = !pretty->options.print_delta_field;
6e1bc0df 383
88488ff5
SM		 384 apply_one_bool_with_default("clock-cycles", params,
385 &pretty->options.print_timestamp_cycles, false);
6e1bc0df 386
88488ff5
SM		 387 apply_one_bool_with_default("clock-seconds", params,
388 &pretty->options.clock_seconds , false);
6e1bc0df 389
88488ff5
SM		 390 apply_one_bool_with_default("clock-date", params,
391 &pretty->options.clock_date, false);
6e1bc0df 392
88488ff5
SM		 393 apply_one_bool_with_default("clock-gmt", params,
394 &pretty->options.clock_gmt, false);
6e1bc0df 395
88488ff5
SM		 396 apply_one_bool_with_default("verbose", params,
397 &pretty->options.verbose, false);
a263021c 398
6e1bc0df 399 /* Names. */
88488ff5
SM		 400 value = bt_value_map_borrow_entry_value_const(params, "name-default");
401 if (value) {
402 const char *str = bt_value_string_get(value);
403
404 if (strcmp(str, "show") == 0) {
405 pretty->options.name_default = PRETTY_DEFAULT_SHOW;
406 } else {
407 BT_ASSERT(strcmp(str, "hide") == 0);
408 pretty->options.name_default = PRETTY_DEFAULT_HIDE;
409 }
6e1bc0df 410 } else {
88488ff5 411 pretty->options.name_default = PRETTY_DEFAULT_UNSET;
6e1bc0df 412 }
6e1bc0df 413
3228cc1d
PP		 414 switch (pretty->options.name_default) {
415 case PRETTY_DEFAULT_UNSET:
416 pretty->options.print_payload_field_names = true;
417 pretty->options.print_context_field_names = true;
418 pretty->options.print_header_field_names = false;
419 pretty->options.print_scope_field_names = false;
6e1bc0df 420 break;
3228cc1d
PP		 421 case PRETTY_DEFAULT_SHOW:
422 pretty->options.print_payload_field_names = true;
423 pretty->options.print_context_field_names = true;
424 pretty->options.print_header_field_names = true;
425 pretty->options.print_scope_field_names = true;
6e1bc0df 426 break;
3228cc1d
PP		 427 case PRETTY_DEFAULT_HIDE:
428 pretty->options.print_payload_field_names = false;
429 pretty->options.print_context_field_names = false;
430 pretty->options.print_header_field_names = false;
431 pretty->options.print_scope_field_names = false;
6e1bc0df
MD		 432 break;
433 default:
498e7994 434 bt_common_abort();
6e1bc0df
MD		 435 }
436
88488ff5
SM		 437 apply_one_bool_if_specified("name-payload", params,
438 &pretty->options.print_payload_field_names);
6e1bc0df 439
88488ff5
SM		 440 apply_one_bool_if_specified("name-context", params,
441 &pretty->options.print_context_field_names);
6e1bc0df 442
88488ff5
SM		 443 apply_one_bool_if_specified("name-header", params,
444 &pretty->options.print_header_field_names);
6e1bc0df 445
88488ff5
SM		 446 apply_one_bool_if_specified("name-scope", params,
447 &pretty->options.print_scope_field_names);
6e1bc0df
MD		 448
449 /* Fields. */
88488ff5
SM		 450 value = bt_value_map_borrow_entry_value_const(params, "field-default");
451 if (value) {
452 const char *str = bt_value_string_get(value);
453
454 if (strcmp(str, "show") == 0) {
455 pretty->options.field_default = PRETTY_DEFAULT_SHOW;
456 } else {
457 BT_ASSERT(strcmp(str, "hide") == 0);
458 pretty->options.field_default = PRETTY_DEFAULT_HIDE;
459 }
6e1bc0df 460 } else {
88488ff5 461 pretty->options.field_default = PRETTY_DEFAULT_UNSET;
6e1bc0df 462 }
6e1bc0df 463
3228cc1d
PP		 464 switch (pretty->options.field_default) {
465 case PRETTY_DEFAULT_UNSET:
466 pretty->options.print_trace_field = false;
467 pretty->options.print_trace_hostname_field = true;
468 pretty->options.print_trace_domain_field = false;
469 pretty->options.print_trace_procname_field = true;
470 pretty->options.print_trace_vpid_field = true;
471 pretty->options.print_loglevel_field = false;
472 pretty->options.print_emf_field = false;
473 pretty->options.print_callsite_field = false;
6e1bc0df 474 break;
3228cc1d
PP		 475 case PRETTY_DEFAULT_SHOW:
476 pretty->options.print_trace_field = true;
477 pretty->options.print_trace_hostname_field = true;
478 pretty->options.print_trace_domain_field = true;
479 pretty->options.print_trace_procname_field = true;
480 pretty->options.print_trace_vpid_field = true;
481 pretty->options.print_loglevel_field = true;
482 pretty->options.print_emf_field = true;
483 pretty->options.print_callsite_field = true;
6e1bc0df 484 break;
3228cc1d
PP		 485 case PRETTY_DEFAULT_HIDE:
486 pretty->options.print_trace_field = false;
487 pretty->options.print_trace_hostname_field = false;
488 pretty->options.print_trace_domain_field = false;
489 pretty->options.print_trace_procname_field = false;
490 pretty->options.print_trace_vpid_field = false;
491 pretty->options.print_loglevel_field = false;
492 pretty->options.print_emf_field = false;
493 pretty->options.print_callsite_field = false;
6e1bc0df
MD		 494 break;
495 default:
498e7994 496 bt_common_abort();
6e1bc0df
MD		 497 }
498
88488ff5
SM		 499 apply_one_bool_if_specified("field-trace", params,
500 &pretty->options.print_trace_field);
6e1bc0df 501
88488ff5
SM		 502 apply_one_bool_if_specified("field-trace:hostname", params,
503 &pretty->options.print_trace_hostname_field);
6e1bc0df 504
88488ff5
SM		 505 apply_one_bool_if_specified("field-trace:domain", params,
506 &pretty->options.print_trace_domain_field);
6e1bc0df 507
88488ff5
SM		 508 apply_one_bool_if_specified("field-trace:procname", params,
509 &pretty->options.print_trace_procname_field);
6e1bc0df 510
88488ff5
SM		 511 apply_one_bool_if_specified("field-trace:vpid", params,
512 &pretty->options.print_trace_vpid_field);
6e1bc0df 513
88488ff5
SM		 514 apply_one_bool_if_specified("field-loglevel", params,
515 &pretty->options.print_loglevel_field);
6e1bc0df 516
88488ff5
SM		 517 apply_one_bool_if_specified("field-emf", params,
518 &pretty->options.print_emf_field);
6e1bc0df 519
88488ff5
SM		 520 apply_one_bool_if_specified("field-callsite", params,
521 &pretty->options.print_callsite_field);
522
04609487 523 pretty_print_init();
88488ff5 524 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
6e1bc0df 525
6e1bc0df 526end:
88488ff5
SM		 527 g_free(validate_error);
528
529 return status;
6e1bc0df
MD		 530}
531
ad96d936 532static
3228cc1d 533void set_use_colors(struct pretty_component *pretty)
ad96d936 534{
3228cc1d
PP		 535 switch (pretty->options.color) {
536 case PRETTY_COLOR_OPT_ALWAYS:
537 pretty->use_colors = true;
ad96d936 538 break;
3228cc1d
PP		 539 case PRETTY_COLOR_OPT_AUTO:
540 pretty->use_colors = pretty->out == stdout &&
ad96d936
PP		 541 bt_common_colors_supported();
542 break;
3228cc1d
PP		 543 case PRETTY_COLOR_OPT_NEVER:
544 pretty->use_colors = false;
ad96d936
PP		 545 break;
546 }
547}
548
3228cc1d 549BT_HIDDEN
21a9f056 550bt_component_class_initialize_method_status pretty_init(
88488ff5 551 bt_self_component_sink *self_comp_sink,
59225a3e
SM		 552 bt_self_component_sink_configuration *config,
553 const bt_value *params,
c88dd1cb 554 __attribute__((unused)) void *init_method_data)
bac67f0f 555{
88488ff5
SM		 556 bt_component_class_initialize_method_status status;
557 bt_self_component_add_port_status add_port_status;
3228cc1d 558 struct pretty_component *pretty = create_pretty();
88488ff5
SM		 559 bt_self_component *self_comp =
560 bt_self_component_sink_as_self_component(self_comp_sink);
561 const bt_component *comp = bt_self_component_as_component(self_comp);
562 bt_logging_level log_level = bt_component_get_logging_level(comp);
bac67f0f 563
3228cc1d 564 if (!pretty) {
88488ff5
SM		 565 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
566 goto error;
bac67f0f
JG		 567 }
568
88488ff5
SM		 569 add_port_status = bt_self_component_sink_add_input_port(self_comp_sink,
570 in_port_name, NULL, NULL);
571 if (add_port_status != BT_SELF_COMPONENT_ADD_PORT_STATUS_OK) {
572 status = (int) add_port_status;
d24d5663 573 goto error;
b9d103be
PP		 574 }
575
3228cc1d
PP		 576 pretty->out = stdout;
577 pretty->err = stderr;
6e1bc0df 578
3228cc1d
PP		 579 pretty->delta_cycles = -1ULL;
580 pretty->last_cycles_timestamp = -1ULL;
3af83b5a 581
3228cc1d
PP		 582 pretty->delta_real_timestamp = -1ULL;
583 pretty->last_real_timestamp = -1ULL;
3af83b5a 584
88488ff5
SM		 585 status = apply_params(pretty, params, self_comp, log_level);
586 if (status != BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK) {
6e1bc0df
MD		 587 goto error;
588 }
589
3228cc1d 590 set_use_colors(pretty);
88488ff5 591 bt_self_component_set_data(self_comp, pretty);
2b4c4a7c 592
88488ff5
SM		 593 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
594 goto end;
d94d92ac 595
bac67f0f 596error:
3228cc1d 597 destroy_pretty_data(pretty);
88488ff5
SM		 598
599end:
600 return status;
bac67f0f 601}
BabelTrace - Trace Format Babel Tower
This page took 0.100625 seconds and 4 git commands to generate.