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