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 void 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_connection_status conn_status;
 161         struct bt_private_connection *connection;
 162         struct pretty_component *pretty;
 163
 164         pretty = bt_private_component_get_user_data(component);
 165         BT_ASSERT(pretty);
 166         BT_ASSERT(!pretty->input_iterator);
 167         connection = bt_private_port_get_private_connection(self_port);
 168         BT_ASSERT(connection);
 169         conn_status = bt_private_connection_create_notification_iterator(
 170                 connection, &pretty->input_iterator);
 171         if (conn_status != BT_CONNECTION_STATUS_OK) {
 172                 pretty->error = true;
 173         }
 174
 175         bt_put(connection);
 176 }
 177
 178 BT_HIDDEN
 179 enum bt_component_status pretty_consume(struct bt_private_component *component)
 180 {
 181         enum bt_component_status ret;
 182         bt_notification_array notifs;
 183         struct bt_notification_iterator *it;
 184         struct pretty_component *pretty =
 185                 bt_private_component_get_user_data(component);
 186         enum bt_notification_iterator_status it_ret;
 187         uint64_t count = 0;
 188         uint64_t i = 0;
 189
 190         if (unlikely(pretty->error)) {
 191                 ret = BT_COMPONENT_STATUS_ERROR;
 192                 goto end;
 193         }
 194
 195         it = pretty->input_iterator;
 196         it_ret = bt_private_connection_notification_iterator_next(it, &notifs,
 197                 &count);
 198
 199         switch (it_ret) {
 200         case BT_NOTIFICATION_ITERATOR_STATUS_END:
 201                 ret = BT_COMPONENT_STATUS_END;
 202                 BT_PUT(pretty->input_iterator);
 203                 goto end;
 204         case BT_NOTIFICATION_ITERATOR_STATUS_AGAIN:
 205                 ret = BT_COMPONENT_STATUS_AGAIN;
 206                 goto end;
 207         case BT_NOTIFICATION_ITERATOR_STATUS_OK:
 208                 break;
 209         default:
 210                 ret = BT_COMPONENT_STATUS_ERROR;
 211                 goto end;
 212         }
 213
 214         BT_ASSERT(it_ret == BT_NOTIFICATION_ITERATOR_STATUS_OK);
 215
 216         for (i = 0; i < count; i++) {
 217                 ret = handle_notification(pretty, notifs[i]);
 218                 if (ret) {
 219                         goto end;
 220                 }
 221
 222                 bt_put(notifs[i]);
 223         }
 224
 225 end:
 226         for (; i < count; i++) {
 227                 bt_put(notifs[i]);
 228         }
 229
 230         return ret;
 231 }
 232
 233 static
 234 enum bt_component_status add_params_to_map(struct bt_value *plugin_opt_map)
 235 {
 236         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 237         unsigned int i;
 238
 239         for (i = 0; i < BT_ARRAY_SIZE(plugin_options); i++) {
 240                 const char *key = plugin_options[i];
 241                 enum bt_value_status status;
 242
 243                 status = bt_value_map_insert(plugin_opt_map, key, bt_value_null);
 244                 switch (status) {
 245                 case BT_VALUE_STATUS_OK:
 246                         break;
 247                 default:
 248                         ret = BT_COMPONENT_STATUS_ERROR;
 249                         goto end;
 250                 }
 251         }
 252 end:
 253         return ret;
 254 }
 255
 256 static
 257 bt_bool check_param_exists(const char *key, struct bt_value *object, void *data)
 258 {
 259         struct pretty_component *pretty = data;
 260         struct bt_value *plugin_opt_map = pretty->plugin_opt_map;
 261
 262         if (!bt_value_map_has_key(plugin_opt_map, key)) {
 263                 fprintf(pretty->err,
 264                         "[warning] Parameter \"%s\" unknown to \"text.pretty\" sink component\n", key);
 265         }
 266         return BT_TRUE;
 267 }
 268
 269 static
 270 enum bt_component_status apply_one_string(const char *key,
 271                 struct bt_value *params,
 272                 char **option)
 273 {
 274         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 275         struct bt_value *value = NULL;
 276         enum bt_value_status status;
 277         const char *str;
 278
 279         value = bt_value_map_borrow(params, key);
 280         if (!value) {
 281                 goto end;
 282         }
 283         if (bt_value_is_null(value)) {
 284                 goto end;
 285         }
 286         status = bt_value_string_get(value, &str);
 287         switch (status) {
 288         case BT_VALUE_STATUS_OK:
 289                 break;
 290         default:
 291                 ret = BT_COMPONENT_STATUS_ERROR;
 292                 goto end;
 293         }
 294         *option = g_strdup(str);
 295 end:
 296         return ret;
 297 }
 298
 299 static
 300 enum bt_component_status apply_one_bool(const char *key,
 301                 struct bt_value *params,
 302                 bool *option,
 303                 bool *found)
 304 {
 305         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 306         struct bt_value *value = NULL;
 307         enum bt_value_status status;
 308         bt_bool bool_val;
 309
 310         value = bt_value_map_borrow(params, key);
 311         if (!value) {
 312                 goto end;
 313         }
 314         status = bt_value_bool_get(value, &bool_val);
 315         switch (status) {
 316         case BT_VALUE_STATUS_OK:
 317                 break;
 318         default:
 319                 ret = BT_COMPONENT_STATUS_ERROR;
 320                 goto end;
 321         }
 322         *option = (bool) bool_val;
 323         if (found) {
 324                 *found = true;
 325         }
 326
 327 end:
 328         return ret;
 329 }
 330
 331 static
 332 void warn_wrong_color_param(struct pretty_component *pretty)
 333 {
 334         fprintf(pretty->err,
 335                 "[warning] Accepted values for the \"color\" parameter are:\n    \"always\", \"auto\", \"never\"\n");
 336 }
 337
 338 static
 339 enum bt_component_status open_output_file(struct pretty_component *pretty)
 340 {
 341         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 342
 343         if (!pretty->options.output_path) {
 344                 goto end;
 345         }
 346
 347         pretty->out = fopen(pretty->options.output_path, "w");
 348         if (!pretty->out) {
 349                 goto error;
 350         }
 351
 352         goto end;
 353
 354 error:
 355         ret = BT_COMPONENT_STATUS_ERROR;
 356 end:
 357         return ret;
 358 }
 359
 360 static
 361 enum bt_component_status apply_params(struct pretty_component *pretty,
 362                 struct bt_value *params)
 363 {
 364         enum bt_component_status ret = BT_COMPONENT_STATUS_OK;
 365         enum bt_value_status status;
 366         bool value, found;
 367         char *str = NULL;
 368
 369         pretty->plugin_opt_map = bt_value_map_create();
 370         if (!pretty->plugin_opt_map) {
 371                 ret = BT_COMPONENT_STATUS_ERROR;
 372                 goto end;
 373         }
 374         ret = add_params_to_map(pretty->plugin_opt_map);
 375         if (ret != BT_COMPONENT_STATUS_OK) {
 376                 goto end;
 377         }
 378         /* Report unknown parameters. */
 379         status = bt_value_map_foreach(params, check_param_exists, pretty);
 380         switch (status) {
 381         case BT_VALUE_STATUS_OK:
 382                 break;
 383         default:
 384                 ret = BT_COMPONENT_STATUS_ERROR;
 385                 goto end;
 386         }
 387         /* Known parameters. */
 388         pretty->options.color = PRETTY_COLOR_OPT_AUTO;
 389         if (bt_value_map_has_key(params, "color")) {
 390                 struct bt_value *color_value;
 391                 const char *color;
 392
 393                 color_value = bt_value_map_borrow(params, "color");
 394                 if (!color_value) {
 395                         goto end;
 396                 }
 397
 398                 status = bt_value_string_get(color_value, &color);
 399                 if (status) {
 400                         warn_wrong_color_param(pretty);
 401                 } else {
 402                         if (strcmp(color, "never") == 0) {
 403                                 pretty->options.color = PRETTY_COLOR_OPT_NEVER;
 404                         } else if (strcmp(color, "auto") == 0) {
 405                                 pretty->options.color = PRETTY_COLOR_OPT_AUTO;
 406                         } else if (strcmp(color, "always") == 0) {
 407                                 pretty->options.color = PRETTY_COLOR_OPT_ALWAYS;
 408                         } else {
 409                                 warn_wrong_color_param(pretty);
 410                         }
 411                 }
 412         }
 413
 414         ret = apply_one_string("path", params, &pretty->options.output_path);
 415         if (ret != BT_COMPONENT_STATUS_OK) {
 416                 goto end;
 417         }
 418         ret = open_output_file(pretty);
 419         if (ret != BT_COMPONENT_STATUS_OK) {
 420                 goto end;
 421         }
 422
 423         value = false;          /* Default. */
 424         ret = apply_one_bool("no-delta", params, &value, NULL);
 425         if (ret != BT_COMPONENT_STATUS_OK) {
 426                 goto end;
 427         }
 428         pretty->options.print_delta_field = !value;     /* Reverse logic. */
 429
 430         value = false;          /* Default. */
 431         ret = apply_one_bool("clock-cycles", params, &value, NULL);
 432         if (ret != BT_COMPONENT_STATUS_OK) {
 433                 goto end;
 434         }
 435         pretty->options.print_timestamp_cycles = value;
 436
 437         value = false;          /* Default. */
 438         ret = apply_one_bool("clock-seconds", params, &value, NULL);
 439         if (ret != BT_COMPONENT_STATUS_OK) {
 440                 goto end;
 441         }
 442         pretty->options.clock_seconds = value;
 443
 444         value = false;          /* Default. */
 445         ret = apply_one_bool("clock-date", params, &value, NULL);
 446         if (ret != BT_COMPONENT_STATUS_OK) {
 447                 goto end;
 448         }
 449         pretty->options.clock_date = value;
 450
 451         value = false;          /* Default. */
 452         ret = apply_one_bool("clock-gmt", params, &value, NULL);
 453         if (ret != BT_COMPONENT_STATUS_OK) {
 454                 goto end;
 455         }
 456         pretty->options.clock_gmt = value;
 457
 458         value = false;          /* Default. */
 459         ret = apply_one_bool("verbose", params, &value, NULL);
 460         if (ret != BT_COMPONENT_STATUS_OK) {
 461                 goto end;
 462         }
 463         pretty->options.verbose = value;
 464
 465         /* Names. */
 466         ret = apply_one_string("name-default", params, &str);
 467         if (ret != BT_COMPONENT_STATUS_OK) {
 468                 goto end;
 469         }
 470         if (!str) {
 471                 pretty->options.name_default = PRETTY_DEFAULT_UNSET;
 472         } else if (!strcmp(str, "show")) {
 473                 pretty->options.name_default = PRETTY_DEFAULT_SHOW;
 474         } else if (!strcmp(str, "hide")) {
 475                 pretty->options.name_default = PRETTY_DEFAULT_HIDE;
 476         } else {
 477                 ret = BT_COMPONENT_STATUS_ERROR;
 478                 goto end;
 479         }
 480         g_free(str);
 481         str = NULL;
 482
 483         switch (pretty->options.name_default) {
 484         case PRETTY_DEFAULT_UNSET:
 485                 pretty->options.print_payload_field_names = true;
 486                 pretty->options.print_context_field_names = true;
 487                 pretty->options.print_header_field_names = false;
 488                 pretty->options.print_scope_field_names = false;
 489                 break;
 490         case PRETTY_DEFAULT_SHOW:
 491                 pretty->options.print_payload_field_names = true;
 492                 pretty->options.print_context_field_names = true;
 493                 pretty->options.print_header_field_names = true;
 494                 pretty->options.print_scope_field_names = true;
 495                 break;
 496         case PRETTY_DEFAULT_HIDE:
 497                 pretty->options.print_payload_field_names = false;
 498                 pretty->options.print_context_field_names = false;
 499                 pretty->options.print_header_field_names = false;
 500                 pretty->options.print_scope_field_names = false;
 501                 break;
 502         default:
 503                 ret = BT_COMPONENT_STATUS_ERROR;
 504                 goto end;
 505         }
 506
 507         value = false;
 508         found = false;
 509         ret = apply_one_bool("name-payload", params, &value, &found);
 510         if (ret != BT_COMPONENT_STATUS_OK) {
 511                 goto end;
 512         }
 513         if (found) {
 514                 pretty->options.print_payload_field_names = value;
 515         }
 516
 517         value = false;
 518         found = false;
 519         ret = apply_one_bool("name-context", params, &value, &found);
 520         if (ret != BT_COMPONENT_STATUS_OK) {
 521                 goto end;
 522         }
 523         if (found) {
 524                 pretty->options.print_context_field_names = value;
 525         }
 526
 527         value = false;
 528         found = false;
 529         ret = apply_one_bool("name-header", params, &value, &found);
 530         if (ret != BT_COMPONENT_STATUS_OK) {
 531                 goto end;
 532         }
 533         if (found) {
 534                 pretty->options.print_header_field_names = value;
 535         }
 536
 537         value = false;
 538         found = false;
 539         ret = apply_one_bool("name-scope", params, &value, &found);
 540         if (ret != BT_COMPONENT_STATUS_OK) {
 541                 goto end;
 542         }
 543         if (found) {
 544                 pretty->options.print_scope_field_names = value;
 545         }
 546
 547         /* Fields. */
 548         ret = apply_one_string("field-default", params, &str);
 549         if (ret != BT_COMPONENT_STATUS_OK) {
 550                 goto end;
 551         }
 552         if (!str) {
 553                 pretty->options.field_default = PRETTY_DEFAULT_UNSET;
 554         } else if (!strcmp(str, "show")) {
 555                 pretty->options.field_default = PRETTY_DEFAULT_SHOW;
 556         } else if (!strcmp(str, "hide")) {
 557                 pretty->options.field_default = PRETTY_DEFAULT_HIDE;
 558         } else {
 559                 ret = BT_COMPONENT_STATUS_ERROR;
 560                 goto end;
 561         }
 562         g_free(str);
 563         str = NULL;
 564
 565         switch (pretty->options.field_default) {
 566         case PRETTY_DEFAULT_UNSET:
 567                 pretty->options.print_trace_field = false;
 568                 pretty->options.print_trace_hostname_field = true;
 569                 pretty->options.print_trace_domain_field = false;
 570                 pretty->options.print_trace_procname_field = true;
 571                 pretty->options.print_trace_vpid_field = true;
 572                 pretty->options.print_loglevel_field = false;
 573                 pretty->options.print_emf_field = false;
 574                 pretty->options.print_callsite_field = false;
 575                 break;
 576         case PRETTY_DEFAULT_SHOW:
 577                 pretty->options.print_trace_field = true;
 578                 pretty->options.print_trace_hostname_field = true;
 579                 pretty->options.print_trace_domain_field = true;
 580                 pretty->options.print_trace_procname_field = true;
 581                 pretty->options.print_trace_vpid_field = true;
 582                 pretty->options.print_loglevel_field = true;
 583                 pretty->options.print_emf_field = true;
 584                 pretty->options.print_callsite_field = true;
 585                 break;
 586         case PRETTY_DEFAULT_HIDE:
 587                 pretty->options.print_trace_field = false;
 588                 pretty->options.print_trace_hostname_field = false;
 589                 pretty->options.print_trace_domain_field = false;
 590                 pretty->options.print_trace_procname_field = false;
 591                 pretty->options.print_trace_vpid_field = false;
 592                 pretty->options.print_loglevel_field = false;
 593                 pretty->options.print_emf_field = false;
 594                 pretty->options.print_callsite_field = false;
 595                 break;
 596         default:
 597                 ret = BT_COMPONENT_STATUS_ERROR;
 598                 goto end;
 599         }
 600
 601         value = false;
 602         found = false;
 603         ret = apply_one_bool("field-trace", params, &value, &found);
 604         if (ret != BT_COMPONENT_STATUS_OK) {
 605                 goto end;
 606         }
 607         if (found) {
 608                 pretty->options.print_trace_field = value;
 609         }
 610
 611         value = false;
 612         found = false;
 613         ret = apply_one_bool("field-trace:hostname", params, &value, &found);
 614         if (ret != BT_COMPONENT_STATUS_OK) {
 615                 goto end;
 616         }
 617         if (found) {
 618                 pretty->options.print_trace_hostname_field = value;
 619         }
 620
 621         value = false;
 622         found = false;
 623         ret = apply_one_bool("field-trace:domain", params, &value, &found);
 624         if (ret != BT_COMPONENT_STATUS_OK) {
 625                 goto end;
 626         }
 627         if (found) {
 628                 pretty->options.print_trace_domain_field = value;
 629         }
 630
 631         value = false;
 632         found = false;
 633         ret = apply_one_bool("field-trace:procname", params, &value, &found);
 634         if (ret != BT_COMPONENT_STATUS_OK) {
 635                 goto end;
 636         }
 637         if (found) {
 638                 pretty->options.print_trace_procname_field = value;
 639         }
 640
 641         value = false;
 642         found = false;
 643         ret = apply_one_bool("field-trace:vpid", params, &value, &found);
 644         if (ret != BT_COMPONENT_STATUS_OK) {
 645                 goto end;
 646         }
 647         if (found) {
 648                 pretty->options.print_trace_vpid_field = value;
 649         }
 650
 651         value = false;
 652         found = false;
 653         ret = apply_one_bool("field-loglevel", params, &value, &found);
 654         if (ret != BT_COMPONENT_STATUS_OK) {
 655                 goto end;
 656         }
 657         if (found) {
 658                 pretty->options.print_loglevel_field = value;
 659         }
 660
 661         value = false;
 662         found = false;
 663         ret = apply_one_bool("field-emf", params, &value, &found);
 664         if (ret != BT_COMPONENT_STATUS_OK) {
 665                 goto end;
 666         }
 667         if (found) {
 668                 pretty->options.print_emf_field = value;
 669         }
 670
 671         value = false;
 672         found = false;
 673         ret = apply_one_bool("field-callsite", params, &value, &found);
 674         if (ret != BT_COMPONENT_STATUS_OK) {
 675                 goto end;
 676         }
 677         if (found) {
 678                 pretty->options.print_callsite_field = value;
 679         }
 680
 681 end:
 682         bt_put(pretty->plugin_opt_map);
 683         pretty->plugin_opt_map = NULL;
 684         g_free(str);
 685         return ret;
 686 }
 687
 688 static
 689 void set_use_colors(struct pretty_component *pretty)
 690 {
 691         switch (pretty->options.color) {
 692         case PRETTY_COLOR_OPT_ALWAYS:
 693                 pretty->use_colors = true;
 694                 break;
 695         case PRETTY_COLOR_OPT_AUTO:
 696                 pretty->use_colors = pretty->out == stdout &&
 697                         bt_common_colors_supported();
 698                 break;
 699         case PRETTY_COLOR_OPT_NEVER:
 700                 pretty->use_colors = false;
 701                 break;
 702         }
 703 }
 704
 705 static
 706 void init_stream_packet_context_quarks(void)
 707 {
 708         stream_packet_context_quarks[Q_TIMESTAMP_BEGIN] =
 709                 g_quark_from_string("timestamp_begin");
 710         stream_packet_context_quarks[Q_TIMESTAMP_BEGIN] =
 711                 g_quark_from_string("timestamp_begin");
 712         stream_packet_context_quarks[Q_TIMESTAMP_END] =
 713                 g_quark_from_string("timestamp_end");
 714         stream_packet_context_quarks[Q_EVENTS_DISCARDED] =
 715                 g_quark_from_string("events_discarded");
 716         stream_packet_context_quarks[Q_CONTENT_SIZE] =
 717                 g_quark_from_string("content_size");
 718         stream_packet_context_quarks[Q_PACKET_SIZE] =
 719                 g_quark_from_string("packet_size");
 720         stream_packet_context_quarks[Q_PACKET_SEQ_NUM] =
 721                 g_quark_from_string("packet_seq_num");
 722 }
 723
 724 BT_HIDDEN
 725 enum bt_component_status pretty_init(
 726                 struct bt_private_component *component,
 727                 struct bt_value *params,
 728                 UNUSED_VAR void *init_method_data)
 729 {
 730         enum bt_component_status ret;
 731         struct pretty_component *pretty = create_pretty();
 732
 733         if (!pretty) {
 734                 ret = BT_COMPONENT_STATUS_NOMEM;
 735                 goto end;
 736         }
 737
 738         ret = bt_private_component_sink_add_input_private_port(component,
 739                 "in", NULL, NULL);
 740         if (ret != BT_COMPONENT_STATUS_OK) {
 741                 goto end;
 742         }
 743
 744         pretty->out = stdout;
 745         pretty->err = stderr;
 746
 747         pretty->delta_cycles = -1ULL;
 748         pretty->last_cycles_timestamp = -1ULL;
 749
 750         pretty->delta_real_timestamp = -1ULL;
 751         pretty->last_real_timestamp = -1ULL;
 752
 753         ret = apply_params(pretty, params);
 754         if (ret != BT_COMPONENT_STATUS_OK) {
 755                 goto error;
 756         }
 757
 758         set_use_colors(pretty);
 759         ret = bt_private_component_set_user_data(component, pretty);
 760         if (ret != BT_COMPONENT_STATUS_OK) {
 761                 goto error;
 762         }
 763
 764         init_stream_packet_context_quarks();
 765
 766 end:
 767         return ret;
 768 error:
 769         destroy_pretty_data(pretty);
 770         return ret;
 771 }