15.2 Logs and History
Understanding what happened in your automations—and when—is crucial for debugging, compliance, and continuous improvement. This section shows you how to access execution history, track changes, and create audit trails in Taibles.
Overview: How Taibles Tracks History
A Different Approach
Traditional automation platforms:
- Logs are separate text files
- Time-sequenced entries
- Hard to connect logs with results
- Often disappear after 30-90 days
Taibles:
- The table IS the audit trail
- Every cell stores its own history
- Click any cell to see complete context
- History never expires
- Data + timestamps + state all in one place
What Taibles Tracks
Taibles provides built-in execution tracking at three levels:
Level 1: Cell-Level History
What it tracks:
- Current state (Completed, Error, etc.)
- Data value produced
- Last update timestamp
- Error details (if failed)
- Input data that was used
How to access: Click any cell
Level 2: Usage History
What it tracks:
- Token consumption by date
- API call counts
- Cost tracking
- Organization-level usage
How to access: Settings → Usage History
Level 3: Real-Time Monitoring
What it tracks:
- Which cells are running now
- Which cells are queued
- Failed cell counts
- Processing status
How to access: Column headers, taible overview
Part 1: Cell-Level History
Viewing Cell History
For any cell in your taible:
Click the cell you want to inspect
Sidebar opens showing complete cell information
{
"name": "Acme Corporation",
"domain": "acme.com",
"employees": 500,
"industry": "Technology",
"location": "San Francisco, CA"
}What you see:
- Column and Row: Shows which cell you're viewing
- Status Badge: Current state (Completed, Error, etc.)
- Timestamp: When this cell was last updated
- Data: The actual result produced by the cell
What You See: Successful Cells
When you click a cell that completed successfully, you'll see:
1. Current Data Value
The result produced by this cell - exactly what the column calculated or retrieved.
2. Execution Information
- State: Shows "Completed" with a green badge
- Last Updated: When this cell finished executing
- Column and Row: Which cell you're viewing
3. Available Actions
- Copy Value: Copy the cell data to clipboard
- Re-run Cell: Execute this cell again
- Clear Cell: Reset to ready state
- View Raw JSON: See full unformatted data
What You See: Failed Cells
For cells that failed, click the red error icon to open the error sidebar:
{
"error": {
"type": "unknown_record",
"message": "Company not found"
}
}{
"company_domain": "xyz-invalid.com",
"lead_email": "john@xyz-invalid.com"
}How to use error details:
- Description: Plain English explanation of what failed
- Technical Details: HTTP status and API endpoint information
- Input Data: Shows exactly what data was sent to the column
- Response Body: The error message returned by the API
Error Information Includes:
Error Summary
- Error type (API Error, Connection Error, etc.)
- HTTP status code if applicable
What Went Wrong
- Plain English explanation
- Human-readable description of the problem
Input Data
- Shows exactly what data was sent to the column
- Critical for debugging - lets you see what caused the error
Technical Details (if API-related)
- HTTP method (GET, POST, etc.)
- Full URL that was called
- Response headers
- Response body from the API
Stack Trace (for developers)
- Technical error trace
- Useful for identifying code issues
Using Cell History for Debugging
Example debugging workflow:
Scenario: 20 cells failed in "Company Enrichment" column
Step 1: Identify pattern
- Filter taible to show only errors
- Click first failed cell → view error
- Note error type: "404 Not Found"
Step 2: Check input data 4. Look at Input Data section 5. Notice: company_domain = "invalid-xyz-company.com" 6. Check source column that provides this domain
Step 3: Trace back 7. Click the source column cell (e.g., "Email Domain Extracted") 8. See what domain extraction logic produced 9. Find bug: extraction regex is including hyphens incorrectly
Step 4: Fix 10. Update domain extraction logic 11. Re-run failed cells 12. Verify success ✓
Total time: 5-10 minutes (vs. hours with traditional logging)
Part 2: Usage History (Token Consumption)
Accessing Usage History
Click your profile (top right)
Select "Settings"
Navigate to "Usage History" tab
Usage History
Get a detailed breakdown of your token usage.
| Date | Description | Tokens |
|---|---|---|
| Oct 31, 2024 2:15 PM | LLM: Lead scoring | 2,456 |
| Oct 31, 2024 1:30 PM | LLM: Email generation | 5,123 |
| Oct 31, 2024 11:45 AM | LLM: Company research | 8,901 |
| Oct 30, 2024 4:20 PM | LLM: Content generation | 3,567 |
| Oct 30, 2024 2:10 PM | LLM: Lead scoring | 1,892 |
| Oct 30, 2024 10:30 AM | LLM: Email generation | 4,234 |
Understanding usage history:
- Date: When the tokens were consumed
- Description: Which column or operation used the tokens
- Tokens: Number of tokens consumed (input + output)
- Access this from: Settings → Usage History
Understanding Usage History
The table shows:
- Date: When the usage occurred
- Description: What operation consumed tokens
- "LLM: [Column name]" for AI columns
- "Vector Store: Indexing" for knowledge base operations
- Other descriptions for token-consuming operations
- Tokens: Number of tokens used
- Includes input tokens (prompts) + output tokens (responses)
- For AI columns: Typically 100-10,000 per cell
Using Usage History
Monitor costs:
Daily total: 45,000 tokens
Average per row: ~500 tokens
Monthly projection: 1.35M tokens ≈ $20-40/monthIdentify expensive operations:
Email generation: 5,000 tokens/cell (high)
Lead scoring: 500 tokens/cell (reasonable)
→ Consider caching email templates to reduce costTrack usage trends:
Week 1: 200K tokens
Week 2: 350K tokens (↑75%)
Week 3: 320K tokens
→ Spike in Week 2: New lead enrichment campaignPart 3: Real-Time Monitoring
Column Status Indicators
Column headers show real-time processing status:
What the indicators mean:
Spinning gear icon: At least one cell in this column is running right now
- Click to navigate directly to the running cell
Clock icon with number: Cells queued and waiting to execute
- Number shows how many cells are queued
- Hover to see details
No indicator: Column is idle with no active processing
Monitoring Best Practices
When to actively monitor:
During testing: When you first set up a new column
- Watch cells execute in real-time
- Catch errors immediately
- Verify results are correct
After changes: When you modify column configuration
- Ensure changes work as expected
- Monitor for unexpected errors
- Check performance hasn't degraded
Active processing: When processing large batches
- Track progress through queue
- Identify bottlenecks
- Spot recurring errors
When to check periodically:
- Daily health check: Quick scan for error badges
- Weekly review: Check Usage History for cost trends
- Monthly audit: Export data for compliance if needed
Part 4: Creating Audit Trails
Since formal audit logging (user attribution, configuration history) is planned for future releases, here's how to create effective audit trails today:
Practice 1: Design for Traceability
Add explicit tracking columns to your taibles:
Example: Support Ticket Taible
Columns:
1. ticket_id (text) - Unique identifier
2. customer_email (text) - Who submitted
3. received_at (timestamp) - When received
4. issue_description (text) - What they need
5. assigned_to (user-select) - Who handles it ← Tracks ownership
6. status (dropdown: open/in-progress/closed)
7. resolution (text) - How it was resolved
8. resolved_at (timestamp) - When completed ← Tracks timing
9. resolution_time (custom code) - Calculate durationBenefits:
- ✓ Know who handled each ticket
- ✓ Know when each step occurred
- ✓ Measure response times
- ✓ Complete audit trail per ticket
- ✓ Accountability for team members
Practice 2: Preserve Raw Data
Pattern: Keep original input unchanged
Example: Form Submission Processing
Column 1: raw_webhook_data (webhook trigger)
→ Stores complete JSON payload as received
→ NEVER modify this column
Column 2: customer_name (custom code)
→ Extract from raw webhook data
Column 3: customer_email (custom code)
→ Extract from raw webhook data
Column 4: lead_score (AI)
→ Analyzes extracted dataWhy preserve raw data?:
- ✓ Re-parse if initial extraction was wrong
- ✓ Audit shows exactly what was received
- ✓ Debug with original input
- ✓ Compliance: Prove data wasn't altered
- ✓ Historical context if source format changes
Practice 3: Create Audit Log Taibles
Pattern: Separate taible for tracking changes
Setup: Main Data + Audit Log
Taible 1: Customer Records (main data)
Columns:
- customer_id
- name
- email
- status
- credit_limitTaible 2: Customer Audit Log (tracks changes)
Columns:
- audit_id (auto-increment)
- timestamp (current time)
- customer_id (which record changed)
- field_changed (which field: "credit_limit")
- old_value (previous value: "5000")
- new_value (new value: "10000")
- changed_by (user-select: who made change)
- change_reason (text: why changed)Practice 4: Export for Compliance
For regulated industries (healthcare, finance, legal):
Quarterly Compliance Export
What to export:
- Transaction taibles: All customer/financial/patient data
- Audit log taibles: All change history
- Usage history: Token consumption (proof of processing)
- Error logs: Failed cells (proof of monitoring)
Export process:
Step 1: Export taible
- Open taible
- Click ⋮ menu (top right)
- Select "Export"
- Choose format: CSV (for spreadsheets) or .agent (full backup)
- Download file
Step 2: Archive securely
Folder structure:
/compliance-archive
/2024-Q4
/taibles
customer-records-2024-10-31.csv
audit-log-2024-10-31.csv
order-processing-2024-10-31.csv
/usage-history
token-usage-oct-2024.csv
/documentation
taible-configurations-q4-2024.pdfStep 3: Document retention
- Retention period: 7 years (typical for financial)
- Storage location: Secure cloud storage (encrypted)
- Access control: Compliance officer only
- Backup: Secondary location
Practice 5: Use Filters to Review History
Filter taibles to track patterns:
Filter 1: Failed Executions (Last Week)
Filter:
- Show only: Error cells
- Updated: Last 7 days
Review:
- How many failures?
- Which columns failing most?
- Common error patterns?Action: Address recurring issues
Filter 2: Processed by Specific User
Filter:
- assigned_to (user-select column) = "john@company.com"
- Status: closed
Review:
- How many tickets John closed
- Average resolution time
- Quality of resolutionsUse: Performance review, workload balancing
Filter 3: Recent Changes (Last 24 Hours)
Filter:
- Updated: Last 24 hours
Review:
- What changed recently?
- Any unexpected updates?
- New data arriving as expected?Use: Daily monitoring, anomaly detection
Part 5: Debugging Workflows
Debugging Scenario 1: "Why did this cell fail last week?"
Problem: Customer reports their order wasn't processed on Oct 24
Investigation:
Step 1: Locate the row
Filter taible:
- customer_email = "customer@example.com"
- date = Oct 24Step 2: Click failed cell
State: Error
Last Updated: Oct 24, 2024 10:15 AMStep 3: View error details
Error: Payment processing failed
Reason: Credit card expired
Input: {card_last4: "1234", expiry: "09/24"}Step 4: Trace cause
→ Card expired end of September
→ Payment column correctly detected expiration
→ Order rightfully failed
→ Customer needs to update payment methodResolution: Contact customer, request card update ✓
Time: 2 minutes
Debugging Scenario 2: "Data looks wrong, what happened?"
Problem: Lead scores suddenly all showing "0" instead of 0-100 range
Investigation:
Step 1: Check recent lead scores
Sort by: Updated (newest first)
Check: Last 10 rows all show "0"Step 2: Click one "0" score cell
Data value: 0
State: Completed ✓
Last Updated: Oct 31, 2024 2:30 PMStep 3: Compare to older working scores
Click cell from Oct 30:
Data value: 75
State: Completed ✓
Last Updated: Oct 30, 2024 11:00 AMStep 4: Check configuration change
→ Compare Oct 30 vs Oct 31 column config
→ Notice: AI prompt was modified Oct 31 at 2:00 PM
→ New prompt doesn't explicitly ask for numeric score
→ AI now returns text descriptions, scored as "0"Resolution:
- Restore previous prompt
- Re-run affected cells ✓
Time: 5 minutes
Debugging Scenario 3: "Why is processing slower than usual?"
Problem: Lead enrichment usually takes 2 minutes per row, now taking 15 minutes
Investigation:
Step 1: Check Usage History
Settings → Usage History
Oct 31: 150,000 tokens (normal: 50,000)
→ 3x increase in token usageStep 2: Identify expensive column
Usage History shows:
"LLM: Company Research" - 8,900 tokens per cell
(Was previously 1,500 tokens)Step 3: Click cell in Company Research column
Data value: Long essay about company (5 pages)
→ Much more verbose than neededStep 4: Check AI prompt
New prompt says: "Write detailed analysis..."
Old prompt said: "Summarize in 100 words..."
→ Prompt change caused verbose outputResolution:
- Restore concise prompt
- Add max_tokens limit (500)
- Re-run recent rows ✓
Time: 10 minutes
Quick Reference: What's Logged Where
Cell-Level (Click any cell)
| Information | Available? | How to Access |
|---|---|---|
| Current state | ✅ Yes | Cell sidebar |
| Current data value | ✅ Yes | Cell sidebar |
| Last update timestamp | ✅ Yes | Cell sidebar |
| Error details | ✅ Yes (if failed) | Click error icon |
| Input data | ✅ Yes (if failed) | Error sidebar |
| HTTP request/response | ✅ Yes (if API error) | Error sidebar |
| Previous values | ❌ Future | - |
| Who modified | ❌ Future | - |
Organization-Level (Settings → Usage History)
| Information | Available? | How to Access |
|---|---|---|
| Token consumption | ✅ Yes | Usage History tab |
| Date/time of usage | ✅ Yes | Usage History tab |
| Operation description | ✅ Yes | Usage History tab |
| Cost tracking | ✅ Yes | Usage History tab |
| User attribution | ❌ Future | - |
| Detailed execution log | ❌ Future | - |
Configuration-Level (Column settings)
| Information | Available? | How to Access |
|---|---|---|
| Current configuration | ✅ Yes | Edit column modal |
| Export taible | ✅ Yes | Export menu |
| Configuration history | ❌ Future | - |
| Who changed config | ❌ Future | - |
| When config changed | ❌ Future | - |
Best Practices Summary
✅ Do This:
Add tracking columns to your taibles:
- Timestamp columns for "when"
- User-select columns for "who"
- Status/state columns for "what"
Preserve raw input data:
- Keep original webhook/email payloads
- Never overwrite source data
- Parse into separate columns
Create audit log taibles for critical data:
- Separate taible for change history
- Track old and new values
- Document who/when/why
Export regularly for compliance:
- Quarterly exports to secure storage
- Include transaction and audit data
- Follow retention requirements
Use filters to review history:
- Filter by state (Error) for errors
- Filter by date for recent changes
- Filter by user for workload tracking
Monitor actively during critical periods:
- When testing new columns
- After configuration changes
- During large batch processing
❌ Don't Do This:
Rely on manual memory→ Create tracking columnsOverwrite source data→ Keep raw data preservedSkip audit trails→ Critical for complianceDelete old data without exporting→ Export firstMake configuration changes without documentation→ Log changesAssume "someone knows"→ Make it explicit in data
Summary: Logs and History
You now understand how to access and use execution history in Taibles:
✅ Cell-level history:
- Click any cell to see state, data, timestamp
- Error sidebar shows complete debugging context
- Input data, HTTP details, all available for troubleshooting
✅ Usage history:
- Settings → Usage History for token consumption
- Track costs and identify expensive operations
- Monitor usage trends over time
✅ Real-time monitoring:
- Column headers show running/queued indicators
- Click indicators to navigate to active cells
- Watch progress in real-time
✅ Audit trail best practices:
- Add tracking columns (who, when, what)
- Preserve raw input data
- Create dedicated audit log taibles
- Export regularly for compliance
- Use filters to review patterns
✅ Current limitations (being addressed):
- No cell value history (yet)
- No configuration change log (yet)
- No user attribution (yet)
- Workaround: Manual tracking taibles
✅ Debugging with history:
- Trace failures back to root cause
- Compare working vs. failing cells
- Identify configuration changes
- Measure performance trends
Next Steps
You've completed Section 15.2: Logs and History!
Next: Section 15.3: Alerts and Notifications → Learn how to set up proactive alerts for errors, delays, and threshold breaches.
Let's set up notifications! 🔔