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