NAME | SYNOPSIS | DESCRIPTION | OPTIONS | EXAMPLES | ENVIRONMENT VARIABLES | FILES | EXIT STATUS | BUGS | RESOURCES | AUTHORS | COPYRIGHT | SEE ALSO | COLOPHON

BABELTRACE-CONVERT(1)         Babeltrace manual        BABELTRACE-CONVERT(1)

NAME         top

       babeltrace-convert - Convert one or more traces

SYNOPSIS         top

       Convert one or more traces:

       babeltrace convert [GENERAL OPTIONS] [--omit-home-plugin-path]
                          [--omit-system-plugin-path]
                          [--plugin-path=PATH[:PATH]...]
                          [--run-args | --run-args-0] [--retry-duration=DURUS]
                          CONVERSION ARGUMENTS

       Print the metadata text of a CTF trace:

       babeltrace convert [GENERAL OPTIONS] [--omit-home-plugin-path]
                          [--omit-system-plugin-path]
                          [--plugin-path=PATH[:PATH]...]
                          [--output=OUTPATH]
                          --output-format=ctf-metadata TRACE-PATH

       Print the available LTTng live (see <http://lttng.org/docs/#doc-
       lttng-live>) sessions:

       babeltrace convert [GENERAL OPTIONS] [--omit-home-plugin-path]
                          [--omit-system-plugin-path]
                          [--plugin-path=PATH[:PATH]...]
                          [--output=OUTPATH] --input-format=lttng-live URL

DESCRIPTION         top

       The convert command creates a trace conversion graph and runs it.

       See babeltrace-intro(7) to learn more about the Babeltrace project
       and its core concepts.

           Note
           convert is the default babeltrace(1) command: you usually don’t
           need to specify its name. The following commands are equivalent
           if the ... part does not start with another babeltrace(1)
           command’s name, like run or list-plugins:

               $ babeltrace convert ...
               $ babeltrace ...

           If you need to make sure that you are executing the convert
           command, use babeltrace convert explicitly.

       A conversion graph is a specialized trace processing graph focused on
       the conversion of one or more traces to another format, possibly
       filtering their events and other notifications in the process. A
       conversion graph is a linear chain of components after the source
       streams are merged:

           +----------+
           | source 1 |-.
           +----------+ |
                        |  +-------+
           +----------+ '->|       |    +---------+    +------------+
           | source 2 |--->| muxer |--->| trimmer |--->| debug-info |-.
           +----------+ .->|       |    +---------+    +------------+ |
                        |  +-------+                                  |
           +----------+ |    .----------------------------------------'
           |   ...    |-'    |  +---------------+    +------+
           +----------+      '->| other filters |--->| sink |
                                +---------------+    +------+

       Note that the trimmer, debugging information, and other filters are
       optional. See Create implicit components to learn how to enable them.

       If you need another processing graph layout, use the more flexible
       babeltrace-run(1) command.

       Like with the babeltrace-run(1) command, you can create components
       explicitly with the --component option (see Create explicit
       components). You can also use one of the many specific convert
       command options and arguments to create implicit components from
       known component classes (see Create implicit components). For
       example, you can specify a single path argument to print the merged
       events of a CTF trace on the console:

           $ babeltrace /path/to/trace

       This is the equivalent of creating and connecting together:

       ·   A src.ctf.fs component with its path initialization parameter set
           to /path/to/trace.

       ·   A filter.utils.muxer component.

       ·   A sink.text.pretty component.

       This creates the following conversion graph:

           +------------+    +--------------------+    +------------------+
           | src.ctf.fs |    | filter.utils.muxer |    | sink.text.pretty |
           |  [ctf-fs]  |    |       [muxer]      |    |     [pretty]     |
           |            |    |                    |    |                  |
           |    stream0 @--->@                out @--->@ in               |
           |    stream1 @--->@                    |    +------------------+
           |    stream2 @--->@                    |
           |    stream3 @--->@                    |
           +------------+    +--------------------+

       It is equivalent to the following command:

           $ babeltrace run --component=ctf-fs:src.ctf.fs \
                            --key=path --value=/path/to/trace \
                            --component=pretty:sink.text.pretty \
                            --component=muxer:filter.utils.muxer \
                            --connect=ctf-fs:muxer --connect=muxer:pretty

       You can use the --run-args option to make the convert command print
       its equivalent babeltrace-run(1) arguments instead of creating and
       running the conversion graph. The printed arguments are escaped for
       shells, which means you can use them as is on the command line and
       possibly add more options to the run command:

           $ babeltrace run $(babeltrace --run-args /path/to/trace) ...

       The --run-args-0 option is like the --run-args option, but the
       printed arguments are NOT escaped and they are separated by a null
       character instead of a space. This is useful if the resulting
       arguments are not the direct input of a shell, for example if passed
       to xargs -0.

       See EXAMPLES for usage examples.

   Create explicit components
       To explicitly create a component, use the --component option. This
       option specifies:

       ·   Optional: The name of the component instance. You can also use
           the --name option for this.

       ·   The type of the component class to instantiate: source, filter,
           or sink.

       ·   The name of the plugin in which to find the component class to
           instantiate.

       ·   The name of the component class to instantiate.

       You can use the --component option multiple times to create multiple
       components. You can instantiate the same component class multiple
       times as different component instances.

       Immediately following a --component option on the command line, the
       created component is known as the current component (until the next
       --component option).

       The following, optional command-line options apply to the current
       component:

       --name=NAME
           Set the name of the current component to NAME.

       --params=PARAMS
           Add PARAMS to the initialization parameters of the current
           component. If PARAMS contains a key which exists in the current
           component’s initialization parameters, this parameter is
           replaced.

           See Parameters format for the format of PARAMS.

       --path=PATH
           Set the path initialization parameter of the current component to
           PATH (replace the parameter if it exists).

           You can use this option instead of manually specifying
           path="PATH" in a --params option to use your shell’s tilde
           expansion (~). Tilde expansion requires the tilde to be the first
           character of the argument, which is not possible with
           path="PATH".

       --url=URL
           Set the url initialization parameter of the current component to
           URL (replace the parameter if it exists).

       See EXAMPLES for usage examples.

   Create implicit components
       An implicit component is a component which is created and added to
       the conversion graph without an explicit instantiation through the
       --component option. An implicit component is easier to create than an
       explicit component: this is why the convert command exists, as you
       can also create and run a conversion graph with the generic
       babeltrace-run(1) command.

       There are many ways to create implicit components with the convert
       command:

       ·   To create one or more implicit src.ctf.fs components (CTF trace
           read from the file system), use one or more positional arguments
           to specify the paths to the CTF traces to read, and do NOT
           specify the --input-format=lttng-live option.

           Example:

               $ babeltrace /path/to/trace /path/to/other/trace

           The --clock-offset and --clock-offset-ns options apply to all the
           implicit src.ctf.fs components. For example:

               $ babeltrace --clock-offset=3 trace1 trace2

           With the command line above, two implicit src.ctf.fs components
           have their clock-class-offset-s initialization parameter set to
           3, but they have different path parameters (trace1 and trace2).

           You cannot create implicit src.ctf.fs components and an implicit
           src.ctf.lttng-live component.

       ·   To create an implicit src.ctf.lttng-live component (LTTng live
           (see <http://lttng.org/docs/#doc-lttng-live>) input), specify the
           --input-format=lttng-live option and the LTTng relay daemon’s URL
           with the positional argument.

           Example:

               $ babeltrace --input-format=lttng-live \
                            net://localhost/host/abeille/my-session

           You cannot create an implicit src.ctf.lttng-live component and
           implicit src.ctf.fs components.

       ·   To create an implicit filter.utils.trimmer component (trace
           trimmer), specify the --begin, --end, or --timerange option.

           Examples:

               $ babeltrace /path/to/trace --begin=22:14:38 --end=22:15:07

               $ babeltrace /path/to/trace --timerange=22:14:38,22:15:07

               $ babeltrace /path/to/trace --end=12:31:04.882928015

       ·   To create an implicit filter.lttng-utils.debug-info (add
           debugging information to compatible LTTng events), specify any of
           the --debug-info, --debug-info-dir, --debug-info-full-path, or
           --debug-info-target-prefix options.

           Examples:

               $ babeltrace --debug-info /path/to/trace

               $ babeltrace /path/to/trace \
                            --debug-info-target-prefix=/tmp/tgt-root

               $ babeltrace /path/to/trace --debug-info-full-path

       ·   To create an implicit sink.text.pretty component (pretty-printing
           text output to the console or to a file), do any of:

           ·   Specify no other sink components, explicit or implicit. The
               sink.text.pretty implicit component is the default implicit
               sink component. If any other explicit or implicit component
               exists, the default sink.text.pretty sink component is not
               automatically created.

           ·   Specify any of the --clock-cycles, --clock-date, --clock-gmt,
               --clock-seconds, --color, --fields, --names, or --no-delta
               options. You can also specify the --output option without
               using the --output-format=ctf option (in which case --output
               applies to the implicit sink.ctf.fs component).

           ·   Specify the --output-format=text option.

           Examples:

               $ babeltrace /path/to/trace

               $ babeltrace /path/to/trace --no-delta

               $ babeltrace /path/to/trace --output-format=text

               $ babeltrace /path/to/trace --output=/tmp/pretty-out

       ·   To create an implicit sink.utils.dummy component (dummy output),
           specify the --output-format=dummy option. This option disables
           the default implicit sink.text.pretty component.

           Example:

               $ babeltrace /path/to/trace --output-format=dummy

       ·   To create an implicit sink.ctf.fs component (CTF traces written
           to the file system), specify the --output-format=ctf option. This
           option disables the default implicit sink.text.pretty component.
           Use the --output option to specify the output directory.

           Example:

               $ babeltrace /path/to/input/trace --output-format=ctf \
                            --output=my-traces

       You can combine multiple methods to create implicit components. For
       example, you can trim an LTTng (CTF) trace, add debugging information
       to it, and write it as another CTF trace:

           $ babeltrace /path/to/input/trace --timerange=22:14:38,22:15:07 \
                        --debug-info --output-format=ctf --output=out-dir

       The equivalent babeltrace-run(1) command of this convert command is:

           $ babeltrace run --component=src-ctf-fs:src.ctf.fs \
                            --key=path --value=/path/to/input/trace \
                            --component=sink-ctf-fs:sink.ctf.fs \
                            --key=path --value=out-dir \
                            --component=muxer:flt.utils.muxer \
                            --component=trimmer:flt.utils.trimmer \
                            --key=begin --value=22:14:38 \
                            --key=end --value=22:15:07 \
                            --component=dbginfo:flt.lttng-utils.debug-info \
                            --connect=src-ctf-fs:muxer --connect=muxer:trimmer \
                            --connect=trimmer:dbg-info \
                            --connect=dbginfo:sink-ctf-fs

       See EXAMPLES for more examples.

   Parameters format
       The format of the PARAMS option’s argument is a comma-separated list
       of NAME=VALUE assignments:

           NAME=VALUE[,NAME=VALUE]...

       NAME
           Parameter name (C identifier plus the :, ., and - characters).

       VALUE
           One of:

           ·   null, nul, NULL: null value.

           ·   true, TRUE, yes, YES: true boolean value.

           ·   false, FALSE, no, NO: false boolean value.

           ·   Binary (0b prefix), octal (0 prefix), decimal, or hexadecimal
               (0x prefix) signed 64-bit integer.

           ·   Double precision floating point number (scientific notation
               is accepted).

           ·   Unquoted string with no special characters, and not matching
               any of the null and boolean value symbols above.

           ·   Double-quoted string (accepts escape characters).

           You may put whitespaces around the individual = (assignment) and
           , (separator) characters.

       Example:

           babeltrace ... --params='many=null, fresh=yes, condition=false,
                                    squirrel=-782329, observe=3.14,
                                    simple=beef, needs-quotes="some string",
                                    escape.chars-are:allowed="a \" quote"'

           Important
           Like in the example above, make sure to single-quote the whole
           argument when you run this command from a shell.

   Time option format
       The format of the arguments of the --begin and --end options is:

           [YYYY-MM-DD [hh:mm:]]ss[.nnnnnnnnn]

       YYYY
           4-digit year.

       MM
           2-digit month (January is 01).

       DD
           2-digit day.

       hh
           2-digit hour (24-hour format).

       mm
           2-digit minute.

       ss
           2-digit second.

       nnnnnnnnn
           9-digit nanosecond.

   Plugin path
       This command loads Babeltrace plugins to perform its operation. The
       search path for Babeltrace plugins is, in this order:

        1. The colon-separated list of directories in the
           BABELTRACE_PLUGIN_PATH environment variable.

        2. The colon-separated list of directories in the --plugin-path
           option.

        3. If the --omit-home-plugin-path option is absent:
           $HOME/.local/lib/babeltrace/plugins

        4. If the --omit-system-plugin-path option is absent:
           /usr/local/lib/babeltrace/plugins

       You can use the babeltrace-list-plugins(1) command to dynamically
       list the available plugins.

OPTIONS         top

   General options
       See babeltrace(1) for more details.

       -d, --debug
           Turn the debugging mode on.

       --log-level=LVL
           Set the log level of all known Babeltrace loggers to LVL.

       -v, --verbose
           Turn the verbose mode on.

       -h, --help
           Show general help and quit.

       -V, --version
           Show version and quit.

   Explicit component creation
       See Create explicit components to learn how to use the following
       options.

       -c [NAME:]TYPE.PLUGIN.COMPCLS, --component=[NAME:]TYPE.PLUGIN.COMPCLS
           Create a component initially named NAME (if specified) from the
           component class of type TYPE named COMPCLS found in the plugin
           named PLUGIN, and set it as the current component.

           The available values for TYPE are:

           source, src
               Source component class.

           filter, flt
               Filter component class.

           sink
               Sink component class.

       --name=NAME
           Set the name of the current component to NAME. The names of all
           the explicitly created components in the conversion graph must be
           unique.

       -p PARAMS, --params=PARAMS
           Add PARAMS to the initialization parameters of the current
           component. If PARAMS contains a key which exists in the current
           component’s initialization parameters, replace the parameter. See
           Parameters format for the format of PARAMS.

       -P PATH, --path=PATH
           Set the path initialization parameter of the current component to
           PATH (replace the parameter if it exists).

       -u URL, --url=URL
           Set the url initialization parameter of the current component to
           URL (replace the parameter if it exists).

   Legacy options to create implicit components
       -i FORMAT, --input-format=FORMAT
           Create one or more implicit source components. The available
           values for FORMAT are:

           ctf
               Create an implicit src.ctf.fs component for each positional
               argument. Each positional argument sets the path
               initialization parameter of an individual component. See
               Implicit src.ctf.fs component.

               See babeltrace-source.ctf.fs(7) to learn more about this
               component class.

           lttng-live
               Depending on the format of the positional argument:

               net[4]://RDHOST[:RDPORT]/host/TGTHOST
                   Print the available LTTng live sessions of the LTTng
                   relay daemon at the address RDHOST and port RDPORT, and
                   then exit.

               net[4]://RDHOST[:RDPORT]/host/TGTHOST/SESSION
                   Create an implicit src.ctf.lttng-live component. The
                   position argument sets the url parameter of the
                   component.

                   Any other format for the positional argument is invalid.

                   See babeltrace-source.ctf.lttng-live(7) to learn more
                   about this component class.

           You can specify at most one --input-format option.

       -o FORMAT, --output-format=FORMAT
           Create an implicit sink component. The available values for
           FORMAT are:

           text
               Create an implicit sink.text.pretty component. See Implicit
               sink.text.pretty component.

               See babeltrace-sink.text.pretty(7) to learn more about this
               component class.

           ctf
               Create an implicit sink.ctf.fs component. Specify the output
               path with the --output option.

               See babeltrace-sink.ctf.fs(7) to learn more about this
               component class.

           dummy
               Create an implicit sink.utils.dummy component.

               See babeltrace-sink.utils.dummy(7) to learn more about this
               component class.

           ctf-metadata
               Print the metadata text of a CTF trace and exit. The first
               positional argument specifies the path to the CTF trace.

           You can specify at most one --output-format option.

   Implicit src.ctf.fs component(s)
       There is one implicit src.ctf.fs component per positional argument
       (which are trace paths), unless you specify --input-format=lttng-
       live.

       See babeltrace-source.ctf.fs(7) to learn more about this component
       class.

       --clock-offset=SEC
           Set the clock-class-offset-s initialization parameter of all the
           implicit src.ctf.fs components to SEC.

           The clock-class-offset-s initialization parameter adds SEC
           seconds to the offsets of all the clock classes that the
           component creates.

           You can combine this option with --clock-offset-ns.

       --clock-offset-ns=NS
           Set the clock-class-offset-ns initialization parameter of all the
           implicit src.ctf.fs components to NS.

           The clock-class-offset-ns initialization parameter adds NS
           nanoseconds to the offsets of all the clock classes that the
           component creates.

           You can combine this option with --clock-offset-s.

   Implicit filter.utils.trimmer component
       If you specify at least one of the following options, you create an
       implicit filter.utils.trimmer component.

       See babeltrace-filter.utils.trimmer(7) to learn more about this
       component class.

       See Time option format for the format of BEGIN and END.

       --begin=BEGIN
           Set the begin initialization parameter of the component to BEGIN.
           You cannot use this option with the --timerange option.

       --end=END
           Set the end initialization parameter of the component to END. You
           cannot use this option with the --timerange option.

       --timerange=BEGIN,END
           Equivalent to --begin=BEGIN --end=END.

           You can also surround the whole argument with [ and ].

   Implicit filter.lttng-utils.debug-info component
       If you specify at least one of the following options, you create an
       implicit filter.lttng-utils.debug-info component. This component only
       alters compatible LTTng events.

       See babeltrace-filter.lttng-utils.debug-info(7) to learn more about
       this component class.

       --debug-info
           Create an implicit filter.lttng-utils.debug-info component. This
           option is useless if you specify any of the options below.

       --debug-info-dir=DIR
           Set the debug-info-dir initialization parameter of the component
           to DIR.

           The debug-info-dir parameter indicates where the component should
           find the debugging information it needs if it’s not found in the
           actual executable files.

       --debug-info-full-path
           Set the full-path initialization parameter of the component to
           true.

           When the full-path parameter is true, the component writes the
           full (absolute) paths to files in its debugging information
           fields instead of just the short names.

       --debug-info-target-prefix=PREFIX
           Set the target-prefix initialization parameter of the component
           to PREFIX.

           The target-prefix parameter is a path to prepend to the paths to
           executables recorded in the trace. For example, if a trace
           contains the executable path /usr/bin/ls in its state dump
           events, and you specify --debug-info-target-
           prefix=/home/user/boards/xyz/root, then the component opens the
           /home/user/boards/xyz/root/usr/bin/ls file to find debugging
           information.

   Implicit sink.text.pretty component
       If you specify at least one of the following options, you create an
       implicit sink.text.pretty component. The convert command also creates
       a default implicit sink.text.pretty component if no other sink
       component exists.

       See babeltrace-sink.text.pretty(7) to learn more about this component
       class.

       --clock-cycles
           Set the clock-seconds initialization parameter of the component
           to true.

           The clock-cycles parameter makes the component print the event
           time in clock cycles.

       --clock-date
           Set the clock-date initialization parameter of the component to
           true.

           The clock-date parameter makes the component print the date and
           the time of events.

       --clock-gmt
           Set the clock-gmt initialization parameter of the component to
           true.

           The clock-gmt parameter makes the component not apply the local
           timezone to the printed times.

       --clock-seconds
           Set the clock-seconds initialization parameter of the component
           to true.

           The clock-seconds parameter makes the component print the event
           times in seconds since Epoch.

       --color=WHEN
           Set the color initialization parameter of the component to WHEN.

           The available values for WHEN are:

           auto
               Automatic color support depending on the capabilities of the
               terminal(s) to which the standard output and error streams
               are connected.

           never
               Never emit terminal color codes.

           always
               Always emit terminal color codes.

           The auto and always values have no effect if the
           BABELTRACE_TERM_COLOR environment variable is set to NEVER.

       --fields=FIELD[,FIELD]...
           For each FIELD, set the field-FIELD initialization parameter of
           the component to true.

           For example, --fields=trace,loglevel,emf sets the field-trace,
           field-loglevel, and field-emf initialization parameters to true.

           The available value for FIELD are:

           ·   trace

           ·   trace:hostname

           ·   trace:domain

           ·   trace:procname

           ·   trace:vpid

           ·   loglevel

           ·   emf

           ·   callsite

       --names=NAME[,NAME]...
           For each NAME, set the name-NAME initialization parameter of the
           component to true.

           For example, --names=payload,scope sets the name-payload and
           name-scope initialization parameters to true.

           The available value for NAME are:

           ·   payload

           ·   context

           ·   scope

           ·   header

       --no-delta
           Set the no-delta initialization parameter of the component to
           true.

           When the no-delta parameter is true, the component does not print
           the duration since the last event on the line.

   Shared options
       -w PATH, --output=PATH
           With --output-format=ctf-metadata or --input-format=lttng-live
           (when printing the available LTTng live sessions), write the text
           to the file PATH instead of the standard output.

           When you specify --output-format=ctf, set the path initialization
           parameter of the implicit sink.ctf.fs component to PATH.
           Otherwise, create an implicit sink.text.pretty component and set
           its path initialization parameter to PATH.

           See babeltrace-sink.ctf.fs(7) and babeltrace-sink.text.pretty(7)
           to learn more about those component classes.

   Equivalent babeltrace run arguments
       --run-args
           Print the equivalent babeltrace-run(1) arguments instead of
           creating and running the conversion graph. The printed arguments
           are space-separated and individually escaped for safe shell
           input.

           You cannot use this option with the --run-args-0 or --stream-
           intersection option.

       --run-args-0
           Print the equivalent babeltrace-run(1) arguments instead of
           creating and running the conversion graph. The printed arguments
           are separated with a null character and NOT escaped for safe
           shell input.

           You cannot use this option with the --run-args or --stream-
           intersection option.

   Conversion graph configuration
       --retry-duration=DURUS
           Set the duration of a single retry to DURUS µs when a component
           reports "try again later" (busy network or file system, for
           example).

           Default: 100000 (100 ms).

       --stream-intersection
           Enable the stream intersection mode. In this mode, for each
           trace, the convert command filters out the events and other
           notifications which are not in the time range where all the
           trace’s streams are active.

           All the source components, explicit and implicit, must have
           classes which support the trace-info query object to use this
           option. The only Babeltrace project’s component class which
           supports this query object is source.ctf.fs.

           Because it is not possible to replicate with a single
           babeltrace-run(1) command line what the convert method does with
           the --stream-intersection option, you cannot use this option with
           the --run-args or --run-args-0 option.

   Plugin path
       --omit-home-plugin-path
           Do not search for plugins in $HOME/.local/lib/babeltrace/plugins.

       --omit-system-plugin-path
           Do not search for plugins in /usr/local/lib/babeltrace/plugins.

       --plugin-path=PATH[:PATH]...
           Add PATH to the list of paths in which dynamic plugins can be
           found.

   Command information
       -h, --help
           Show command help and quit.

EXAMPLES         top

       Example 1. Pretty-print the events of one or more CTF traces.

           $ babeltrace my-trace

           $ babeltrace my-traces

           $ babeltrace my-trace-1 my-trace-2 my-trace-3

       Example 2. Trim a CTF trace and pretty-print the events.

           $ babeltrace my-trace --begin=22:55:43.658582931 \
                        --end=22:55:46.967687564

           $ babeltrace my-trace --begin=22:55:43.658582931

           $ babeltrace my-trace --end=22:55:46.967687564

           $ babeltrace my-trace --timerange=22:55:43,22:55:46.967687564

       Example 3. Trim a CTF trace, enable the stream intersection mode, and
       generate a CTF trace.

           $ babeltrace my-trace --stream-intersection \
                        --timerange=22:55:43,22:55:46.967687564 \
                        --output-format=ctf --output=out-trace

       Example 4. Record LTTng live traces to the file system (as CTF
       traces).

           $ babeltrace --input-format=lttng-live \
                        net://localhost/host/myhostname/auto-20170411-134512 \
                        --output-format=ctf --output=/path/to/generated/traces

       Example 5. Read a CTF trace as fast as possible using a dummy output.

           $ babeltrace my-trace --output-format=dummy

       Example 6. Read three CTF traces in stream intersection mode, add
       debugging information, and pretty-print them to a file.

           $ babeltrace trace1 trace2 trace3 --stream-intersection \
                        --debug-info --output=pretty-out

       Example 7. Pretty-print a CTF trace and traces from an explicit
       source component, with the event times showed in seconds since Epoch.

           $ babeltrace ctf-trace --component=src.my-plugin.my-src \
                        --params=output-some-event-type=yes --clock-seconds

       Example 8. Send LTTng live events to an explicit sink component.

           $ babeltrace --input-format=lttng-live \
                        net://localhost/host/myhostname/mysession \
                        --component=sink.my-plugin.my-sink

       Example 9. Trim a CTF trace, add debugging information, apply an
       explicit filter component, and write as a CTF trace.

           $ babeltrace /path/to/trace --timerange=22:14:38,22:15:07 \
                        --debug-info --component=filter.my-plugin.my-filter \
                        --params=criteria=xyz,ignore-abc=yes \
                        --output-format=ctf --output=out-trace

       Example 10. Print the metadata text of a CTF trace.

           $ babeltrace /path/to/trace --output-format=ctf-metadata

       Example 11. Print the available LTTng live sessions of an LTTng relay
       daemon.

           $ babeltrace --input-format=lttng-live net://localhost

ENVIRONMENT VARIABLES         top

   Babeltrace library
       BABELTRACE_COMMON_LOG_LEVEL
           Common functions’s log level. The available values are the same
           as for the --log-level option of babeltrace(1).

       BABELTRACE_COMPAT_LOG_LEVEL
           Compatibility functions’s log level. The available values are the
           same as for the --log-level option of babeltrace(1).

       BABELTRACE_TERM_COLOR
           Force the terminal color support. The available values are:

           AUTO
               Only emit terminal color codes when the standard output and
               error streams are connected to a color-capable terminal.

           NEVER
               Never emit terminal color codes.

           ALWAYS
               Always emit terminal color codes.

       BABELTRACE_DISABLE_PYTHON_PLUGINS
           Set to 1 to disable the loading of any Babeltrace Python plugin.

       BABELTRACE_LOGGING_GLOBAL_LEVEL
           Babeltrace library’s global log level. The available values are
           the same as for the --log-level option of babeltrace(1)

       BABELTRACE_NO_DLCLOSE
           Set to 1 to make the Babeltrace library leave any dynamically
           loaded modules (plugins and Python plugin provider) open at exit.
           This can be useful for debugging purposes.

       BABELTRACE_PLUGIN_PATH
           Colon-separated list of directories, in order, in which dynamic
           plugins can be found before other directories are considered.

   Python plugin provider
       BABELTRACE_PYTHON_PLUGIN_PROVIDER_LOG_LEVEL
           Python plugin provider’s log level. The available values are the
           same as for the --log-level option of babeltrace(1).

   CLI
       BABELTRACE_CLI_LOG_LEVEL
           babeltrace CLI’s log level. The available values are the same as
           for the --log-level option.

       BABELTRACE_CLI_WARN_COMMAND_NAME_DIRECTORY_CLASH
           Set to 0 to disable the warning message which babeltrace prints
           when you convert a trace with a relative path that’s also the
           name of a babeltrace command.

FILES         top

       $HOME/.local/lib/babeltrace/plugins
           User plugin directory.

       /usr/local/lib/babeltrace/plugins
           System plugin directory.

EXIT STATUS         top

       0 on success, 1 otherwise.

BUGS         top

       If you encounter any issue or usability problem, please report it on
       the Babeltrace bug tracker (see
       <https://bugs.linuxfoundation.org/buglist.cgi?product=Diamon&component=Babeltrace>).

RESOURCES         top

       The Babeltrace project shares some communication channels with the
       LTTng project (see <http://lttng.org/>).

       ·   Babeltrace website (see <http://diamon.org/babeltrace>)

       ·   Git repository (see
           <http://git.linuxfoundation.org/?p=diamon/babeltrace.git>)

       ·   EfficiOS GitHub organization (see <http://github.com/efficios/>)

       ·   Continuous integration (see
           <https://ci.lttng.org/job/babeltrace_master_build/>)

       ·   Mailing list (see <http://lists.lttng.org>) for support and
           development: lttng-dev@lists.lttng.org

       ·   IRC channel (see <irc://irc.oftc.net/lttng>): #lttng on
           irc.oftc.net

AUTHORS         top

       The Babeltrace project is the result of efforts by many regular
       developers and occasional contributors.

       The current project maintainer is Jérémie Galarneau
       <mailto:jeremie.galarneau@efficios.com>.

COPYRIGHT         top

       This command is part of the Babeltrace project.

       Babeltrace is distributed under the MIT license (see
       <https://opensource.org/licenses/MIT>).

SEE ALSO         top

       babeltrace(1), babeltrace-run(1), babeltrace-intro(7)

COLOPHON         top

       This page is part of the babeltrace (trace read and write libraries
       and a trace converter) project.  Information about the project can be
       found at ⟨http://www.efficios.com/babeltrace⟩.  If you have a bug
       report for this manual page, send it to lttng-dev@lists.lttng.org.
       This page was obtained from the project's upstream Git repository
       ⟨git://git.efficios.com/babeltrace.git⟩ on 2017-11-25.  (At that
       time, the date of the most recent commit that was found in the repos‐
       itory was 2017-11-23.)  If you discover any rendering problems in
       this HTML version of the page, or you believe there is a better or
       more up-to-date source for the page, or you have corrections or
       improvements to the information in this COLOPHON (which is not part
       of the original manual page), send a mail to man-pages@man7.org

Babeltrace 2.0.0-pre4          5 October 2017          BABELTRACE-CONVERT(1)

Pages that refer to this page: babeltrace(1)babeltrace-run(1)babeltrace-intro(7)