logfire Skill

Pydantic Logfire observability and tracing. Query application logs, find exceptions, analyze spans with SQL, and generate trace links.

Context Efficiency

Traditional MCP approach:

• All 4 tools loaded at startup
• Estimated context: 2000 tokens

This skill approach:

• Metadata only: ~100 tokens
• Full instructions (when used): ~5k tokens
• Tool execution: 0 tokens (runs externally)

How This Works

Instead of loading all MCP tool definitions upfront, this skill:

1. Tells you what tools are available (just names and brief descriptions)
2. You decide which tool to call based on the user's request
3. Generate a JSON command to invoke the tool
4. The executor handles the actual MCP communication

Available Tools

• find_exceptions_in_file: Get the details about the 10 most recent exceptions on the file.
• arbitrary_query: Run an arbitrary query on the Pydantic Logfire database.

The SQL reference is available via the sql_reference tool.

• logfire_link: Creates a link to help the user to view the trace in the Logfire UI.
• schema_reference: The database schema for the Logfire DataFusion database.

This includes all tables, columns, and their types as well as descriptions. For example:

-- The records table contains spans and logs.
CREATE TABLE records (
    message TEXT, -- The message of the record
    span_name TEXT, -- The name of the span, message is usually templated from this
    trace_id TEXT, -- The trace ID, identifies a group of spans in a trace
    exception_type TEXT, -- The type of the exception
    exception_message TEXT, -- The message of the exception
    -- other columns...
);

The SQL syntax is similar to Postgres, although the query engine is actually Apache DataFusion.

To access nested JSON fields e.g. in the attributes column use the -> and ->> operators. You may need to cast the result of these operators e.g. (attributes->'cost')::float + 10.

You should apply as much filtering as reasonable to reduce the amount of data queried. Filters on start_timestamp, service_name, span_name, metric_name, trace_id are efficient.

Usage Pattern

When the user's request matches this skill's capabilities:

Step 1: Identify the right tool from the list above

Step 2: Generate a tool call in this JSON format:

{
  "tool": "tool_name",
  "arguments": {
    "param1": "value1",
    "param2": "value2"
  }
}

Step 3: Execute via bash:

python .claude/skills/mcp-skills/executor.py --skill logfire --call 'YOUR_JSON_HERE'

Getting Tool Details

If you need detailed information about a specific tool's parameters:

python .claude/skills/mcp-skills/executor.py --skill logfire --describe tool_name

This loads ONLY that tool's schema, not all tools.

Examples

Example 1: Simple tool call

User: "Find recent exceptions in main.py"

Your workflow:

1. Identify tool: find_exceptions_in_file
2. Generate call JSON
3. Execute:

python .claude/skills/mcp-skills/executor.py --skill logfire --call '{"tool": "find_exceptions_in_file", "arguments": {"filepath": "main.py"}}'

Example 2: Get tool details first

python .claude/skills/mcp-skills/executor.py --skill logfire --describe arbitrary_query

Returns the full schema, then you can generate the appropriate call.

Error Handling

If the executor returns an error:

• Check the tool name is correct
• Verify required arguments are provided
• Ensure the MCP server is accessible

Performance Notes

Context usage comparison for this skill:

Savings: ~-150% reduction in typical usage

This skill was auto-generated from an MCP server configuration. Generator: mcp_to_skill.py