trace-collection-assistant

Parse and normalize strace and ltrace execution traces into structured JSON.

142|14|Updated Feb 14, 2026
One-click install
npx skills add https://github.com/ArabelaTso/Skills-4-SE --skill trace-collection-assistant
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: trace-collection-assistant
Source: https://github.com/ArabelaTso/Skills-4-SE/tree/main/skills/trace-collection-assistant
Command: npx skills add https://github.com/ArabelaTso/Skills-4-SE --skill trace-collection-assistant

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

This Skill automates the collection, normalization, and structuring of execution traces from instrumented programs, transforming raw logs into actionable JSON data for efficient debugging and analysis.

Core Features & Use Cases

  • Trace Parsing: Converts strace and ltrace output into a standardized JSON format.
  • Filtering & Cleaning: Removes noise and filters traces based on specific criteria (errors, syscalls, arguments).
  • Debug Info Extraction: Isolates file, network, and process operations, as well as errors, for focused analysis.
  • Use Case: When debugging a program that crashes unexpectedly, use this Skill to parse its strace output, filter for error-related system calls, and extract file operation details to pinpoint the root cause.

Quick Start

Parse the strace output file 'trace.txt' into a pretty-printed JSON format.

Frequently Asked Questions about trace-collection-assistant

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I parse strace output into JSON for debugging?

To parse strace output into JSON for debugging, you use a trace parser to normalize raw execution logs into a standardized JSON format. This process extracts and structures system call details, enabling efficient filtering and focused analysis of program behavior.

What is the best way to filter system calls from execution traces?

The best way to filter system calls from execution traces is to normalize the raw logs into a structured JSON format first. Once the trace data is structured, you can easily apply specific criteria to isolate errors, file operations, or network activity for focused analysis.

Can I extract network activity and file operations from ltrace logs?

Yes, you can extract network activity and file operations from ltrace logs by parsing the library call traces into a structured data format. This allows you to isolate specific process behaviors and debug information from the raw execution output for verification.

Does trace parsing help with test case reproduction and program crashes?

Yes, trace parsing helps with test case reproduction and program crashes by structuring execution traces into actionable JSON data. This allows you to filter for error-related system calls and extract relevant details to pinpoint the root cause of unexpected crashes.

How do I clean noisy execution traces to identify specific errors?

To clean noisy execution traces and identify specific errors, parse the raw logs into a normalized JSON format and apply filtering criteria based on specific syscalls or arguments. This removes irrelevant noise and isolates the exact execution details needed for debugging.