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