def test_ust_app_tracing_available(tmpdir, ust_label, tools_label, outcome):
nb_events = 100
# Prepare environment
ust = ProjectFactory.get_precook(ust_label)
tools = ProjectFactory.get_precook(tools_label)
babeltrace = ProjectFactory.get_precook(Settings.default_babeltrace)
tools_runtime_path = os.path.join(str(tmpdir), "tools")
ust_runtime_path = os.path.join(str(tmpdir), "ust")
app_path = os.path.join(str(tmpdir), "app")
with Run.get_runtime(ust_runtime_path) as runtime_app, Run.get_runtime(
tools_runtime_path) as runtime_tools:
runtime_tools.add_project(tools)
runtime_tools.add_project(babeltrace)
runtime_app.add_project(ust)
runtime_app.lttng_home = runtime_tools.lttng_home
trace_path = os.path.join(runtime_tools.lttng_home, "trace")
# Make application using the ust runtime
shutil.copytree(Settings.apps_gen_events_folder, app_path)
runtime_app.run("make V=1", cwd=app_path)
# Start lttng-sessiond
sessiond = utils.sessiond_spawn(runtime_tools)
# Create session using mi to get path and session name
runtime_tools.run("lttng create trace --output={}".format(trace_path))
runtime_tools.run("lttng enable-event -u tp:tptest")
runtime_tools.run("lttng start")
# Run application
cmd = "./app {}".format(nb_events)
runtime_app.run(cmd, cwd=app_path)
# Stop tracing
runtime_tools.run("lttng stop")
runtime_tools.run("lttng destroy -a")
cp = runtime_tools.subprocess_terminate(sessiond)
if cp.returncode != 0:
pytest.fail("Sessiond return code")
cmd = "babeltrace {}".format(trace_path)
if outcome == "Success":
cp_process, cp_out, cp_err = runtime_tools.run(cmd)
assert utils.line_count(cp_out) == nb_events
else:
with pytest.raises(subprocess.CalledProcessError):
cp_process, cp_out, cp_err = runtime_tools.run(cmd)
if outcome == "Unsupported version":
assert utils.file_contains(
runtime_tools.get_subprocess_stderr_path(sessiond),
[event_registration_error],
)
def test_babeltrace_lost_patcket(tmpdir, babeltrace_l, supported):
babeltrace = ProjectFactory.get_precook(babeltrace_l)
trace_path = Settings.trace_lost_packet
with Run.get_runtime(str(tmpdir)) as runtime:
runtime.add_project(babeltrace)
cmd = "babeltrace {}".format(trace_path)
cp, cp_out, cp_err = runtime.run(cmd)
if supported:
assert (utils.file_contains(cp_err, "Tracer lost 3 trace packets"))
assert (utils.file_contains(cp_err, "Tracer lost 2 trace packets"))
assert (utils.file_contains(cp_err, "Tracer lost 1 trace packets"))
else:
os.path.getsize(cp_err) > 0
assert (utils.line_count(cp_out) == 8)
def test_tools_liblttng_ctl_vs_sessiond_basic_listing(tmpdir, client_label,
tools_label, outcome):
# Prepare environment
client = ProjectFactory.get_precook(client_label)
tools = ProjectFactory.get_precook(tools_label)
tools_runtime_path = os.path.join(str(tmpdir), "tools")
lttng_client = os.path.join(client.installation_path, "bin/lttng")
with Run.get_runtime(tools_runtime_path) as runtime_tools:
runtime_tools.add_project(tools)
sessiond = utils.sessiond_spawn(runtime_tools)
cp, out, err = runtime_tools.run(
"{} create trace".format(lttng_client),
check_return=False,
ld_debug=True)
if outcome == "Missing symbol":
assert cp.returncode != 0
assert utils.file_contains(err, "Missing symbol")
return
if outcome == "Deprecated":
assert cp.returncode == 38
return
assert cp.returncode == 0
runtime_tools.run("{} enable-event -u tp:tptest".format(lttng_client))
runtime_tools.run("{} start".format(lttng_client))
# Stop tracing
runtime_tools.run("{} stop".format(lttng_client))
runtime_tools.run("{} destroy -a".format(lttng_client))
cp = runtime_tools.subprocess_terminate(sessiond)
if cp.returncode != 0:
pytest.fail("Sessiond return code")
def test_save_load_app_contexts(tmpdir, tools_save_l, tools_load_l,
should_load):
# Prepare environment
t_save = ProjectFactory.get_precook(tools_save_l)
t_load = ProjectFactory.get_precook(tools_load_l)
t_save_runtime_path = os.path.join(str(tmpdir), "tools-save")
t_load_runtime_path = os.path.join(str(tmpdir), "tools-load")
save_load_path = os.path.join(str(tmpdir), 'save_load')
validation_path = os.path.join(str(tmpdir), 'validation')
trace_name = "saved_trace"
trace_filename = trace_name + Settings.save_ext
trace_file_path = os.path.join(save_load_path, trace_filename)
validation_file_path = os.path.join(validation_path, trace_filename)
# Craft the save
with Run.get_runtime(t_save_runtime_path) as runtime:
runtime.add_project(t_save)
# Start lttng-sessiond
sessiond = utils.sessiond_spawn(runtime)
runtime.run("lttng create {}".format(trace_name))
runtime.run("lttng enable-event --jul hello")
runtime.run("lttng enable-event --log4j hello")
# NOTE: For now there is a bug/quirk for which app context is applied
# everywhere. Might need to be revisited. This influence the number of
# node we expect in the saved file.
runtime.run("lttng add-context --jul --type='$app.myRetriever:intCtx'")
runtime.run("lttng save --output-path={}".format(save_load_path))
cp = runtime.subprocess_terminate(sessiond)
if cp.returncode != 0:
pytest.fail("Sessiond on save return code")
validate_app_context(trace_name, trace_file_path)
# Load the save
with Run.get_runtime(t_load_runtime_path) as runtime:
runtime.add_project(t_load)
# Start lttng-sessiond
sessiond = utils.sessiond_spawn(runtime)
cmd = "lttng load --input-path={} {}".format(save_load_path,
trace_name)
if not should_load:
cp, out, err = runtime.run(cmd, check_return=False)
assert (cp.returncode != 0)
assert (utils.file_contains(
err, ['Session configuration file validation failed']))
return
runtime.run(cmd)
# Since lttng list does not include context we need to re-save and
# validate that the contexts are presend in the newly saved file.
runtime.run("lttng save --output-path={}".format(validation_path))
cp = runtime.subprocess_terminate(sessiond)
if cp.returncode != 0:
pytest.fail("Sessiond on load return code")
validate_app_context(trace_name, validation_file_path)
def test_ust_java_agent_interface(tmpdir, ust_label, tools_label, app_version,
outcome):
"""
Use the agent coming from ust_label, but run app under tools_version runtime using ust agent.
"""
nb_iter = 100
nb_events = 3 * nb_iter
# Prepare environment
ust = ProjectFactory.get_precook(ust_label)
tools = ProjectFactory.get_precook(tools_label)
babeltrace = ProjectFactory.get_precook(Settings.default_babeltrace)
tools_runtime_path = os.path.join(str(tmpdir), "tools")
ust_runtime_path = os.path.join(str(tmpdir), "ust")
app_path = os.path.join(str(tmpdir), "app")
with Run.get_runtime(ust_runtime_path) as runtime_app, Run.get_runtime(
tools_runtime_path) as runtime_tools:
runtime_tools.add_project(tools)
runtime_tools.add_project(babeltrace)
runtime_app.add_project(ust)
runtime_app.lttng_home = runtime_tools.lttng_home
trace_path = os.path.join(runtime_tools.lttng_home, "trace")
# Make application using the ust runtime
shutil.copytree(version_to_app[app_version], app_path)
runtime_app.run("javac App.java", cwd=app_path)
# Start lttng-sessiond
sessiond = utils.sessiond_spawn(runtime_tools)
# Create session using mi to get path and session name
runtime_tools.run("lttng create trace --output={}".format(trace_path))
runtime_tools.run("lttng enable-event -j jello")
runtime_tools.run("lttng start")
# Steal the classpath from ust project
ust_classpath = ust.special_env_variables["CLASSPATH"]
# Run application with tools runtime
cmd = "java App {}".format(nb_iter)
runtime_tools.run(cmd, cwd=app_path, classpath=ust_classpath)
# Stop tracing
runtime_tools.run("lttng stop")
runtime_tools.run("lttng destroy -a")
cp = runtime_tools.subprocess_terminate(sessiond)
if cp.returncode != 0:
pytest.fail("Sessiond return code")
# Read trace with babeltrace and check for event count via number of line
cmd = "babeltrace {}".format(trace_path)
if outcome == "Success":
assert utils.file_contains(
runtime_tools.get_subprocess_stderr_path(sessiond),
[
"New registration for pid",
"New registration for agent application: pid"
],
)
cp_process, cp_out, cp_err = runtime_tools.run(cmd)
assert utils.line_count(cp_out) == nb_events
else:
if outcome == "Unsupported protocol":
assert not (utils.file_contains(
runtime_tools.get_subprocess_stderr_path(sessiond),
[
"New registration for pid",
"New registration for agent application: pid"
],
))
cp_process, cp_out, cp_err = runtime_tools.run(cmd)
assert utils.line_count(cp_out) == 0
def test_ust_python_agent_interface(tmpdir, ust_label, tools_label, outcome):
"""
Use the agent coming from ust_label, but run app under tools_version runtime using ust agent.
"""
nb_iter = 100
nb_events = 5 * nb_iter
# Prepare environment
ust = ProjectFactory.get_precook(ust_label)
tools = ProjectFactory.get_precook(tools_label)
babeltrace = ProjectFactory.get_precook(Settings.default_babeltrace)
tools_runtime_path = os.path.join(str(tmpdir), "tools")
ust_runtime_path = os.path.join(str(tmpdir), "ust")
app_path = os.path.join(str(tmpdir), "app")
with Run.get_runtime(ust_runtime_path) as runtime_app, Run.get_runtime(
tools_runtime_path) as runtime_tools:
runtime_tools.add_project(tools)
runtime_tools.add_project(babeltrace)
runtime_app.add_project(ust)
runtime_app.lttng_home = runtime_tools.lttng_home
trace_path = os.path.join(runtime_tools.lttng_home, 'trace')
# Make application using the ust runtime
shutil.copytree(Settings.apps_python, app_path)
# Start lttng-sessiond
sessiond = utils.sessiond_spawn(runtime_tools)
# Create session using mi to get path and session name
runtime_tools.run('lttng create trace --output={}'.format(trace_path))
runtime_tools.run('lttng enable-event -p pello')
runtime_tools.run('lttng start')
# Steal the PYTHONPATH from ust project and force it on the tools
# project
python_path = ust.special_env_variables['PYTHONPATH']
tools.special_env_variables['PYTHONPATH'] = python_path
# Run application with tools runtime
cmd = 'python app.py -i {}'.format(nb_iter)
runtime_tools.run(cmd, cwd=app_path)
# Stop tracing
runtime_tools.run('lttng stop')
runtime_tools.run('lttng destroy -a')
cp = runtime_tools.subprocess_terminate(sessiond)
if cp.returncode != 0:
pytest.fail("Sessiond return code")
# Read trace with babeltrace and check for event count via number of line
cmd = 'babeltrace {}'.format(trace_path)
if outcome == "Success":
assert (utils.file_contains(
runtime_tools.get_subprocess_stderr_path(sessiond),
["New registration for pid"]))
cp_process, cp_out, cp_err = runtime_tools.run(cmd)
assert (utils.line_count(cp_out) == nb_events)
else:
if outcome == "Unsupported protocol":
assert (not (utils.file_contains(
runtime_tools.get_subprocess_stderr_path(sessiond),
["New registration for pid"])))
cp_process, cp_out, cp_err = runtime_tools.run(cmd)
assert (utils.line_count(cp_out) == 0)
def test_modules_regen_metadata(tmpdir, modules_label, tools_label, command, scenario):
modules = ProjectFactory.get_precook(modules_label)
if modules.skip:
pytest.skip("{} cannot be built on this kernel".format(modules.label))
tools = ProjectFactory.get_precook(tools_label)
babeltrace = ProjectFactory.get_precook(Settings.default_babeltrace)
nb_events = 10
with Run.get_runtime(str(tmpdir)) as runtime:
runtime.add_project(modules)
runtime.add_project(tools)
runtime.add_project(babeltrace)
trace_path = os.path.join(runtime.lttng_home, "trace")
babeltrace_cmd = "babeltrace {}".format(trace_path)
sessiond = sessiond_spawn(runtime)
runtime.load_test_module()
runtime.run("lttng create trace -o {}".format(trace_path))
runtime.run("lttng enable-event -k lttng_test_filter_event")
runtime.run("lttng start")
with open(Settings.lttng_test_procfile, "w") as procfile:
procfile.write("{}".format(nb_events))
runtime.run("lttng stop")
# Validate that we have all event base on the current metadata
cp_process, cp_out, cp_err = runtime.run(babeltrace_cmd)
assert line_count(cp_out) == nb_events
# Empty the metadata file
open(get_metadata_file_path(trace_path), "w").close()
# Babeltrace should never be able to parse the trace
with pytest.raises(subprocess.CalledProcessError):
runtime.run(babeltrace_cmd)
runtime.run("lttng start")
# TODO: rework this a bit to differentiate each errors and rework how
# the condition are meet
if scenario == "Unsupported by tools" or scenario == "Unsupported by modules":
if (
modules_label == "lttng-modules-2.7"
and scenario == "Unsupported by modules"
):
# Error from lttng-modules-2.7 is not reported correctly by
# sessiond. But it is reported on the sessiond side.
# For now, run the command, validate that the error exist on
# sessiond side and mark as xfail.
runtime.run("lttng {}".format(command))
else:
with pytest.raises(subprocess.CalledProcessError):
runtime.run("lttng {}".format(command))
# Make sure everything looks good on this side
runtime.run("lttng stop")
runtime.run("lttng destroy -a")
stderr_path = runtime.get_subprocess_stderr_path(sessiond)
sessiond = runtime.subprocess_terminate(sessiond)
if scenario == "Unsupported by modules":
error_msg = "Error: Failed to regenerate the kernel metadata"
assert file_contains(stderr_path, [error_msg]), "Error message missing"
if (
modules_label == "lttng-modules-2.7"
and scenario == "Unsupported by modules"
):
pytest.xfail(
"Lttng-tools does not bubble up error from unsupported metadata regeneration"
)
return
runtime.run("lttng {}".format(command))
runtime.run("lttng stop")
runtime.run("lttng destroy -a")
sessiond = runtime.subprocess_terminate(sessiond)
if sessiond.returncode != 0:
pytest.fail("Return value of sessiond is not zero")
cp_process, cp_out, cp_err = runtime.run(babeltrace_cmd)
assert line_count(cp_out) == nb_events
def test_ust_tracepoint_probe_abi_api_vs_ust_base(tmpdir, ust_label,
tools_label, scenario):
nb_loop = 100
if scenario != tracing_unavailable:
nb_expected_events = 200
else:
nb_expected_events = 0
# Prepare environment
ust = ProjectFactory.get_precook(ust_label)
tools = ProjectFactory.get_precook(tools_label)
babeltrace = ProjectFactory.get_precook(Settings.default_babeltrace)
tools_runtime_path = os.path.join(str(tmpdir), "tools")
ust_runtime_path = os.path.join(str(tmpdir), "ust")
app_path = os.path.join(str(tmpdir), "app")
with Run.get_runtime(ust_runtime_path) as runtime_ust, Run.get_runtime(
tools_runtime_path) as runtime_tools:
runtime_tools.add_project(tools)
runtime_tools.add_project(babeltrace)
runtime_ust.add_project(ust)
runtime_ust.lttng_home = runtime_tools.lttng_home
trace_path = os.path.join(runtime_tools.lttng_home, "trace")
# Make application using the ust runtime
shutil.copytree(Settings.apps_preload_provider_folder, app_path)
# Make the probe in the ust runtime
runtime_ust.run("make provider", cwd=app_path)
# Use the ust env to test tracepoint instrumentation
runtime_ust.run("make app", cwd=app_path)
# Start lttng-sessiond
sessiond = utils.sessiond_spawn(runtime_tools)
# Create session using mi to get path and session name
runtime_tools.run("lttng create trace --output={}".format(trace_path))
runtime_tools.run("lttng enable-event -u tp:tptest,tp:tpenum")
runtime_tools.run("lttng start")
# Run in the tools runtime application
cmd = "./app {}".format(nb_loop)
if scenario in fail_so_errors:
cp_process, cp_out, cp_err = runtime_tools.run(
cmd, cwd=app_path, ld_preload="./libtp.so", check_return=False)
assert cp_process.returncode == 127
assert utils.file_contains(cp_err, [fail_so_errors[scenario]])
# Nothing else to check.
return
else:
runtime_tools.run(cmd, cwd=app_path, ld_preload="./libtp.so")
# Stop tracing
runtime_tools.run("lttng stop")
runtime_tools.run("lttng destroy -a")
runtime_tools.subprocess_terminate(sessiond)
# Read trace with babeltrace and check for event count via number of line
cmd = "babeltrace {}".format(trace_path)
cp_process, cp_out, cp_err = runtime_tools.run(cmd)
assert utils.line_count(cp_out) == nb_expected_events
