Duyetbot Agent

Log Compaction Examples

Quick reference for using log compaction utilities

Log Compaction Examples

Quick reference for using the new log compaction utilities.

The Problem

Your current logs have repetitive "State updated" entries:

(log) {
  displayMessage: 'State updated',
  id: 'FAgyjrmzpRXx_LURS8hBl',
  payload: {},
  timestamp: 1765739728961,
  type: 'state:update'
}
(log) {
  displayMessage: 'State updated',
  id: 'G060kn9Dj8GGPSQINg9oe',
  payload: {},
  timestamp: 1765739728962,
  type: 'state:update'
}

Result: Logs are 80% noise, 20% signal.

Solution: Log Compaction

Basic Usage

import { compactLog, compactStateUpdate } from '@duyetbot/observability';
 
// Compact state update
const log = {
  displayMessage: 'State updated',
  payload: { messages: [...] },
  timestamp: 1765739728961,
  type: 'state:update'
};
 
compactStateUpdate(log);
// Output: "[state] msgs:42 | t:728961"
 
// Or use general compactor
compactLog(log);
// Output: { type: 'state:update', displayMessage: 'State updated', ... (fields) }

With Options

compactLog(log, {
  abbreviate: true,    // Use short field names: msgs instead of messages
  hideRefs: true,      // Hide ID, trace, request IDs
  maxLines: 3          // Truncate multi-line content
});
 
// Output: { type: 'state:update', msg: 'State updated', ... }

Real-World Examples

Example 1: State Updates in Bulk

Before:

(log) { displayMessage: 'State updated', id: 'FAgyjrmzpRXx_LURS8hBl', ... }
(log) { displayMessage: 'State updated', id: 'G060kn9Dj8GGPSQINg9oe', ... }
(log) { displayMessage: 'State updated', id: 'H080lpo1Zdq2xMW4T1i1F', ... }
(log) { displayMessage: 'State updated', id: 'J1A4mss3awZ0xPNXy5j4K', ... }

After (with compactStateUpdate):

(log) [state] msgs:5 | t:728961
(log) [state] msgs:6 | t:728962
(log) [state] msgs:7 | t:728963
(log) [state] msgs:8 | t:728964

Reduction: 4 lines → 4 lines, but 89% size reduction (340 bytes → 37 bytes per log).

Example 2: Compacting Debug Context

Before:

logger.debug('Agent state:', {
  messages: [
    { role: 'user', content: 'hello', id: 'msg_1234', timestamp: 1765739728961 },
    { role: 'assistant', content: 'Hi!', id: 'msg_5678', timestamp: 1765739729000 },
    // ... 38 more messages ...
    { role: 'user', content: 'last msg', id: 'msg_9999', timestamp: 1765739800000 }
  ],
  state: { locked: false, processing: true },
  metadata: { userId: '123', chatId: '456', ... }
});

After (with compactDebugContext):

import { compactDebugContext } from '@duyetbot/observability';
 
logger.debug('Agent state:', compactDebugContext(state, {
  hideRefs: true,
  abbreviate: true
}));
 
// Output:
// Agent state: {
//   msgs: [{ role: 'user' }, { role: 'assistant' }],
//   messageCount: 40,
//   state: { locked: false, processing: true },
//   metadata: { userId: '123', chatId: '456', ... }
// }

Result: Full context preserved, but focused on structure not content.

Example 3: Filtering + Compacting

Suppress state updates entirely:

import { createCompactMiddleware } from '@duyetbot/observability';
 
const compactify = createCompactMiddleware({
  abbreviate: true,
  hideRefs: true
});
 
// Add to logger middleware chain
const shouldLog = (log) => {
  // Skip state:update logs entirely
  if (log.type === 'state:update') return false;
  return true;
};
 
logger.use((log) => {
  if (!shouldLog(log)) return;  // Filter
  return compactify(log);        // Compact
});

Example 4: Using in Platform Response

Telegram response with compact footer:

import { compactLog } from '@duyetbot/observability';
 
async function sendResponse(text: string, context: TelegramContext) {
  // Compact footer details before sending
  if (context.debugContext) {
    const footer = formatDebugFooter(context);  // Already formatted
    logger.debug('[TRANSPORT] Sending', {
      messageId: context.messageId,
      textLength: text.length,
      debugContext: compactLog(context.debugContext, {
        hideRefs: true,
        maxLines: 3
      })
    });
  }
 
  return transport.send(context, text);
}

Integration Points

1. In Hono Middleware

import { createCompactMiddleware } from '@duyetbot/observability';
 
const app = new Hono();
 
// Add logging middleware with compaction
app.use(logger.middleware((log) => {
  return createCompactMiddleware({ abbreviate: true })(log);
}));

2. In Cloudflare Agent

// In cloudflare-agent.ts
import { compactStateUpdate } from '@duyetbot/observability';
 
// When logging state updates
logger.debug('[STATE]', compactStateUpdate(stateUpdateLog));

3. Custom Logger Wrapper

import type { Logger } from '@duyetbot/hono-middleware';
import { compactLog } from '@duyetbot/observability';
 
export function createCompactLogger(baseLogger: Logger) {
  return {
    debug: (msg: string, data?: any) => {
      baseLogger.debug(msg, data ? compactLog(data) : undefined);
    },
    info: (msg: string, data?: any) => {
      baseLogger.info(msg, data ? compactLog(data) : undefined);
    },
    error: (msg: string, data?: any) => {
      baseLogger.error(msg, data ? compactLog(data) : undefined);
    }
  };
}

Output Formats

Abbreviation Mapping

OriginalAbbreviated
displayMessagemsg
timestampt
messagesmsgs
requestIdreq
traceIdtrace
totalDurationMsduration

Truncation Rules

ContentRule
Strings > 100 chars"...string is long..."
Arrays > 10 items<42 items>
Objects > 5 fields<object with 12 keys>
IDs (UUID/trace)First 8 chars + ...

Performance Impact

Before Compaction

  • Log entry size: 340-500 bytes (each state update)
  • 100 state updates: 34-50 KB
  • Logger parse time: ~0.5ms per entry (JSON stringify)

After Compaction

  • Log entry size: 37-60 bytes (each state update)
  • 100 state updates: 3.7-6 KB
  • Logger parse time: ~0.05ms per entry (direct string)

Result: 10x smaller logs, 10x faster logging ⚡

Migration Guide

Step 1: Import Compactor

import { compactLog, createCompactMiddleware } from '@duyetbot/observability';

Step 2: Choose Integration Point

Option A: Wrap logger calls

logger.debug('[TAG]', compactLog(largeObject));

Option B: Use middleware

const compactMiddleware = createCompactMiddleware();
logger.use(compactMiddleware);

Option C: Filter + compact

logger.use((log) => {
  if (log.type === 'state:update') return;  // Skip
  return compactLog(log);                    // Compact
});

Step 3: Test & Monitor

# Deploy compacted logs
bun run deploy
 
# Monitor in Cloudflare dashboard
# Should see:
# - Reduced log volume (~90% less for state updates)
# - Same information preserved
# - Faster log processing

Tips & Tricks

1. Keep Full Details for Errors

logger.error('[ERROR]', data);  // Never compact errors
logger.debug('[DEBUG]', compactLog(data));  // Compact debug only

2. Selective Abbreviation

// Only abbreviate for development
const opts = process.env.ENV === 'production'
  ? {}
  : { abbreviate: true };
 
compactLog(data, opts);

3. Custom Compaction Rules

function customCompact(log) {
  // Your custom rules
  if (log.type === 'state:update') {
    return `[state] ${log.payload.messages?.length || 0} msgs`;
  }
  return compactLog(log);  // Default compaction
}

See Also

Previous

Integration Guide

Next

Ralph Loop Tasks

On this page