Cuihua Logger

📝 AI-powered logging assistant that generates production-ready structured logs. Automatically add intelligent logging to your code with proper levels, conte...

Security Scan

The package is mostly coherent for a logging-analysis tool, but it claims to automatically add logging to code while the included CLI only scans files and generates snippet strings (does not modify files), which is an important mismatch the user should know about.

Purpose & Capability

Name/description promise: 'automatically add intelligent logging' and examples showing generated 'after' code and 'Add logging to function' workflows. Actual bundled code (logger.js) implements scanning, detection of functions lacking logging, generating logging snippet text, and producing a coverage report, but it does not write changes back to source files or integrate with repositories/CI. No environment variables, binaries, or external services are requested — those ARE consistent with a local analysis tool, but the 'auto-add' and 'multiple logger support' claims are overstated relative to what the code actually performs.

Instruction Scope

SKILL.md instructs analysis and shows examples for adding logging and running commands like 'node logger.js check ./src'. The runtime instructions and the shipped CLI align with scanning/analysis of a target path. However SKILL.md implies the agent will 'add' or patch logging into functions; the provided code only returns generated snippet text and a report and does not implement in-place modifications, patching, or writing files. The tool reads arbitrary files under the target path (as expected) — exercise caution about which path you point it at (don't run against system directories or secrets).

Install Mechanism

Instruction-only install (no install spec) and a single Node CLI file. Requires 'node' binary which matches the code. No network downloads or extract steps are present. Low install risk.

Credentials

No environment variables, credentials, or config paths are declared or required. The code operates on filesystem paths only and does not access or require secrets — proportional to the stated purpose of static analysis/coverage reporting.

Persistence & Privilege

Skill does not request persistent/always-on presence. It is user-invocable and the CLI runs on demand. The code does not modify other skills or global agent configuration.

What to consider before installing

This package appears to be a local static analyzer that reports where logging is missing and produces example logging snippets, but it does NOT automatically patch your source files. If you expect automated in-place changes, this will not do that as-is. Before running: (1) review logger.js (it reads every file under the target path) and run it only on a project copy or in a sandboxed repo to avoid scanning unintended files; (2) if you need automated edits, either implement a safe write/patch step yourself or verify the tool that will apply the snippets; (3) confirm node is installed and run the CLI with an explicit path (e.g., ./src) rather than root/~/; (4) because the tool reads your codebase, don’t run it on directories containing secrets or system configs. If you want the tool to actually insert logging automatically, ask the author for an implementation that writes changes and includes safeguards (backups, dry-run, and clear patching behavior).

cuihua-logger - Production-Ready Logging 📝

Debug faster with intelligent, structured logging.

An AI-powered logging assistant that automatically:

• 📝 Generates structured logs with proper context
• 🎯 Selects appropriate log levels (debug, info, warn, error)
• 📊 Adds performance metrics and timing
• 🔍 Detects missing logs in critical paths
• ⚡ Optimizes log output for production

🎯 Why cuihua-logger?

The problem:

• ❌ Too many console.log() everywhere
• ❌ No structure, hard to search
• ❌ Wrong log levels (everything is "info")
• ❌ Missing context (what user? what request?)
• ❌ Performance overhead in production

cuihua-logger solves all of this.

---

🚀 Quick Start

Analyze logging coverage

"Check logging coverage in src/"

Add structured logging

"Add logging to getUserById function"

Generate performance logs

"Add performance logging to API endpoints"

---

🎨 Features

1. Structured Logging ✨

// ❌ BEFORE - Unstructured
async function getUserById(id) {
  console.log('Getting user:', id);
  const user = await db.query('SELECT * FROM users WHERE id = $1', [id]);
  console.log('User found:', user);
  return user;
}

// ✅ AFTER - Structured
async function getUserById(id) {
  logger.info('Fetching user', { 
    userId: id,
    operation: 'getUserById'
  });
  
  const startTime = Date.now();
  const user = await db.query('SELECT * FROM users WHERE id = $1', [id]);
  const duration = Date.now() - startTime;
  
  logger.info('User fetched successfully', {
    userId: id,
    operation: 'getUserById',
    duration,
    found: !!user
  });
  
  return user;
}

2. Smart Log Levels 🎯

// Automatic level selection based on context

logger.debug('Cache hit', { key, ttl }); // Development only

logger.info('User logged in', { userId, ip }); // Important events

logger.warn('Rate limit approaching', { 
  userId, 
  current: 95, 
  limit: 100 
}); // Potential issues

logger.error('Payment failed', { 
  orderId, 
  error: error.message,
  stack: error.stack 
}); // Critical errors

3. Performance Logging ⚡

async function fetchData() {
  const timer = logger.startTimer();
  
  const data = await expensiveOperation();
  
  timer.done({ level: 'info', message: 'Operation complete' });
  
  return data;
}

// Output: "Operation complete" duration=1234ms

4. Request Tracking 🔍

app.use((req, res, next) => {
  req.requestId = generateId();
  req.logger = logger.child({ 
    requestId: req.requestId,
    method: req.method,
    path: req.path 
  });
  
  req.logger.info('Request started');
  
  res.on('finish', () => {
    req.logger.info('Request completed', {
      statusCode: res.statusCode,
      duration: Date.now() - req.startTime
    });
  });
  
  next();
});

---

📋 Usage Examples

Example 1: Add Logging to Function

User: "Add logging to processOrder function"

Generated:

async function processOrder(orderId, items) {
  logger.info('Processing order', { orderId, itemCount: items.length });
  
  try {
    // Validate
    if (!orderId || !items.length) {
      logger.warn('Invalid order data', { orderId, items });
      throw new ValidationError('Invalid order');
    }
    
    // Create order
    const order = await createOrder(orderId, items);
    logger.info('Order created', { orderId, orderNumber: order.number });
    
    // Process payment
    const payment = await processPayment(order);
    logger.info('Payment processed', { 
      orderId, 
      paymentId: payment.id,
      amount: payment.amount 
    });
    
    return order;
    
  } catch (error) {
    logger.error('Order processing failed', {
      orderId,
      error: error.message,
      stack: error.stack
    });
    throw error;
  }
}

Example 2: API Endpoint Logging

app.post('/api/users', async (req, res) => {
  const { logger } = req;
  
  logger.info('Creating user', { email: req.body.email });
  
  try {
    const user = await userService.create(req.body);
    
    logger.info('User created successfully', {
      userId: user.id,
      email: user.email
    });
    
    res.status(201).json(user);
    
  } catch (error) {
    logger.error('User creation failed', {
      email: req.body.email,
      error: error.message
    });
    
    res.status(500).json({ error: 'Failed to create user' });
  }
});

---

⚙️ Logger Configuration

Winston

import winston from 'winston';

const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.errors({ stack: true }),
    winston.format.json()
  ),
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' })
  ]
});

Pino (fastest)

import pino from 'pino';

const logger = pino({
  level: process.env.LOG_LEVEL || 'info',
  timestamp: pino.stdTimeFunctions.isoTime,
  formatters: {
    level: (label) => ({ level: label })
  }
});

---

📊 Log Levels

Level	When to Use	Example
debug	Development debugging	logger.debug('Cache miss', { key })
info	Important events	logger.info('User logged in', { userId })
warn	Potential issues	logger.warn('Rate limit approaching', { userId })
error	Errors that need attention	logger.error('Payment failed', { orderId })

---

💰 Pricing

Free

• ✅ Basic log generation
• ✅ Up to 10 files

Pro ($8/month)

• ✅ Unlimited files
• ✅ Performance logging
• ✅ Request tracking
• ✅ CI/CD integration

Enterprise ($59/month)

• ✅ Team policies
• ✅ Log aggregation setup
• ✅ Custom formatters

---

📚 Best Practices

1. Always log errors with context
2. Use structured logging (objects, not strings)
3. Include request IDs for tracing
4. Don't log sensitive data (passwords, tokens)
5. Use appropriate log levels

---

📜 License

MIT

---

🙏 Acknowledgments

Built with 🌸 by 翠花 (Cuihua)

---

Made with 🌸 | Cuihua Series | ClawHub Pioneer