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