src/plugins/text/pretty/pretty.c

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