src/plugins/text/pretty/pretty.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   5  * Copyright 2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   6  */
   7
   8 #define BT_COMP_LOG_SELF_COMP (pretty->self_comp)
   9 #define BT_LOG_OUTPUT_LEVEL (pretty->log_level)
  10 #define BT_LOG_TAG "PLUGIN/SINK.TEXT.PRETTY"
  11 #include "logging/comp-logging.h"
  12
  13 #include <babeltrace2/babeltrace.h>
  14 #include "compat/compiler.h"
  15 #include "common/common.h"
  16 #include <stdio.h>
  17 #include <stdbool.h>
  18 #include <glib.h>
  19 #include <string.h>
  20 #include "common/assert.h"
  21 #include "plugins/common/param-validation/param-validation.h"
  22
  23 #include "pretty.h"
  24
  25 static
  26 const char * const in_port_name = "in";
  27
  28 static
  29 void destroy_pretty_data(struct pretty_component *pretty)
  30 {
  31         uint64_t i;
  32         if (!pretty) {
  33                 goto end;
  34         }
  35
  36         bt_message_iterator_put_ref(pretty->iterator);
  37
  38         if (pretty->string) {
  39                 (void) g_string_free(pretty->string, TRUE);
  40         }
  41
  42         if (pretty->tmp_string) {
  43                 (void) g_string_free(pretty->tmp_string, TRUE);
  44         }
  45
  46         if (pretty->out != stdout) {
  47                 int ret;
  48
  49                 ret = fclose(pretty->out);
  50                 if (ret) {
  51                         perror("close output file");
  52                 }
  53         }
  54
  55         for (i = 0; i < ENUMERATION_MAX_BITFLAGS_COUNT; i++) {
  56                 if (pretty->enum_bit_labels[i]) {
  57                         g_ptr_array_free(pretty->enum_bit_labels[i], true);
  58                 }
  59         }
  60
  61         g_free(pretty->options.output_path);
  62         g_free(pretty);
  63
  64 end:
  65         return;
  66 }
  67
  68 static
  69 struct pretty_component *create_pretty(void)
  70 {
  71         struct pretty_component *pretty;
  72
  73         pretty = g_new0(struct pretty_component, 1);
  74         if (!pretty) {
  75                 goto end;
  76         }
  77         pretty->string = g_string_new("");
  78         if (!pretty->string) {
  79                 goto error;
  80         }
  81         pretty->tmp_string = g_string_new("");
  82         if (!pretty->tmp_string) {
  83                 goto error;
  84         }
  85 end:
  86         return pretty;
  87
  88 error:
  89         g_free(pretty);
  90         return NULL;
  91 }
  92
  93 BT_HIDDEN
  94 void pretty_finalize(bt_self_component_sink *comp)
  95 {
  96         destroy_pretty_data(
  97                 bt_self_component_get_data(
  98                         bt_self_component_sink_as_self_component(comp)));
  99 }
 100
 101 static
 102 bt_message_iterator_class_next_method_status handle_message(
 103                 struct pretty_component *pretty,
 104                 const bt_message *message)
 105 {
 106         bt_message_iterator_class_next_method_status ret =
 107                 BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_OK;
 108
 109         BT_ASSERT_DBG(pretty);
 110
 111         switch (bt_message_get_type(message)) {
 112         case BT_MESSAGE_TYPE_EVENT:
 113                 if (pretty_print_event(pretty, message)) {
 114                         BT_COMP_LOGE_APPEND_CAUSE(pretty->self_comp,
 115                                 "Failed to print one event.");
 116                         ret = BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
 117                 }
 118                 break;
 119         case BT_MESSAGE_TYPE_DISCARDED_EVENTS:
 120         case BT_MESSAGE_TYPE_DISCARDED_PACKETS:
 121                 if (pretty_print_discarded_items(pretty, message)) {
 122                         BT_COMP_LOGE_APPEND_CAUSE(pretty->self_comp,
 123                                 "Failed to print discarded items.");
 124                         ret = BT_MESSAGE_ITERATOR_CLASS_NEXT_METHOD_STATUS_ERROR;
 125                 }
 126                 break;
 127         default:
 128                 break;
 129         }
 130
 131         return ret;
 132 }
 133
 134 BT_HIDDEN
 135 bt_component_class_sink_graph_is_configured_method_status
 136 pretty_graph_is_configured(bt_self_component_sink *self_comp_sink)
 137 {
 138         bt_component_class_sink_graph_is_configured_method_status status;
 139         bt_message_iterator_create_from_sink_component_status
 140                 msg_iter_status;
 141         struct pretty_component *pretty;
 142         bt_self_component *self_comp =
 143                 bt_self_component_sink_as_self_component(self_comp_sink);
 144         bt_self_component_port_input *in_port;
 145
 146         pretty = bt_self_component_get_data(self_comp);
 147         BT_ASSERT(pretty);
 148         BT_ASSERT(!pretty->iterator);
 149
 150         in_port = bt_self_component_sink_borrow_input_port_by_name(self_comp_sink,
 151                 in_port_name);
 152         if (!bt_port_is_connected(bt_port_input_as_port_const(
 153                         bt_self_component_port_input_as_port_input(in_port)))) {
 154                 BT_COMP_LOGE_APPEND_CAUSE(self_comp, "Single input port is not connected: "
 155                         "port-name=\"%s\"", in_port_name);
 156                 status = BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_ERROR;
 157                 goto end;
 158         }
 159
 160         msg_iter_status = bt_message_iterator_create_from_sink_component(
 161                 self_comp_sink, in_port, &pretty->iterator);
 162         if (msg_iter_status != BT_MESSAGE_ITERATOR_CREATE_FROM_SINK_COMPONENT_STATUS_OK) {
 163                 status = (int) msg_iter_status;
 164                 goto end;
 165         }
 166
 167         status = BT_COMPONENT_CLASS_SINK_GRAPH_IS_CONFIGURED_METHOD_STATUS_OK;
 168
 169 end:
 170         return status;
 171 }
 172
 173 BT_HIDDEN
 174 bt_component_class_sink_consume_method_status pretty_consume(
 175                 bt_self_component_sink *comp)
 176 {
 177         bt_component_class_sink_consume_method_status status;
 178         bt_message_array_const msgs;
 179         bt_message_iterator *it;
 180         struct pretty_component *pretty = bt_self_component_get_data(
 181                 bt_self_component_sink_as_self_component(comp));
 182         bt_message_iterator_next_status next_status;
 183         uint64_t count = 0;
 184         uint64_t i = 0;
 185
 186         it = pretty->iterator;
 187         next_status = bt_message_iterator_next(it,
 188                 &msgs, &count);
 189         if (next_status != BT_MESSAGE_ITERATOR_NEXT_STATUS_OK) {
 190                 status = (int) next_status;
 191                 goto end;
 192         }
 193
 194         for (i = 0; i < count; i++) {
 195                 status = (int) handle_message(pretty, msgs[i]);
 196                 if (status) {
 197                         goto end;
 198                 }
 199
 200                 bt_message_put_ref(msgs[i]);
 201         }
 202
 203         status = BT_COMPONENT_CLASS_SINK_CONSUME_METHOD_STATUS_OK;
 204
 205 end:
 206         for (; i < count; i++) {
 207                 bt_message_put_ref(msgs[i]);
 208         }
 209
 210         return status;
 211 }
 212
 213 static
 214 void apply_one_string(const char *key, const bt_value *params, char **option)
 215 {
 216         const bt_value *value = NULL;
 217         const char *str;
 218
 219         value = bt_value_map_borrow_entry_value_const(params, key);
 220         if (!value) {
 221                 goto end;
 222         }
 223
 224         str = bt_value_string_get(value);
 225         *option = g_strdup(str);
 226
 227 end:
 228         return;
 229 }
 230
 231 /*
 232  * Apply parameter with key `key` to `option`.  Use `def` as the value, if
 233  * the parameter is not specified.
 234  */
 235
 236 static
 237 void apply_one_bool_with_default(const char *key, const bt_value *params,
 238                 bool *option, bool def)
 239 {
 240         const bt_value *value;
 241
 242         value = bt_value_map_borrow_entry_value_const(params, key);
 243         if (value) {
 244                 bt_bool bool_val = bt_value_bool_get(value);
 245
 246                 *option = (bool) bool_val;
 247         } else {
 248                 *option = def;
 249         }
 250 }
 251
 252 static
 253 void apply_one_bool_if_specified(const char *key, const bt_value *params, bool *option)
 254 {
 255         const bt_value *value;
 256
 257         value = bt_value_map_borrow_entry_value_const(params, key);
 258         if (value) {
 259                 bt_bool bool_val = bt_value_bool_get(value);
 260
 261                 *option = (bool) bool_val;
 262         }
 263 }
 264
 265 static
 266 int open_output_file(struct pretty_component *pretty)
 267 {
 268         int ret = 0;
 269
 270         if (!pretty->options.output_path) {
 271                 goto end;
 272         }
 273
 274         pretty->out = fopen(pretty->options.output_path, "w");
 275         if (!pretty->out) {
 276                 goto error;
 277         }
 278
 279         goto end;
 280
 281 error:
 282         ret = -1;
 283
 284 end:
 285         return ret;
 286 }
 287
 288 static const char *color_choices[] = { "never", "auto", "always", NULL };
 289 static const char *show_hide_choices[] = { "show", "hide", NULL };
 290
 291 static
 292 struct bt_param_validation_map_value_entry_descr pretty_params[] = {
 293         { "color", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { BT_VALUE_TYPE_STRING, .string = {
 294                 .choices = color_choices,
 295         } } },
 296         { "path", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_STRING } },
 297         { "no-delta", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 298         { "clock-cycles", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 299         { "clock-seconds", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 300         { "clock-date", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 301         { "clock-gmt", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 302         { "verbose", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 303
 304         { "name-default", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { BT_VALUE_TYPE_STRING, .string = {
 305                 .choices = show_hide_choices,
 306         } } },
 307         { "name-payload", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 308         { "name-context", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 309         { "name-scope", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 310         { "name-header", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 311
 312         { "field-default", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { BT_VALUE_TYPE_STRING, .string = {
 313                 .choices = show_hide_choices,
 314         } } },
 315         { "field-trace", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 316         { "field-trace:hostname", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 317         { "field-trace:domain", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 318         { "field-trace:procname", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 319         { "field-trace:vpid", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 320         { "field-loglevel", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 321         { "field-emf", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 322         { "field-callsite", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 323         { "print-enum-flags", BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_OPTIONAL, { .type = BT_VALUE_TYPE_BOOL } },
 324         BT_PARAM_VALIDATION_MAP_VALUE_ENTRY_END
 325 };
 326
 327 static
 328 bt_component_class_initialize_method_status apply_params(
 329                 struct pretty_component *pretty, const bt_value *params)
 330 {
 331         int ret;
 332         const bt_value *value;
 333         bt_component_class_initialize_method_status status;
 334         enum bt_param_validation_status validation_status;
 335         gchar *validate_error = NULL;
 336
 337         validation_status = bt_param_validation_validate(params,
 338                 pretty_params, &validate_error);
 339         if (validation_status == BT_PARAM_VALIDATION_STATUS_MEMORY_ERROR) {
 340                 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
 341                 goto end;
 342         } else if (validation_status == BT_PARAM_VALIDATION_STATUS_VALIDATION_ERROR) {
 343                 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
 344                 BT_COMP_LOGE_APPEND_CAUSE(pretty->self_comp, "%s", validate_error);
 345                 goto end;
 346         }
 347
 348         /* Known parameters. */
 349         pretty->options.color = PRETTY_COLOR_OPT_AUTO;
 350         value = bt_value_map_borrow_entry_value_const(params, "color");
 351         if (value) {
 352                 const char *color = bt_value_string_get(value);
 353
 354                 if (strcmp(color, "never") == 0) {
 355                         pretty->options.color = PRETTY_COLOR_OPT_NEVER;
 356                 } else if (strcmp(color, "auto") == 0) {
 357                         pretty->options.color = PRETTY_COLOR_OPT_AUTO;
 358                 } else {
 359                         BT_ASSERT(strcmp(color, "always") == 0);
 360                         pretty->options.color = PRETTY_COLOR_OPT_ALWAYS;
 361                 }
 362         }
 363
 364         apply_one_string("path", params, &pretty->options.output_path);
 365         ret = open_output_file(pretty);
 366         if (ret) {
 367                 BT_COMP_LOGE_APPEND_CAUSE(pretty->self_comp,
 368                         "Failed to open output file: %s", validate_error);
 369                 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_ERROR;
 370                 goto end;
 371         }
 372
 373         apply_one_bool_with_default("no-delta", params,
 374                 &pretty->options.print_delta_field, false);
 375         /* Reverse logic. */
 376         pretty->options.print_delta_field = !pretty->options.print_delta_field;
 377
 378         apply_one_bool_with_default("clock-cycles", params,
 379                 &pretty->options.print_timestamp_cycles, false);
 380
 381         apply_one_bool_with_default("clock-seconds", params,
 382                 &pretty->options.clock_seconds , false);
 383
 384         apply_one_bool_with_default("clock-date", params,
 385                 &pretty->options.clock_date, false);
 386
 387         apply_one_bool_with_default("clock-gmt", params,
 388                 &pretty->options.clock_gmt, false);
 389
 390         apply_one_bool_with_default("verbose", params,
 391                 &pretty->options.verbose, false);
 392
 393         apply_one_bool_with_default("print-enum-flags", params,
 394                 &pretty->options.print_enum_flags, false);
 395
 396         /* Names. */
 397         value = bt_value_map_borrow_entry_value_const(params, "name-default");
 398         if (value) {
 399                 const char *str = bt_value_string_get(value);
 400
 401                 if (strcmp(str, "show") == 0) {
 402                         pretty->options.name_default = PRETTY_DEFAULT_SHOW;
 403                 } else {
 404                         BT_ASSERT(strcmp(str, "hide") == 0);
 405                         pretty->options.name_default = PRETTY_DEFAULT_HIDE;
 406                 }
 407         } else {
 408                 pretty->options.name_default = PRETTY_DEFAULT_UNSET;
 409         }
 410
 411         switch (pretty->options.name_default) {
 412         case PRETTY_DEFAULT_UNSET:
 413                 pretty->options.print_payload_field_names = true;
 414                 pretty->options.print_context_field_names = true;
 415                 pretty->options.print_header_field_names = false;
 416                 pretty->options.print_scope_field_names = false;
 417                 break;
 418         case PRETTY_DEFAULT_SHOW:
 419                 pretty->options.print_payload_field_names = true;
 420                 pretty->options.print_context_field_names = true;
 421                 pretty->options.print_header_field_names = true;
 422                 pretty->options.print_scope_field_names = true;
 423                 break;
 424         case PRETTY_DEFAULT_HIDE:
 425                 pretty->options.print_payload_field_names = false;
 426                 pretty->options.print_context_field_names = false;
 427                 pretty->options.print_header_field_names = false;
 428                 pretty->options.print_scope_field_names = false;
 429                 break;
 430         default:
 431                 bt_common_abort();
 432         }
 433
 434         apply_one_bool_if_specified("name-payload", params,
 435                 &pretty->options.print_payload_field_names);
 436
 437         apply_one_bool_if_specified("name-context", params,
 438                 &pretty->options.print_context_field_names);
 439
 440         apply_one_bool_if_specified("name-header", params,
 441                 &pretty->options.print_header_field_names);
 442
 443         apply_one_bool_if_specified("name-scope", params,
 444                 &pretty->options.print_scope_field_names);
 445
 446         /* Fields. */
 447         value = bt_value_map_borrow_entry_value_const(params, "field-default");
 448         if (value) {
 449                 const char *str = bt_value_string_get(value);
 450
 451                 if (strcmp(str, "show") == 0) {
 452                         pretty->options.field_default = PRETTY_DEFAULT_SHOW;
 453                 } else {
 454                         BT_ASSERT(strcmp(str, "hide") == 0);
 455                         pretty->options.field_default = PRETTY_DEFAULT_HIDE;
 456                 }
 457         } else {
 458                 pretty->options.field_default = PRETTY_DEFAULT_UNSET;
 459         }
 460
 461         switch (pretty->options.field_default) {
 462         case PRETTY_DEFAULT_UNSET:
 463                 pretty->options.print_trace_field = false;
 464                 pretty->options.print_trace_hostname_field = true;
 465                 pretty->options.print_trace_domain_field = false;
 466                 pretty->options.print_trace_procname_field = true;
 467                 pretty->options.print_trace_vpid_field = true;
 468                 pretty->options.print_loglevel_field = false;
 469                 pretty->options.print_emf_field = false;
 470                 pretty->options.print_callsite_field = false;
 471                 break;
 472         case PRETTY_DEFAULT_SHOW:
 473                 pretty->options.print_trace_field = true;
 474                 pretty->options.print_trace_hostname_field = true;
 475                 pretty->options.print_trace_domain_field = true;
 476                 pretty->options.print_trace_procname_field = true;
 477                 pretty->options.print_trace_vpid_field = true;
 478                 pretty->options.print_loglevel_field = true;
 479                 pretty->options.print_emf_field = true;
 480                 pretty->options.print_callsite_field = true;
 481                 break;
 482         case PRETTY_DEFAULT_HIDE:
 483                 pretty->options.print_trace_field = false;
 484                 pretty->options.print_trace_hostname_field = false;
 485                 pretty->options.print_trace_domain_field = false;
 486                 pretty->options.print_trace_procname_field = false;
 487                 pretty->options.print_trace_vpid_field = false;
 488                 pretty->options.print_loglevel_field = false;
 489                 pretty->options.print_emf_field = false;
 490                 pretty->options.print_callsite_field = false;
 491                 break;
 492         default:
 493                 bt_common_abort();
 494         }
 495
 496         apply_one_bool_if_specified("field-trace", params,
 497                 &pretty->options.print_trace_field);
 498
 499         apply_one_bool_if_specified("field-trace:hostname", params,
 500                 &pretty->options.print_trace_hostname_field);
 501
 502         apply_one_bool_if_specified("field-trace:domain", params,
 503                 &pretty->options.print_trace_domain_field);
 504
 505         apply_one_bool_if_specified("field-trace:procname", params,
 506                 &pretty->options.print_trace_procname_field);
 507
 508         apply_one_bool_if_specified("field-trace:vpid", params,
 509                 &pretty->options.print_trace_vpid_field);
 510
 511         apply_one_bool_if_specified("field-loglevel", params,
 512                 &pretty->options.print_loglevel_field);
 513
 514         apply_one_bool_if_specified("field-emf", params,
 515                 &pretty->options.print_emf_field);
 516
 517         apply_one_bool_if_specified("field-callsite", params,
 518                 &pretty->options.print_callsite_field);
 519
 520         pretty_print_init();
 521         status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
 522
 523 end:
 524         g_free(validate_error);
 525
 526         return status;
 527 }
 528
 529 static
 530 void set_use_colors(struct pretty_component *pretty)
 531 {
 532         switch (pretty->options.color) {
 533         case PRETTY_COLOR_OPT_ALWAYS:
 534                 pretty->use_colors = true;
 535                 break;
 536         case PRETTY_COLOR_OPT_AUTO:
 537                 pretty->use_colors = pretty->out == stdout &&
 538                         bt_common_colors_supported();
 539                 break;
 540         case PRETTY_COLOR_OPT_NEVER:
 541                 pretty->use_colors = false;
 542                 break;
 543         }
 544 }
 545
 546 BT_HIDDEN
 547 bt_component_class_initialize_method_status pretty_init(
 548                 bt_self_component_sink *self_comp_sink,
 549                 bt_self_component_sink_configuration *config,
 550                 const bt_value *params,
 551                 __attribute__((unused)) void *init_method_data)
 552 {
 553         bt_component_class_initialize_method_status status;
 554         bt_self_component_add_port_status add_port_status;
 555         struct pretty_component *pretty = create_pretty();
 556         bt_self_component *self_comp =
 557                 bt_self_component_sink_as_self_component(self_comp_sink);
 558         const bt_component *comp = bt_self_component_as_component(self_comp);
 559         bt_logging_level log_level = bt_component_get_logging_level(comp);
 560
 561         if (!pretty) {
 562                 /*
 563                  * Don't use BT_COMP_LOGE_APPEND_CAUSE, as `pretty` is not
 564                  * initialized yet.
 565                  */
 566                 BT_COMP_LOG_CUR_LVL(BT_LOG_ERROR, log_level, self_comp,
 567                         "Failed to allocate component.");
 568                 BT_CURRENT_THREAD_ERROR_APPEND_CAUSE_FROM_COMPONENT(
 569                         self_comp, "Failed to allocate component.");
 570                 status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_MEMORY_ERROR;
 571                 goto error;
 572         }
 573
 574         pretty->self_comp = self_comp;
 575         pretty->log_level = log_level;
 576
 577         add_port_status = bt_self_component_sink_add_input_port(self_comp_sink,
 578                 in_port_name, NULL, NULL);
 579         if (add_port_status != BT_SELF_COMPONENT_ADD_PORT_STATUS_OK) {
 580                 status = (int) add_port_status;
 581                 goto error;
 582         }
 583
 584         pretty->out = stdout;
 585         pretty->err = stderr;
 586
 587         pretty->delta_cycles = -1ULL;
 588         pretty->last_cycles_timestamp = -1ULL;
 589
 590         pretty->delta_real_timestamp = -1ULL;
 591         pretty->last_real_timestamp = -1ULL;
 592
 593         status = apply_params(pretty, params);
 594         if (status != BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK) {
 595                 goto error;
 596         }
 597
 598         set_use_colors(pretty);
 599
 600         if (pretty->options.print_enum_flags) {
 601                 uint64_t i;
 602                 /*
 603                  * Allocate all label arrays during the initialization of the
 604                  * component and reuse the same set of arrays for all
 605                  * enumerations.
 606                  */
 607                 for (i = 0; i < ENUMERATION_MAX_BITFLAGS_COUNT; i++) {
 608                         pretty->enum_bit_labels[i] = g_ptr_array_new();
 609                 }
 610         }
 611         bt_self_component_set_data(self_comp, pretty);
 612
 613         status = BT_COMPONENT_CLASS_INITIALIZE_METHOD_STATUS_OK;
 614         goto end;
 615
 616 error:
 617         destroy_pretty_data(pretty);
 618
 619 end:
 620         return status;
 621 }