LTTng

https://lttng.org/docs/2.15/
Admin
LTTng is an open source Linux kernel and user space tracer that provides low-overhead, comprehensive...
Tokens:43,555
Snippets:592
Trust Score:9.9
Update:5 months ago
Show doc for...
Tokens:
Raw
### Example: Rebuild Quick Start as 32-bit Application

Source: https://lttng.org/docs

Demonstrates rebuilding the 'quick start' example as a 32-bit instrumented application using gcc, including compilation and linking steps with necessary flags.

```bash
gcc -m32 -c -I. hello-tp.c
gcc -m32 -c hello.c
gcc -m32 -o hello hello.o hello-tp.o \
    -L/usr/lib32 -L/usr/local/lib32 \
    -Wl,-rpath,/usr/lib32,-rpath,/usr/local/lib32 \
    -llttng-ust -ldl
```

--------------------------------

### LTTng Session Setup and Start

Source: https://lttng.org/docs

Commands to create an LTTng recording session, enable Python logging events from a specific logger, and start recording.

```bash
lttng create
lttng enable-event --python my-logger
lttng start
```

--------------------------------

### Create and Start an LTTng Recording Session

Source: https://lttng.org/docs

Set up an LTTng recording session named 'my-session', enable all userspace events, and start the recording process.

```bash
lttng create my-session
lttng enable-event --userspace --all
lttng start
```

--------------------------------

### Build and Install 64-bit LTTng-Tools

Source: https://lttng.org/docs

Builds and installs the 64-bit version of LTTng-tools, configuring it to use the previously installed 32-bit consumer daemon.

```bash
cd $(mktemp -d) &&
wget https://lttng.org/files/lttng-tools/lttng-tools-latest-2.15.tar.bz2 &&
tar -xf lttng-tools-latest-2.15.tar.bz2 &&
cd lttng-tools-2.15.*
./configure --with-consumerd32-libdir=/usr/local/lib32 \
            --with-consumerd32-bin=/usr/local/lib32/lttng/libexec/lttng-consumerd &&
make &&
sudo make install &&
sudo ldconfig
```

--------------------------------

### Setup LTTng Recording Session for JUL Events

Source: https://lttng.org/docs

Create an LTTng recording session, enable JUL events for a specific logger, and start the recording.

```bash
lttng create
lttng enable-event --jul jello
lttng start
```

--------------------------------

### Build and Install 32-bit LTTng-Tools Consumer Daemon

Source: https://lttng.org/docs

Builds and installs the 32-bit LTTng-tools consumer daemon. This step requires disabling certain binaries to focus on the consumer daemon installation.

```bash
cd $(mktemp -d) &&
wget https://lttng.org/files/lttng-tools/lttng-tools-latest-2.15.tar.bz2 &&
tar -xf lttng-tools-latest-2.15.tar.bz2 &&
cd lttng-tools-2.15.*
./configure --libdir=/usr/local/lib32 CFLAGS=-m32 CXXFLAGS=-m32 \
            LDFLAGS='-L/usr/local/lib32 -L/usr/lib32' \
            --disable-bin-lttng --disable-bin-lttng-crash \
            --disable-bin-lttng-relayd --disable-bin-lttng-sessiond &&
make &&
cd src/bin/lttng-consumerd &&
sudo make install &&
sudo ldconfig
```

--------------------------------

### Complete Java JUL Logging Example with LTTng-UST Agent

Source: https://lttng.org/docs

A full Java example demonstrating the integration of the LTTng-UST agent with java.util.logging, including setup, logging, and cleanup.

```java
import java.io.IOException;
import java.util.logging.Handler;
import java.util.logging.Logger;
import org.lttng.ust.agent.jul.LttngLogHandler;

public class Test
{
    private static final int answer = 42;

    public static void main(String[] argv) throws Exception
    {
        // Create a logger
        Logger logger = Logger.getLogger("jello");

        // Create an LTTng-UST log handler
        Handler lttngUstLogHandler = new LttngLogHandler();

        // Add the LTTng-UST log handler to our logger
        logger.addHandler(lttngUstLogHandler);

        // Log at will!
        logger.info("some info");
        logger.warning("some warning");
        Thread.sleep(500);
        logger.finer("finer information; the answer is " + answer);
        Thread.sleep(123);
        logger.severe("error!");

        // Not mandatory, but cleaner
        logger.removeHandler(lttngUstLogHandler);
        lttngUstLogHandler.close();
    }
}
```

--------------------------------

### Build LTTng-UST from Source

Source: https://lttng.org/docs

Installs LTTng-UST (User Space Tracing) from source. Configure with options like --enable-java-agent-jul or --enable-python-agent if needed. After installation, update LD_LIBRARY_PATH and use linker options for applications to find the UST libraries.

```bash
cd $(mktemp -d) &&
wget https://lttng.org/files/lttng-ust/lttng-ust-latest-2.15.tar.bz2 &&
tar -xf lttng-ust-latest-2.15.tar.bz2 &&
cd lttng-ust-2.15.* &&
./configure &&
make &&
sudo make install &&
sudo ldconfig
```

--------------------------------

### Enable Kernel Events and Start Recording

Source: https://lttng.org/docs

Enable kernel scheduling events and start the LTTng recording session. This prepares the session for data collection before rotation.

```bash
lttng enable-event --kernel sched_'
'
```

```bash
lttng start
```

--------------------------------

### Create User Space Channel with Infinite Blocking Timeout

Source: https://lttng.org/docs

Creates a user space channel with an infinite blocking timeout. This example also shows the full sequence of creating a session, channel, event rule, and starting recording.

```bash
lttng create
```

```bash
lttng enable-channel --userspace --blocking-timeout=inf blocking-chan
```

```bash
lttng enable-event --userspace --channel=blocking-chan --all
```

```bash
lttng start
```

--------------------------------

### Complete Java Example with LTTng-UST log4j 1.2 Agent

Source: https://lttng.org/docs

A full Java example demonstrating the integration of the LTTng-UST agent with Apache log4j 1.2, including logger setup, event emission, and appender cleanup.

```java
import org.apache.log4j.Appender;
import org.apache.log4j.Logger;
import org.lttng.ust.agent.log4j.LttngLogAppender;

public class Test
{
    private static final int answer = 42;

    public static void main(String[] argv) throws Exception
    {
        // Create a logger
        Logger logger = Logger.getLogger("jello");

        // Create an LTTng-UST log appender
        Appender lttngUstLogAppender = new LttngLogAppender();

        // Add the LTTng-UST log appender to our logger
        logger.addAppender(lttngUstLogAppender);

        // Log at will!
        logger.info("some info");
        logger.warn("some warning");
        Thread.sleep(500);
        logger.debug("debug information; the answer is " + answer);
        Thread.sleep(123);
        logger.fatal("error!");

        // Not mandatory, but cleaner
        logger.removeAppender(lttngUstLogAppender);
        lttngUstLogAppender.close();
    }
}
```

--------------------------------

### Create and Start LTTng Recording Session

Source: https://lttng.org/docs

Commands to create a new LTTng recording session, enable kernel events named 'lttng_logger', and start the recording process.

```bash
lttng create
```

```bash
lttng enable-event --kernel lttng_logger
```

```bash
lttng start
```

--------------------------------

### Start User Session Daemon

Source: https://lttng.org/docs

Run lttng-sessiond in the background for user-space tracing. Remove --daemonize to run in the foreground.

```bash
lttng-sessiond --daemonize
```

--------------------------------

### Start LTTng Recording

Source: https://lttng.org/docs

Begin the LTTng recording session to capture events and context data.

```bash
lttng start
```

--------------------------------

### Build and Install 32-bit LTTng-UST 2.15

Source: https://lttng.org/docs

Builds and installs a 32-bit version of LTTng-UST. Configure with specific library paths for 32-bit components. Add --disable-numa if numactl is not available.

```bash
cd $(mktemp -d) &&
wget https://lttng.org/files/lttng-ust/lttng-ust-latest-2.15.tar.bz2 &&
tar -xf lttng-ust-latest-2.15.tar.bz2 &&
cd lttng-ust-2.15.*
./configure --libdir=/usr/local/lib32 \
            CFLAGS=-m32 CXXFLAGS=-m32 \
            LDFLAGS='-L/usr/local/lib32 -L/usr/lib32' &&
make &&
sudo make install &&
sudo ldconfig
```

--------------------------------

### Start LTTng Recording Session

Source: https://lttng.org/docs

Create an LTTng tracing session, enable events for the 'jello2' logger, and start recording. This prepares the system to capture Log4j 2 events.

```bash
lttng create
lttng enable-event --log4j2 jello2
lttng start
```

--------------------------------

### LTTNG_UST_TP_ARGS Usage Example

Source: https://lttng.org/docs

Demonstrates the usage of the LTTNG_UST_TP_ARGS macro with three input arguments.

```c
LTTNG_UST_TP_ARGS(
    int, count,
    float, ratio,
    const char*, query
)

```

--------------------------------

### Build and Install 32-bit Userspace RCU

Source: https://lttng.org/docs

Builds and installs a 32-bit version of Userspace RCU. Ensure the target system has no existing LTTng packages before starting.

```bash
cd $(mktemp -d) &&
wget https://lttng.org/files/urcu/userspace-rcu-latest-0.13.tar.bz2 &&
tar -xf userspace-rcu-latest-0.13.tar.bz2 &&
cd userspace-rcu-0.13.*
./configure --libdir=/usr/local/lib32 CFLAGS=-m32 &&
make &&
sudo make install &&
sudo ldconfig
```

--------------------------------

### Start LTTng Recording Session for log4j Events

Source: https://lttng.org/docs

Create an LTTng tracing session, enable log4j events for a specific logger name (e.g., 'jello'), and start the recording process.

```bash
lttng create
lttng enable-event --log4j jello
lttng start
```

--------------------------------

### Run Application Without Tracing Support

Source: https://lttng.org/docs

Start the application normally to run without tracing support.

```bash
./app
```

--------------------------------

### Full Java Application Example with LTTng Context

Source: https://lttng.org/docs

A complete Java application demonstrating the integration of LTTng-UST context fields with java.util.logging. This example shows how to set up the logger, add the LTTng handler, and log messages with custom context.

```java
import java.util.logging.Handler;
import java.util.logging.Logger;
import org.lttng.ust.agent.jul.LttngLogHandler;
import org.lttng.ust.agent.context.ContextInfoManager;
import org.lttng.ust.agent.context.IContextInfoRetriever;

public class Test
{
    // Our context information retriever class
    private static class MyContextInfoRetriever
    implements IContextInfoRetriever
    {
        @Override
        public Object retrieveContextInfo(String key) {
            if (key.equals("intCtx")) {
                return (short) 17;
            } else if (key.equals("strContext")) {
                return "context value!";
            } else {
                return null;
            }
        }
    }

    private static final int answer = 42;

    public static void main(String args[]) throws Exception
    {
        // Get the context information manager instance
        ContextInfoManager cim = ContextInfoManager.getInstance();

        // Create and register our context information retriever
        IContextInfoRetriever cir = new MyContextInfoRetriever();
        cim.registerContextInfoRetriever("myRetriever", cir);

        // Create a logger
        Logger logger = Logger.getLogger("jello");

        // Create an LTTng-UST log handler
        Handler lttngUstLogHandler = new LttngLogHandler();

        // Add the LTTng-UST log handler to our logger
        logger.addHandler(lttngUstLogHandler);

        // Log at will!
        logger.info("some info");
        logger.warning("some warning");
        Thread.sleep(500);
        logger.finer("finer information; the answer is " + answer);
        Thread.sleep(123);
        logger.severe("error!");

        // Not mandatory, but cleaner
        logger.removeHandler(lttngUstLogHandler);
        lttngUstLogHandler.close();
        cim.unregisterContextInfoRetriever("myRetriever");
    }
}

```

--------------------------------

### Build LTTng-Tools from Source

Source: https://lttng.org/docs

Installs LTTng-tools from source. This package provides the command-line utilities for managing LTTng tracing sessions. Ensure LTTng-modules and LTTng-UST are installed prior to this step.

```bash
cd $(mktemp -d) &&
wget https://lttng.org/files/lttng-tools/lttng-tools-latest-2.15.tar.bz2 &&
tar -xf lttng-tools-latest-2.15.tar.bz2 &&
cd lttng-tools-2.15.* &&
./configure &&
make &&
sudo make install &&
sudo ldconfig
```

--------------------------------

### Start LTTng Session Daemon

Source: https://lttng.org/docs

Starts the LTTng session daemon in the background. This daemon manages LTTng recording sessions.

```bash
lttng-sessiond --daemonize

```

--------------------------------

### Enable Basic Userspace Event

Source: https://lttng.org/docs

Enables the 'hello:world' event in userspace. This is a general command to start capturing events from a specific user-space application component.

```bash
lttng enable-event --userspace hello:world
```

--------------------------------

### Example: Use LTTng Logger in Bash Script

Source: https://lttng.org/docs

This example demonstrates writing two distinct messages to the LTTng logger from a bash script. The first message is a simple string, and the second includes output from a command.

```bash
echo 'Hello, World!' > /dev/lttng-logger
sleep 2
df --human-readable --print-type / > /dev/lttng-logger
```

--------------------------------

### Create and Configure LTTng Session for Trigger

Source: https://lttng.org/docs

Creates a recording session named 'pitou' and enables all kernel system call events. This setup is used in conjunction with adding a trigger.

```bash
lttng create pitou
lttng enable-event --kernel --syscall --all
```

--------------------------------

### Start LTTng Recording

Source: https://lttng.org/docs

Begins recording trace data for the currently active LTTng session based on the enabled event rules.

```bash
lttng start

```

--------------------------------

### Run Python Script

Source: https://lttng.org/docs

Execute the instrumented Python script after starting the LTTng recording session.

```bash
python test.py
```

--------------------------------

### Create LTTng Kernel Event Rules

Source: https://lttng.org/docs

Defines rules to record specific kernel events. This example sets up rules for 'sched_switch' and 'sched_process_fork' tracepoints, and 'open' and 'close' system calls.

```bash
lttng add-rule my-kernel-session --userspace --kernel sched_switch --kernel sched_process_fork --syscall open --syscall close
```

--------------------------------

### Create LTTng Session in Live Mode

Source: https://lttng.org/docs

Start an LTTng recording session in live mode on the target system. This spawns a local relay daemon that forwards trace data to both the local file system and connected live readers.

```bash
lttng create my-session --live
```

--------------------------------

### Build and Install LTTng Kernel Modules

Source: https://lttng.org/docs

Compile the LTTng kernel modules using make, specifying the path to your Linux kernel source tree. Then, install the modules and update the module dependencies.

```bash
make KERNELDIR=/path/to/linux
make modules_install && depmod -a
```

--------------------------------

### Compile Java Example with LTTng and log4j JARs

Source: https://lttng.org/docs

Compile the Java test application, ensuring the LTTng-UST agent JARs and the Apache log4j 1.2 JAR are included in the classpath.

```bash
javac -cp /usr/share/java/lttng-ust-agent-common.jar:/usr/share/java/lttng-ust-agent-log4j.jar:"$LOG4JPATH" Test.java
```

--------------------------------

### Complete Tracepoint Definition Example

Source: https://lttng.org/docs

An example of a complete tracepoint definition including input arguments and output event fields. Note the use of custom structure fields and different field types.

```c
#include "my-custom-structure.h"

LTTNG_UST_TRACEPOINT_EVENT(
    my_provider,
    my_tracepoint,
    LTTNG_UST_TP_ARGS(
        const struct my_custom_structure *, my_custom_structure,
        float, ratio,
        const char *, query
    ),
    LTTNG_UST_TP_FIELDS(
        lttng_ust_field_string(query_field, query)
        lttng_ust_field_float(double, ratio_field, ratio)
        lttng_ust_field_integer(int, recv_size,
                                my_custom_structure->recv_size)
        lttng_ust_field_integer(int, send_size,
                                my_custom_structure->send_size)
    )
)


```

--------------------------------

### Python Application with Logging

Source: https://lttng.org/docs

Example Python script demonstrating the use of the LTTng-UST Python agent with the standard logging module. Ensure the agent is imported before extensive logging occurs.

```python
import lttngust
import logging
import time


def example():
    logging.basicConfig()
    logger = logging.getLogger('my-logger')

    while True:
        logger.debug('debug message')
        logger.info('info message')
        logger.warn('warn message')
        logger.error('error message')
        logger.critical('critical message')
        time.sleep(1)


if __name__ == '__main__':
    example()
```

--------------------------------

### Compile Java Example with LTTng-UST JARs

Source: https://lttng.org/docs

Compile the Java test class, ensuring the LTTng-UST agent common and JUL JARs are included in the classpath.

```bash
javac -cp /usr/share/java/lttng-ust-agent-common.jar:/usr/share/java/lttng-ust-agent-jul.jar Test.java
```

--------------------------------

### Tracepoint Provider Header File Template

Source: https://lttng.org/docs

Use this template as a starting point for your tracepoint provider header file. Replace `provider_name` with your provider's name and `./tp.h` with your header file's name. Place your tracepoint definitions below the `#include <lttng/tracepoint.h>` line.

```c
#undef LTTNG_UST_TRACEPOINT_PROVIDER
#define LTTNG_UST_TRACEPOINT_PROVIDER provider_name

#undef LTTNG_UST_TRACEPOINT_INCLUDE
#define LTTNG_UST_TRACEPOINT_INCLUDE "./tp.h"

#if !defined(_TP_H) || defined(LTTNG_UST_TRACEPOINT_HEADER_MULTI_READ)
#define _TP_H

#include <lttng/tracepoint.h>

/*
 * Use LTTNG_UST_TRACEPOINT_EVENT(), LTTNG_UST_TRACEPOINT_EVENT_CLASS(),
 * LTTNG_UST_TRACEPOINT_EVENT_INSTANCE(), and
 * LTTNG_UST_TRACEPOINT_LOGLEVEL() here.
 */

#endif /* _TP_H */

#include <lttng/tracepoint-event.h>

```

--------------------------------

### Execute Program to Fire LTTng Trigger

Source: https://lttng.org/docs

Run a command, such as 'ls ~', to trigger the LTTng event rule. This action should start the associated recording session.

```bash
ls ~
```

--------------------------------

### Enable Timer-Based Rotation

Source: https://lttng.org/docs

Sets a recording session rotation schedule based on a timer. This example schedules a rotation every 10 seconds.

```bash
lttng enable-rotation --timer=10s
```

--------------------------------

### Load Extra Probe Kernel Modules with lttng-sessiond

Source: https://lttng.org/docs

Use the `--extra-kmod-probes` option to load default and custom probe kernel modules when starting the lttng-sessiond daemon. Provide a comma-separated list of subsystem names.

```bash
lttng-sessiond --extra-kmod-probes=my_subsys,usb
```

--------------------------------

### Run Hello World Application

Source: https://lttng.org/docs

Executes the instrumented 'Hello World' application with command-line arguments. This step is for demonstrating tracepoint emission.

```bash
./hello world and beyond

```

--------------------------------

### Build Hello World Application

Source: https://lttng.org/docs

Compiles the 'Hello World' C source file into an object file.

```bash
gcc -c hello.c

```

--------------------------------

### Build Application (Static Link with Shared Library)

Source: https://lttng.org/docs

Compile the application source file and link it with the tracepoint provider object file and the instrumented user library. The user library is dynamically loaded.

```bash
gcc -c app.c
```

```bash
gcc -o app app.o tpp.o -llttng-ust -ldl -L. -lemon
```

--------------------------------

### Build Application Statically Linked with Object File

Source: https://lttng.org/docs

Build the application by linking the application object file and the tracepoint provider object file.

```bash
gcc -o app app.o tpp.o -llttng-ust -ldl
```

--------------------------------

### Build Application (Dynamic Loading)

Source: https://lttng.org/docs

Compile the application source file and link it with the instrumented user library. The application dynamically loads the user library.

```bash
gcc -c app.c
```

```bash
gcc -o app app.o -ldl -L. -lemon
```

--------------------------------

### Build LTTng Modules from Source

Source: https://lttng.org/docs

Installs LTTng kernel modules from source. Ensure dependencies like libuuid, popt, Userspace RCU, and libxml2 are installed first. This process involves downloading, extracting, compiling, and installing the modules, followed by updating the module dependency map.

```bash
cd $(mktemp -d) &&
wget https://lttng.org/files/lttng-modules/lttng-modules-latest-2.15.tar.bz2 &&
tar -xf lttng-modules-latest-2.15.tar.bz2 &&
cd lttng-modules-2.15.* &&
make &&
sudo make modules_install &&
sudo depmod -a
```

--------------------------------

### Build Application Statically Linked with Archive File

Source: https://lttng.org/docs

Build the application by linking the application object file and the tracepoint provider archive file.

```bash
gcc -o app app.o tpp.a -llttng-ust -ldl
```

--------------------------------

### Build Application (Static Link with Dynamic Loading and Export Dynamic)

Source: https://lttng.org/docs

Compile the application source file and link it with the tracepoint provider object file. The `--export-dynamic` linker option is crucial for dynamically loaded libraries to see symbols defined in the application.

```c
#define LTTNG_UST_TRACEPOINT_DEFINE
```

```bash
gcc -c app.c
```

```bash
gcc -Wl,--export-dynamic -o app app.o tpp.o \
    -llttng-ust -ldl
```

--------------------------------

### Create Recording Session with Custom Output Directory

Source: https://lttng.org/docs

Create a recording session and specify a non-default directory for trace output using the --output option.

```bash
lttng create my-session --output=/tmp/some-directory
```

--------------------------------

### Start LTTng Relay Daemon

Source: https://lttng.org/docs

Start the LTTng relay daemon on the remote system to receive trace data over the network. This daemon will write received packets to its local file system.

```bash
lttng-relayd
```

--------------------------------

### Hello World Application with LTTng Tracepoints

Source: https://lttng.org/docs

A C 'Hello World' program instrumented with LTTng user-space tracepoints. Includes calls to `lttng_ust_tracepoint` with various arguments.

```c
#include <stdio.h>
#include "hello-tp.h"

int main(int argc, char *argv[])
{
    unsigned int i;

    puts("Hello, World!\nPress Enter to continue...");

    /*
     * The following getchar() call only exists for the purpose of this
     * demonstration, to pause the application in order for you to have
     * time to list its tracepoints. You don't need it otherwise.
     */
    getchar();

    /*
     * An lttng_ust_tracepoint() call.
     *
     * Arguments, as defined in `hello-tp.h`:
     *
     * 1. Tracepoint provider name (required)
     * 2. Tracepoint name (required)
     * 3. `my_integer_arg` (first user-defined argument)
     * 4. `my_string_arg` (second user-defined argument)
     *
     * Notice the tracepoint provider and tracepoint names are
     * C identifiers, NOT strings: they're in fact parts of variables
     * that the macros in `hello-tp.h` create.
     */
    lttng_ust_tracepoint(hello_world, my_first_tracepoint, 23,
                         "hi there!");

    for (i = 0; i < argc; i++) {
        lttng_ust_tracepoint(hello_world, my_first_tracepoint,
                             i, argv[i]);
    }

    puts("Quitting now!");
    lttng_ust_tracepoint(hello_world, my_first_tracepoint,
                         i * i, "i^2");
    return 0;
}

```

--------------------------------

### Create Recording Session with Legacy CTF 1.8 Format

Source: https://lttng.org/docs

Create a recording session that produces legacy CTF 1.8 traces instead of the default CTF 2 format.

```bash
lttng create --trace-format=ctf-1.8
```

--------------------------------

### Build Application Linked with Instrumented User Library (Shared Object)

Source: https://lttng.org/docs

Build the application by linking its object file with the instrumented user library. The -L. flag specifies the library search path, and -lemon links the libemon library.

```bash
gcc -o app app.o -L. -lemon
```

--------------------------------

### Start and Destroy Recording Session

Source: https://lttng.org/docs

Start the LTTng recording session to begin capturing events. Use lttng destroy to stop the session and clean up resources. This command implicitly runs lttng stop.

```bash
lttng start
```

```bash
lttng destroy
```

--------------------------------

### Create Tracepoint Provider Package Archive File

Source: https://lttng.org/docs

Create a static archive (.a) file from the tracepoint provider object file.

```bash
ar rcs tpp.a tpp.o
```

--------------------------------

### List Available Live Recording Sessions with Babeltrace2

Source: https://lttng.org/docs

Use babeltrace2 to list available live recording sessions by connecting to the local relay daemon.

```bash
babeltrace2 net://localhost
```

--------------------------------

### Build Instrumented User Library (Static Link)

Source: https://lttng.org/docs

Compile an instrumented user library source file, defining LTTNG_UST_TRACEPOINT_DEFINE. Link it into a shared object.

```c
#define LTTNG_UST_TRACEPOINT_DEFINE
```

```bash
gcc -I. -fpic -c emon.c
```

```bash
gcc -shared -o libemon.so emon.o
```

--------------------------------

### Connect Babeltrace2 to Live Session

Source: https://lttng.org/docs

Configure babeltrace2 to connect to a live LTTng recording session. Replace 'HOSTNAME' with the target system's hostname and 'my-session' with the session name.

```bash
babeltrace2 net://localhost/host/HOSTNAME/my-session
```

--------------------------------

### Adjust LDFLAGS for 32-bit Libraries

Source: https://lttng.org/docs

Specifies how to adjust LDFLAGS when 32-bit libraries are installed in non-standard locations, such as Debian's /usr/lib/i386-linux-gnu.

```bash
LDFLAGS='-L/usr/lib/i386-linux-gnu -L/usr/lib32'
```

--------------------------------

### Build Application with Statically Linked Tracepoint Provider Package

Source: https://lttng.org/docs

Build the application by linking the compiled object file with the statically linked tracepoint provider package object file. This assumes the tracepoint provider package object file (tpp.o) has already been created.

```bash
gcc -o app app.o -ldl
```

--------------------------------

### Get Current Recording Session Status

Source: https://lttng.org/docs

Retrieves the status of the current recording session, including its parameters, channels, and event rules.

```bash
lttng status
```

--------------------------------

### Create Linux Kernel Channel

Source: https://lttng.org/docs

Creates a Linux kernel channel with default attributes. Use this for basic kernel tracing setup.

```bash
lttng enable-channel --kernel my-channel
```

--------------------------------

### Get Specific Recording Session Status

Source: https://lttng.org/docs

Retrieves the status of a specific recording session by its name. Replace 'SESSION' with the actual session name.

```bash
lttng list SESSION
```

--------------------------------

### Build Application for Dynamic Linkage with Shared Object

Source: https://lttng.org/docs

Compile the application source file, defining LTTNG_UST_TRACEPOINT_DEFINE and LTTNG_UST_TRACEPOINT_PROBE_DYNAMIC_LINKAGE for dynamic loading of the shared object.

```bash
#define LTTNG_UST_TRACEPOINT_DEFINE
#define LTTNG_UST_TRACEPOINT_PROBE_DYNAMIC_LINKAGE
```

```bash
gcc -c app.c
```

```bash
gcc -o app app.o -ldl
```

--------------------------------

### Get Machine Interface Output

Source: https://lttng.org/docs

Retrieves LTTng command output in XML format using the '--mi=xml' option. This is useful for programmatic integration.

```bash
lttng --mi=xml list my-session
```

--------------------------------

### Manage Buffer Preallocation Policy in liblttng-ctl

Source: https://lttng.org/docs

The `liblttng-ctl` API allows setting and getting the buffer preallocation policy for a user space channel using `lttng_channel_set_preallocation_policy()` and `lttng_channel_get_preallocation_policy()`.

```c
lttng_channel_set_preallocation_policy(channel, policy);
lttng_channel_get_preallocation_policy(channel);
```

--------------------------------

### Build Application Linked with Shared Object

Source: https://lttng.org/docs

Build the application by linking the application object file and specifying the shared object library path.

```bash
gcc -c app.c
```

```bash
gcc -o app app.o -ldl -L. -ltpp
```

--------------------------------

### Preload libc and pthread Wrapper

Source: https://lttng.org/docs

Preload `liblttng-ust-libc-wrapper.so` and `liblttng-ust-pthread-wrapper.so` to automatically instrument C standard library and POSIX threads functions.

```bash
LD_PRELOAD=liblttng-ust-libc-wrapper.so my-app
```

--------------------------------

### Enable User Space Channel with On-Demand Buffer Preallocation

Source: https://lttng.org/docs

Configure a user space channel to preallocate buffer memory on demand using the `--buffer-preallocation=on-demand` option with `lttng enable-channel`.

```bash
lttng enable-channel my-channel --userspace --buffer-preallocation=on-demand
```

--------------------------------

### Get Recording Session Status with Stream Details

Source: https://lttng.org/docs

Retrieves the status of a recording session, including detailed information about each data stream's CPU ID and memory usage.

```bash
lttng list SESSION --stream-info-details
```

--------------------------------

### Enable User Space Probe Event (serv:accept_request)

Source: https://lttng.org/docs

Creates a recording event rule for a user space probe event on the `accept_request` function within the `server` USDT probe in `/usr/bin/serv`.

```bash
lttng enable-event --userspace-probe=/usr/bin/serv:server:accept_request
```

--------------------------------

### Define Multiple LTTng Tracepoint Events

Source: https://lttng.org/docs

This example shows the less efficient method of defining three separate tracepoint events with identical field definitions. This results in redundant serialization functions.

```c
LTTNG_UST_TRACEPOINT_EVENT(
    my_app,
    get_account,
    LTTNG_UST_TP_ARGS(
        int, userid,
        size_t, len
    ),
    LTTNG_UST_TP_FIELDS(
        lttng_ust_field_integer(int, userid, userid)
        lttng_ust_field_integer(size_t, len, len)
    )
)

LTTNG_UST_TRACEPOINT_EVENT(
    my_app,
    get_settings,
    LTTNG_UST_TP_ARGS(
        int, userid,
        size_t, len
    ),
    LTTNG_UST_TP_FIELDS(
        lttng_ust_field_integer(int, userid, userid)
        lttng_ust_field_integer(size_t, len, len)
    )
)

LTTNG_UST_TRACEPOINT_EVENT(
    my_app,
    get_transaction,
    LTTNG_UST_TP_ARGS(
        int, userid,
        size_t, len
    ),
    LTTNG_UST_TP_FIELDS(
        lttng_ust_field_integer(int, userid, userid)
        lttng_ust_field_integer(size_t, len, len)
    )
)

```

--------------------------------

### Create LTTng Session with CTF 1.8 Trace Format

Source: https://lttng.org/docs

Use the `--trace-format` option with `lttng create` to specify CTF 1.8 for a recording session. CTF 2 is the default for new sessions.

```bash
lttng create my-session --trace-format=ctf-1.8
```

--------------------------------

### Add a Syscall Event Trigger to LTTng

Source: https://lttng.org/docs

Use this command to add a trigger that starts the 'pitou' session when the 'exec*' syscall occurs and the filename matches '*/ls'. Ensure the session name is correctly specified.

```bash
lttng add-trigger --condition=event-rule-matches \
                  --type=syscall --name='exec*' \
                  --filter='filename == "*/ls"' \
                  --action=start-session pitou
```

--------------------------------

### List All Recording Sessions

Source: https://lttng.org/docs

List all existing recording sessions for the current user, or for all users if running as root.

```bash
lttng list
```

--------------------------------

### Load Only Specific Probe Kernel Modules with lttng-sessiond

Source: https://lttng.org/docs

Use the `--kmod-probes` option to load only the specified custom probe kernel modules when starting the lttng-sessiond daemon. Provide a comma-separated list of subsystem names.

```bash
lttng-sessiond --kmod-probes=my_subsys,usb
```

--------------------------------

### List Available Context Fields

Source: https://lttng.org/docs

Use the `--list` option to see all available context fields for LTTng.

```bash
lttng add-context --list
```

--------------------------------

### Reclaim User Space Channel Memory with liblttng-ctl

Source: https://lttng.org/docs

The `liblttng-ctl` API provides functions to immediately reclaim user space channel memory. Use `lttng_reclaim_channel_memory()`, wait for completion with `lttng_reclaim_handle_wait_for_completion()`, get results with `lttng_reclaim_handle_get_result()` and `lttng_reclaim_result_get_memory_size_bytes()`, and clean up with `lttng_reclaim_handle_destroy()`.

```c
handle = lttng_reclaim_channel_memory(channel);
lttng_reclaim_handle_wait_for_completion(handle);
memory_size = lttng_reclaim_result_get_memory_size_bytes(lttng_reclaim_handle_get_result(handle));
lttng_reclaim_handle_destroy(handle);
```

--------------------------------

### LTTng Session Daemon Kernel Module Loading Error

Source: https://lttng.org/docs

This example shows a common error when the lttng-sessiond fails to load a required kernel module due to signature enforcement policies, often encountered with Secure Boot or forced module signing.

```text
lttng-sessiond
Warning: No tracing group detected
modprobe: ERROR: could not insert 'lttng_ring_buffer_client_discard': Key was rejected by service
Error: Unable to load required module lttng-ring-buffer-client-discard
Warning: No kernel tracer available
```

--------------------------------

### Save Recording Session Configuration

Source: https://lttng.org/docs

Save the current recording session configuration to an XML file. This allows for re-use of complex session setups. The configuration includes session name, trace output path, channels, context fields, and event rules.

```bash
lttng save SESSION
```

--------------------------------

### Create LTTng Session and Enable JUL Events

Source: https://lttng.org/docs

Create a new LTTng recording session and enable events specifically for java.util.logging (JUL) named 'jello'.

```bash
lttng create
lttng enable-event --jul jello
```

--------------------------------

### Enable Userspace Event with Log Level

Source: https://lttng.org/docs

Enables the 'hello:world' event in userspace, specifically capturing events with the INFO log level. This is useful for filtering events based on their severity.

```bash
lttng enable-event --userspace hello:world --loglevel=INFO
```

--------------------------------

### Compile Application Source File

Source: https://lttng.org/docs

Compile the application source file. Ensure LTTNG_UST_TRACEPOINT_DEFINE is defined before including the tracepoint header.

```bash
gcc -c app.c
```

--------------------------------

### Create Notification App with High Buffer Usage Trigger

Source: https://lttng.org/docs

This C code demonstrates how to create a user application that gets notified when the buffer usage of a specific LTTng channel exceeds 75%. It sets up a notification channel, a condition for high buffer usage, and a trigger to receive these notifications. The application requires the recording session name and channel name as command-line arguments.

```c
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <lttng/lttng.h>

int main(int argc, char *argv[])
{
    int exit_status = EXIT_SUCCESS;
    struct lttng_notification_channel *notification_channel;
    struct lttng_condition *condition;
    struct lttng_action *action;
    struct lttng_trigger *trigger;
    const char *recording_session_name;
    const char *channel_name;

    assert(argc >= 3);
    recording_session_name = argv[1];
    channel_name = argv[2];

    /*
     * Create a notification channel.
     *
     * A notification channel connects the user application to the LTTng
     * session daemon.
     *
     * You can use this notification channel to listen to various types
     * of notifications.
     */
    notification_channel = lttng_notification_channel_create(
        lttng_session_daemon_notification_endpoint);

    /*
     * Create a "buffer usage becomes greater than" condition.
     *
     * In this case, the condition is satisfied when the buffer usage
     * becomes greater than or equal to 75 %.
     *
     * We create the condition for a specific recording session name,
     * channel name, and for the user space tracing domain.
     *
     * The following condition types also exist:
     *
     * * The buffer usage of a channel becomes less than a given value.
     *
     * * The consumed data size of a recording session becomes greater
     *   than a given value.
     *
     * * A recording session rotation becomes ongoing.
     *
     * * A recording session rotation becomes completed.
     *
     * * A given event rule matches an event.
     */
    condition = lttng_condition_buffer_usage_high_create();
    lttng_condition_buffer_usage_set_threshold_ratio(condition, .75);
    lttng_condition_buffer_usage_set_session_name(condition,
                                                  recording_session_name);
    lttng_condition_buffer_usage_set_channel_name(condition,
                                                  channel_name);
    lttng_condition_buffer_usage_set_domain_type(condition,
                                                 LTTNG_DOMAIN_UST);

    /*
     * Create an action (receive a notification) to execute when the
     * condition created above is satisfied.
     */
    action = lttng_action_notify_create();

    /*
     * Create a trigger.
     *
     * A trigger associates a condition to an action: LTTng executes
     * the action when the condition is satisfied.
     */
    trigger = lttng_trigger_create(condition, action);

    /* Register the trigger to the LTTng session daemon. */
    lttng_register_trigger(trigger);

    /*
     * Now that we have registered a trigger, LTTng will send a
     * notification every time its condition is met through a
     * notification channel.
     *
     * To receive this notification, we must subscribe to notifications
     * which match the same condition.
     */
    lttng_notification_channel_subscribe(notification_channel,
                                         condition);

    /*
     * Notification loop.
     *
     * Put this in a dedicated thread to avoid blocking the main thread.
     */
    for (;;)
    {
        struct lttng_notification *notification;
        enum lttng_notification_channel_status status;
        const struct lttng_evaluation *notification_evaluation;
        const struct lttng_condition *notification_condition;
        double buffer_usage;

        /* Receive the next notification. */
        status = lttng_notification_channel_get_next_notification(
            notification_channel, &notification);

        switch (status) {
        case LTTNG_NOTIFICATION_CHANNEL_STATUS_OK:
            break;
        case LTTNG_NOTIFICATION_CHANNEL_STATUS_NOTIFICATIONS_DROPPED:
            /*
             * The session daemon can drop notifications if a monitoring
             * application isn't consuming the notifications fast
             * enough.
             */
            continue;
        case LTTNG_NOTIFICATION_CHANNEL_STATUS_CLOSED:
            /*
             * The session daemon closed the notification channel.

```

--------------------------------

### Build Instrumented User Library (Static Linking)

Source: https://lttng.org/docs

Build the instrumented user library as a shared object. This links the compiled user library object file and the tracepoint provider package object file, along with necessary LTTng and dynamic linking libraries.

```bash
gcc -shared -o libemon.so emon.o tpp.o -llttng-ust -ldl
```

--------------------------------

### Build Instrumented User Library (Dynamic Linkage)

Source: https://lttng.org/docs

Compile an instrumented user library source file, defining LTTNG_UST_TRACEPOINT_DEFINE and LTTNG_UST_TRACEPOINT_PROBE_DYNAMIC_LINKAGE. Link it into a shared object.

```c
#define LTTNG_UST_TRACEPOINT_DEFINE
#define LTTNG_UST_TRACEPOINT_PROBE_DYNAMIC_LINKAGE
```

```bash
gcc -I. -fpic -c emon.c
```

```bash
gcc -shared -o libemon.so emon.o -ldl
```

--------------------------------

### Create Recording Session with Specific Name

Source: https://lttng.org/docs

Create a recording session with a user-defined name using the lttng-create command.

```bash
lttng create SESSION
```

--------------------------------

### Run Application with Preloaded Shared Object

Source: https://lttng.org/docs

Preload the tracepoint provider shared object to enable tracing support when running the application.

```bash
LD_PRELOAD=./libtpp.so ./app
```

--------------------------------

### Build Instrumented User Library (No Dynamic Linkage)

Source: https://lttng.org/docs

Compile an instrumented user library source file, defining only LTTNG_UST_TRACEPOINT_DEFINE. Link it into a shared object.

```c
#define LTTNG_UST_TRACEPOINT_DEFINE
```

```bash
gcc -I. -fpic -c emon.c
```

```bash
gcc -shared -o libemon.so emon.o -ldl
```

--------------------------------

### Build notif-app with pkg-config

Source: https://lttng.org/docs

This command demonstrates how to compile the `notif-app` application using GCC and pkg-config to automatically include the necessary compiler and linker flags for the LTTng control library.

```bash
gcc -o notif-app notif-app.c $(pkg-config --cflags --libs lttng-ctl)
```
Tokens:
Raw