plugins/text/pretty/pretty.c

   1 /*
   2  * pretty.c
   3  *
   4  * Babeltrace CTF Text Output Plugin
   5  *
   6  * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com>
   7  * Copyright 2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   8  *
   9  * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com>
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining a copy
  12  * of this software and associated documentation files (the "Software"), to deal
  13  * in the Software without restriction, including without limitation the rights
  14  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  15  * copies of the Software, and to permit persons to whom the Software is
  16  * furnished to do so, subject to the following conditions:
  17  *
  18  * The above copyright notice and this permission notice shall be included in
  19  * all copies or substantial portions of the Software.
  20  *
  21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  24  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  26  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  27  * SOFTWARE.
  28  */
  29
  30 #include <babeltrace/babeltrace.h>
  31 #include <babeltrace/values.h>
  32 #include <babeltrace/compiler-internal.h>
  33 #include <babeltrace/common-internal.h>
  34 #include <plugins-common.h>
  35 #include <stdio.h>
  36 #include <stdbool.h>
  37 #include <glib.h>
  38 #include <babeltrace/assert-internal.h>
  39
  40 #include "pretty.h"
  41
  42 GQuark stream_packet_context_quarks[STREAM_PACKET_CONTEXT_QUARKS_LEN];
  43
  44 static
  45 const char *plugin_options[] = {
  46         "color",
  47         "path",
  48         "no-delta",
  49         "clock-cycles",
  50         "clock-seconds",
  51         "clock-date",
  52         "clock-gmt",
  53         "verbose",
  54         "name-default",         /* show/hide */
  55         "name-payload",
  56         "name-context",
  57         "name-scope",
  58         "name-header",
  59         "field-default",        /* show/hide */
  60         "field-trace",
  61         "field-trace:hostname",
  62         "field-trace:domain",
  63         "field-trace:procname",
  64         "field-trace:vpid",
  65         "field-loglevel",
  66         "field-emf",
  67         "field-callsite",
  68 };
  69
  70 static
  71 void destroy_pretty_data(struct pretty_component *pretty)
  72 {
  73         bt_put(pretty->input_iterator);
  74
  75         if (pretty->string) {
  76                 (void) g_string_free(pretty->string, TRUE);
  77         }
  78
  79         if (pretty->tmp_string) {
  80                 (void) g_string_free(pretty->tmp_string, TRUE);
  81         }
  82
  83         if (pretty->out != stdout) {
  84                 int ret;
  85
  86                 ret = fclose(pretty->out);
  87                 if (ret) {
  88                         perror("close output file");
  89                 }
  90         }
  91         g_free(pretty->options.output_path);
  92         g_free(pretty);
  93 }
  94
  95 static
  96 struct pretty_component *create_pretty(void)
  97 {
  98         struct pretty_component *pretty;
  99
 100         pretty = g_new0(struct pretty_component, 1);
 101         if (!pretty) {
 102                 goto end;
 103         }
 104         pretty->string = g_string_new("");
 105         if (!pretty->string) {
 106                 goto error;
 107         }
 108         pretty->tmp_string = g_string_new("");
 109         if (!pretty->tmp_string) {
 110                 goto error;
 111         }
 112 end:
 113         return pretty;
 114
 115 error:
 116         g_free(pretty);
 117         return NULL;
 118 }
 119
 120 BT_HIDDEN
 121 void pretty_finalize(struct bt_private_component *component)
 122 {
 123         void *data = bt_private_component_get_user_data(component);
 124
 125         destroy_pretty_data(data);
 126 }
 127
 128 static
 129 enum bt_component_status handle_notification(struct pretty_component *pretty,
 130                 struct bt_notification *notification)
 131 {
 132         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 133
 134         BT_ASSERT(pretty);
 135
 136         switch (bt_notification_get_type(notification)) {
 137         case BT_NOTIFICATION_TYPE_EVENT:
 138                 ret = pretty_print_event(pretty, notification);
 139                 break;
 140         case BT_NOTIFICATION_TYPE_INACTIVITY:
 141                 fprintf(stderr, "Inactivity notification\n");
 142                 break;
 143         case BT_NOTIFICATION_TYPE_DISCARDED_PACKETS:
 144         case BT_NOTIFICATION_TYPE_DISCARDED_EVENTS:
 145                 ret = pretty_print_discarded_elements(pretty, notification);
 146                 break;
 147         default:
 148                 break;
 149         }
 150
 151         return ret;
 152 }
 153
 154 BT_HIDDEN
 155 enum bt_component_status pretty_port_connected(
 156                 struct bt_private_component *component,
 157                 struct bt_private_port *self_port,
 158                 struct bt_port *other_port)
 159 {
 160         enum bt_component_status status = BT_COMPONENT_STATUS_OK;
 161         enum bt_connection_status conn_status;
 162         struct bt_private_connection *connection;
 163         struct pretty_component *pretty;
 164
 165         pretty = bt_private_component_get_user_data(component);
 166         BT_ASSERT(pretty);
 167         BT_ASSERT(!pretty->input_iterator);
 168         connection = bt_private_port_get_private_connection(self_port);
 169         BT_ASSERT(connection);
 170         conn_status = bt_private_connection_create_notification_iterator(
 171                 connection, &pretty->input_iterator);
 172         if (conn_status != BT_CONNECTION_STATUS_OK) {
 173                 status = BT_COMPONENT_STATUS_ERROR;
 174         }
 175
 176         bt_put(connection);
 177         return status;
 178 }
 179
 180 BT_HIDDEN
 181 enum bt_component_status pretty_consume(struct bt_private_component *component)
 182 {
 183         enum bt_component_status ret;
 184         bt_notification_array notifs;
 185         struct bt_notification_iterator *it;
 186         struct pretty_component *pretty =
 187                 bt_private_component_get_user_data(component);
 188         enum bt_notification_iterator_status it_ret;
 189         uint64_t count = 0;
 190         uint64_t i = 0;
 191
 192         it = pretty->input_iterator;
 193         it_ret = bt_private_connection_notification_iterator_next(it, &notifs,
 194                 &count);
 195
 196         switch (it_ret) {
 197         case BT_NOTIFICATION_ITERATOR_STATUS_END:
 198                 ret = BT_COMPONENT_STATUS_END;
 199                 BT_PUT(pretty->input_iterator);
 200                 goto end;
 201         case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN:
 202                 ret = BT_COMPONENT_STATUS_AGAIN;
 203                 goto end;
 204         case BT_NOTIFICATION_ITERATOR_STATUS_OK:
 205                 break;
 206         default:
 207                 ret = BT_COMPONENT_STATUS_ERROR;
 208                 goto end;
 209         }
 210
 211         BT_ASSERT(it_ret == BT_NOTIFICATION_ITERATOR_STATUS_OK);
 212
 213         for (i = 0; i < count; i++) {
 214                 ret = handle_notification(pretty, notifs[i]);
 215                 if (ret) {
 216                         goto end;
 217                 }
 218
 219                 bt_put(notifs[i]);
 220         }
 221
 222 end:
 223         for (; i < count; i++) {
 224                 bt_put(notifs[i]);
 225         }
 226
 227         return ret;
 228 }
 229
 230 static
 231 enum bt_component_status add_params_to_map(struct bt_value *plugin_opt_map)
 232 {
 233         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 234         unsigned int i;
 235
 236         for (i = 0; i < BT_ARRAY_SIZE(plugin_options); i++) {
 237                 const char *key = plugin_options[i];
 238                 enum bt_value_status status;
 239
 240                 status = bt_value_map_insert(plugin_opt_map, key, bt_value_null);
 241                 switch (status) {
 242                 case BT_VALUE_STATUS_OK:
 243                         break;
 244                 default:
 245                         ret = BT_COMPONENT_STATUS_ERROR;
 246                         goto end;
 247                 }
 248         }
 249 end:
 250         return ret;
 251 }
 252
 253 static
 254 bt_bool check_param_exists(const char *key, struct bt_value *object, void *data)
 255 {
 256         struct pretty_component *pretty = data;
 257         struct bt_value *plugin_opt_map = pretty->plugin_opt_map;
 258
 259         if (!bt_value_map_has_key(plugin_opt_map, key)) {
 260                 fprintf(pretty->err,
 261                         "[warning] Parameter \"%s\" unknown to \"text.pretty\" sink component\n", key);
 262         }
 263         return BT_TRUE;
 264 }
 265
 266 static
 267 enum bt_component_status apply_one_string(const char *key,
 268                 struct bt_value *params,
 269                 char **option)
 270 {
 271         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 272         struct bt_value *value = NULL;
 273         enum bt_value_status status;
 274         const char *str;
 275
 276         value = bt_value_map_borrow(params, key);
 277         if (!value) {
 278                 goto end;
 279         }
 280         if (bt_value_is_null(value)) {
 281                 goto end;
 282         }
 283         status = bt_value_string_get(value, &str);
 284         switch (status) {
 285         case BT_VALUE_STATUS_OK:
 286                 break;
 287         default:
 288                 ret = BT_COMPONENT_STATUS_ERROR;
 289                 goto end;
 290         }
 291         *option = g_strdup(str);
 292 end:
 293         return ret;
 294 }
 295
 296 static
 297 enum bt_component_status apply_one_bool(const char *key,
 298                 struct bt_value *params,
 299                 bool *option,
 300                 bool *found)
 301 {
 302         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 303         struct bt_value *value = NULL;
 304         enum bt_value_status status;
 305         bt_bool bool_val;
 306
 307         value = bt_value_map_borrow(params, key);
 308         if (!value) {
 309                 goto end;
 310         }
 311         status = bt_value_bool_get(value, &bool_val);
 312         switch (status) {
 313         case BT_VALUE_STATUS_OK:
 314                 break;
 315         default:
 316                 ret = BT_COMPONENT_STATUS_ERROR;
 317                 goto end;
 318         }
 319         *option = (bool) bool_val;
 320         if (found) {
 321                 *found = true;
 322         }
 323
 324 end:
 325         return ret;
 326 }
 327
 328 static
 329 void warn_wrong_color_param(struct pretty_component *pretty)
 330 {
 331         fprintf(pretty->err,
 332                 "[warning] Accepted values for the \"color\" parameter are:\n    \"always\", \"auto\", \"never\"\n");
 333 }
 334
 335 static
 336 enum bt_component_status open_output_file(struct pretty_component *pretty)
 337 {
 338         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 339
 340         if (!pretty->options.output_path) {
 341                 goto end;
 342         }
 343
 344         pretty->out = fopen(pretty->options.output_path, "w");
 345         if (!pretty->out) {
 346                 goto error;
 347         }
 348
 349         goto end;
 350
 351 error:
 352         ret = BT_COMPONENT_STATUS_ERROR;
 353 end:
 354         return ret;
 355 }
 356
 357 static
 358 enum bt_component_status apply_params(struct pretty_component *pretty,
 359                 struct bt_value *params)
 360 {
 361         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 362         enum bt_value_status status;
 363         bool value, found;
 364         char *str = NULL;
 365
 366         pretty->plugin_opt_map = bt_value_map_create();
 367         if (!pretty->plugin_opt_map) {
 368                 ret = BT_COMPONENT_STATUS_ERROR;
 369                 goto end;
 370         }
 371         ret = add_params_to_map(pretty->plugin_opt_map);
 372         if (ret != BT_COMPONENT_STATUS_OK) {
 373                 goto end;
 374         }
 375         /* Report unknown parameters. */
 376         status = bt_value_map_foreach(params, check_param_exists, pretty);
 377         switch (status) {
 378         case BT_VALUE_STATUS_OK:
 379                 break;
 380         default:
 381                 ret = BT_COMPONENT_STATUS_ERROR;
 382                 goto end;
 383         }
 384         /* Known parameters. */
 385         pretty->options.color = PRETTY_COLOR_OPT_AUTO;
 386         if (bt_value_map_has_key(params, "color")) {
 387                 struct bt_value *color_value;
 388                 const char *color;
 389
 390                 color_value = bt_value_map_borrow(params, "color");
 391                 if (!color_value) {
 392                         goto end;
 393                 }
 394
 395                 status = bt_value_string_get(color_value, &color);
 396                 if (status) {
 397                         warn_wrong_color_param(pretty);
 398                 } else {
 399                         if (strcmp(color, "never") == 0) {
 400                                 pretty->options.color = PRETTY_COLOR_OPT_NEVER;
 401                         } else if (strcmp(color, "auto") == 0) {
 402                                 pretty->options.color = PRETTY_COLOR_OPT_AUTO;
 403                         } else if (strcmp(color, "always") == 0) {
 404                                 pretty->options.color = PRETTY_COLOR_OPT_ALWAYS;
 405                         } else {
 406                                 warn_wrong_color_param(pretty);
 407                         }
 408                 }
 409         }
 410
 411         ret = apply_one_string("path", params, &pretty->options.output_path);
 412         if (ret != BT_COMPONENT_STATUS_OK) {
 413                 goto end;
 414         }
 415         ret = open_output_file(pretty);
 416         if (ret != BT_COMPONENT_STATUS_OK) {
 417                 goto end;
 418         }
 419
 420         value = false;          /* Default. */
 421         ret = apply_one_bool("no-delta", params, &value, NULL);
 422         if (ret != BT_COMPONENT_STATUS_OK) {
 423                 goto end;
 424         }
 425         pretty->options.print_delta_field = !value;     /* Reverse logic. */
 426
 427         value = false;          /* Default. */
 428         ret = apply_one_bool("clock-cycles", params, &value, NULL);
 429         if (ret != BT_COMPONENT_STATUS_OK) {
 430                 goto end;
 431         }
 432         pretty->options.print_timestamp_cycles = value;
 433
 434         value = false;          /* Default. */
 435         ret = apply_one_bool("clock-seconds", params, &value, NULL);
 436         if (ret != BT_COMPONENT_STATUS_OK) {
 437                 goto end;
 438         }
 439         pretty->options.clock_seconds = value;
 440
 441         value = false;          /* Default. */
 442         ret = apply_one_bool("clock-date", params, &value, NULL);
 443         if (ret != BT_COMPONENT_STATUS_OK) {
 444                 goto end;
 445         }
 446         pretty->options.clock_date = value;
 447
 448         value = false;          /* Default. */
 449         ret = apply_one_bool("clock-gmt", params, &value, NULL);
 450         if (ret != BT_COMPONENT_STATUS_OK) {
 451                 goto end;
 452         }
 453         pretty->options.clock_gmt = value;
 454
 455         value = false;          /* Default. */
 456         ret = apply_one_bool("verbose", params, &value, NULL);
 457         if (ret != BT_COMPONENT_STATUS_OK) {
 458                 goto end;
 459         }
 460         pretty->options.verbose = value;
 461
 462         /* Names. */
 463         ret = apply_one_string("name-default", params, &str);
 464         if (ret != BT_COMPONENT_STATUS_OK) {
 465                 goto end;
 466         }
 467         if (!str) {
 468                 pretty->options.name_default = PRETTY_DEFAULT_UNSET;
 469         } else if (!strcmp(str, "show")) {
 470                 pretty->options.name_default = PRETTY_DEFAULT_SHOW;
 471         } else if (!strcmp(str, "hide")) {
 472                 pretty->options.name_default = PRETTY_DEFAULT_HIDE;
 473         } else {
 474                 ret = BT_COMPONENT_STATUS_ERROR;
 475                 goto end;
 476         }
 477         g_free(str);
 478         str = NULL;
 479
 480         switch (pretty->options.name_default) {
 481         case PRETTY_DEFAULT_UNSET:
 482                 pretty->options.print_payload_field_names = true;
 483                 pretty->options.print_context_field_names = true;
 484                 pretty->options.print_header_field_names = false;
 485                 pretty->options.print_scope_field_names = false;
 486                 break;
 487         case PRETTY_DEFAULT_SHOW:
 488                 pretty->options.print_payload_field_names = true;
 489                 pretty->options.print_context_field_names = true;
 490                 pretty->options.print_header_field_names = true;
 491                 pretty->options.print_scope_field_names = true;
 492                 break;
 493         case PRETTY_DEFAULT_HIDE:
 494                 pretty->options.print_payload_field_names = false;
 495                 pretty->options.print_context_field_names = false;
 496                 pretty->options.print_header_field_names = false;
 497                 pretty->options.print_scope_field_names = false;
 498                 break;
 499         default:
 500                 ret = BT_COMPONENT_STATUS_ERROR;
 501                 goto end;
 502         }
 503
 504         value = false;
 505         found = false;
 506         ret = apply_one_bool("name-payload", params, &value, &found);
 507         if (ret != BT_COMPONENT_STATUS_OK) {
 508                 goto end;
 509         }
 510         if (found) {
 511                 pretty->options.print_payload_field_names = value;
 512         }
 513
 514         value = false;
 515         found = false;
 516         ret = apply_one_bool("name-context", params, &value, &found);
 517         if (ret != BT_COMPONENT_STATUS_OK) {
 518                 goto end;
 519         }
 520         if (found) {
 521                 pretty->options.print_context_field_names = value;
 522         }
 523
 524         value = false;
 525         found = false;
 526         ret = apply_one_bool("name-header", params, &value, &found);
 527         if (ret != BT_COMPONENT_STATUS_OK) {
 528                 goto end;
 529         }
 530         if (found) {
 531                 pretty->options.print_header_field_names = value;
 532         }
 533
 534         value = false;
 535         found = false;
 536         ret = apply_one_bool("name-scope", params, &value, &found);
 537         if (ret != BT_COMPONENT_STATUS_OK) {
 538                 goto end;
 539         }
 540         if (found) {
 541                 pretty->options.print_scope_field_names = value;
 542         }
 543
 544         /* Fields. */
 545         ret = apply_one_string("field-default", params, &str);
 546         if (ret != BT_COMPONENT_STATUS_OK) {
 547                 goto end;
 548         }
 549         if (!str) {
 550                 pretty->options.field_default = PRETTY_DEFAULT_UNSET;
 551         } else if (!strcmp(str, "show")) {
 552                 pretty->options.field_default = PRETTY_DEFAULT_SHOW;
 553         } else if (!strcmp(str, "hide")) {
 554                 pretty->options.field_default = PRETTY_DEFAULT_HIDE;
 555         } else {
 556                 ret = BT_COMPONENT_STATUS_ERROR;
 557                 goto end;
 558         }
 559         g_free(str);
 560         str = NULL;
 561
 562         switch (pretty->options.field_default) {
 563         case PRETTY_DEFAULT_UNSET:
 564                 pretty->options.print_trace_field = false;
 565                 pretty->options.print_trace_hostname_field = true;
 566                 pretty->options.print_trace_domain_field = false;
 567                 pretty->options.print_trace_procname_field = true;
 568                 pretty->options.print_trace_vpid_field = true;
 569                 pretty->options.print_loglevel_field = false;
 570                 pretty->options.print_emf_field = false;
 571                 pretty->options.print_callsite_field = false;
 572                 break;
 573         case PRETTY_DEFAULT_SHOW:
 574                 pretty->options.print_trace_field = true;
 575                 pretty->options.print_trace_hostname_field = true;
 576                 pretty->options.print_trace_domain_field = true;
 577                 pretty->options.print_trace_procname_field = true;
 578                 pretty->options.print_trace_vpid_field = true;
 579                 pretty->options.print_loglevel_field = true;
 580                 pretty->options.print_emf_field = true;
 581                 pretty->options.print_callsite_field = true;
 582                 break;
 583         case PRETTY_DEFAULT_HIDE:
 584                 pretty->options.print_trace_field = false;
 585                 pretty->options.print_trace_hostname_field = false;
 586                 pretty->options.print_trace_domain_field = false;
 587                 pretty->options.print_trace_procname_field = false;
 588                 pretty->options.print_trace_vpid_field = false;
 589                 pretty->options.print_loglevel_field = false;
 590                 pretty->options.print_emf_field = false;
 591                 pretty->options.print_callsite_field = false;
 592                 break;
 593         default:
 594                 ret = BT_COMPONENT_STATUS_ERROR;
 595                 goto end;
 596         }
 597
 598         value = false;
 599         found = false;
 600         ret = apply_one_bool("field-trace", params, &value, &found);
 601         if (ret != BT_COMPONENT_STATUS_OK) {
 602                 goto end;
 603         }
 604         if (found) {
 605                 pretty->options.print_trace_field = value;
 606         }
 607
 608         value = false;
 609         found = false;
 610         ret = apply_one_bool("field-trace:hostname", params, &value, &found);
 611         if (ret != BT_COMPONENT_STATUS_OK) {
 612                 goto end;
 613         }
 614         if (found) {
 615                 pretty->options.print_trace_hostname_field = value;
 616         }
 617
 618         value = false;
 619         found = false;
 620         ret = apply_one_bool("field-trace:domain", params, &value, &found);
 621         if (ret != BT_COMPONENT_STATUS_OK) {
 622                 goto end;
 623         }
 624         if (found) {
 625                 pretty->options.print_trace_domain_field = value;
 626         }
 627
 628         value = false;
 629         found = false;
 630         ret = apply_one_bool("field-trace:procname", params, &value, &found);
 631         if (ret != BT_COMPONENT_STATUS_OK) {
 632                 goto end;
 633         }
 634         if (found) {
 635                 pretty->options.print_trace_procname_field = value;
 636         }
 637
 638         value = false;
 639         found = false;
 640         ret = apply_one_bool("field-trace:vpid", params, &value, &found);
 641         if (ret != BT_COMPONENT_STATUS_OK) {
 642                 goto end;
 643         }
 644         if (found) {
 645                 pretty->options.print_trace_vpid_field = value;
 646         }
 647
 648         value = false;
 649         found = false;
 650         ret = apply_one_bool("field-loglevel", params, &value, &found);
 651         if (ret != BT_COMPONENT_STATUS_OK) {
 652                 goto end;
 653         }
 654         if (found) {
 655                 pretty->options.print_loglevel_field = value;
 656         }
 657
 658         value = false;
 659         found = false;
 660         ret = apply_one_bool("field-emf", params, &value, &found);
 661         if (ret != BT_COMPONENT_STATUS_OK) {
 662                 goto end;
 663         }
 664         if (found) {
 665                 pretty->options.print_emf_field = value;
 666         }
 667
 668         value = false;
 669         found = false;
 670         ret = apply_one_bool("field-callsite", params, &value, &found);
 671         if (ret != BT_COMPONENT_STATUS_OK) {
 672                 goto end;
 673         }
 674         if (found) {
 675                 pretty->options.print_callsite_field = value;
 676         }
 677
 678 end:
 679         bt_put(pretty->plugin_opt_map);
 680         pretty->plugin_opt_map = NULL;
 681         g_free(str);
 682         return ret;
 683 }
 684
 685 static
 686 void set_use_colors(struct pretty_component *pretty)
 687 {
 688         switch (pretty->options.color) {
 689         case PRETTY_COLOR_OPT_ALWAYS:
 690                 pretty->use_colors = true;
 691                 break;
 692         case PRETTY_COLOR_OPT_AUTO:
 693                 pretty->use_colors = pretty->out == stdout &&
 694                         bt_common_colors_supported();
 695                 break;
 696         case PRETTY_COLOR_OPT_NEVER:
 697                 pretty->use_colors = false;
 698                 break;
 699         }
 700 }
 701
 702 static
 703 void init_stream_packet_context_quarks(void)
 704 {
 705         stream_packet_context_quarks[Q_TIMESTAMP_BEGIN] =
 706                 g_quark_from_string("timestamp_begin");
 707         stream_packet_context_quarks[Q_TIMESTAMP_BEGIN] =
 708                 g_quark_from_string("timestamp_begin");
 709         stream_packet_context_quarks[Q_TIMESTAMP_END] =
 710                 g_quark_from_string("timestamp_end");
 711         stream_packet_context_quarks[Q_EVENTS_DISCARDED] =
 712                 g_quark_from_string("events_discarded");
 713         stream_packet_context_quarks[Q_CONTENT_SIZE] =
 714                 g_quark_from_string("content_size");
 715         stream_packet_context_quarks[Q_PACKET_SIZE] =
 716                 g_quark_from_string("packet_size");
 717         stream_packet_context_quarks[Q_PACKET_SEQ_NUM] =
 718                 g_quark_from_string("packet_seq_num");
 719 }
 720
 721 BT_HIDDEN
 722 enum bt_component_status pretty_init(
 723                 struct bt_private_component *component,
 724                 struct bt_value *params,
 725                 UNUSED_VAR void *init_method_data)
 726 {
 727         enum bt_component_status ret;
 728         struct pretty_component *pretty = create_pretty();
 729
 730         if (!pretty) {
 731                 ret = BT_COMPONENT_STATUS_NOMEM;
 732                 goto end;
 733         }
 734
 735         ret = bt_private_component_sink_add_input_private_port(component,
 736                 "in", NULL, NULL);
 737         if (ret != BT_COMPONENT_STATUS_OK) {
 738                 goto end;
 739         }
 740
 741         pretty->out = stdout;
 742         pretty->err = stderr;
 743
 744         pretty->delta_cycles = -1ULL;
 745         pretty->last_cycles_timestamp = -1ULL;
 746
 747         pretty->delta_real_timestamp = -1ULL;
 748         pretty->last_real_timestamp = -1ULL;
 749
 750         ret = apply_params(pretty, params);
 751         if (ret != BT_COMPONENT_STATUS_OK) {
 752                 goto error;
 753         }
 754
 755         set_use_colors(pretty);
 756         ret = bt_private_component_set_user_data(component, pretty);
 757         if (ret != BT_COMPONENT_STATUS_OK) {
 758                 goto error;
 759         }
 760
 761         init_stream_packet_context_quarks();
 762
 763 end:
 764         return ret;
 765 error:
 766         destroy_pretty_data(pretty);
 767         return ret;
 768 }