Monitoring Expert | Bootspring Docs

The Monitoring Expert agent specializes in application monitoring, error tracking, logging, alerting, and observability for production systems.

Expertise Areas#

Observability Pillars - Logs, metrics, and traces
Error Tracking - Sentry integration and error management
Logging Best Practices - Structured logging with Pino
Metrics Collection - PostHog and analytics
Alerting Configuration - Alert levels and channels
Health Checks - System health monitoring
Dashboard Design - Metrics visualization

Usage Examples#

Sentry Setup#

Use the monitoring-expert agent to set up Sentry error tracking for a Next.js application.

Response includes:

SDK initialization
Error boundary components
User context setup
Breadcrumb tracking

Logging System#

Use the monitoring-expert agent to implement structured logging with Pino.

Response includes:

Logger configuration
Context-aware logging
Request logging middleware
Log levels usage

Health Checks#

Use the monitoring-expert agent to implement comprehensive health check endpoints.

Response includes:

Health endpoint structure
Dependency checking
Status aggregation
Response formatting

Best Practices Applied#

1. Error Tracking#

Capture all exceptions
Add user context
Include breadcrumbs
Filter noise

2. Logging#

Structured JSON format
Appropriate log levels
Context propagation
Sensitive data filtering

3. Alerting#

Severity-based routing
Actionable alerts
Alert fatigue prevention
Clear runbooks

4. Observability#

Request tracing
Performance monitoring
Business metrics
SLO tracking

Common Patterns#

Sentry Configuration#

// lib/sentry.ts
import * as Sentry from '@sentry/nextjs';

Sentry.init({
  dsn: process.env.SENTRY_DSN,
  environment: process.env.NODE_ENV,
  tracesSampleRate: 1.0,
  release: process.env.VERCEL_GIT_COMMIT_SHA,

  beforeSend(event) {
    if (process.env.NODE_ENV === 'development') {
      return null;
    }
    return event;
  },

  ignoreErrors: [
    'ResizeObserver loop',
    'Non-Error promise rejection',
  ],
});

export function captureError(error: Error, context?: Record<string, any>) {
  Sentry.captureException(error, { extra: context });
}

export function setUser(user: { id: string; email: string }) {
  Sentry.setUser(user);
}

Structured Logging#

// lib/logger.ts
import pino from 'pino';

const logger = pino({
  level: process.env.LOG_LEVEL || 'info',
  transport: process.env.NODE_ENV === 'development'
    ? { target: 'pino-pretty' }
    : undefined,
  formatters: {
    level: (label) => ({ level: label }),
  },
  base: {
    env: process.env.NODE_ENV,
    version: process.env.npm_package_version,
  },
});

export function createLogger(context: string) {
  return logger.child({ context });
}

// Usage
const log = createLogger('api');
log.info({ userId }, 'User logged in');
log.error({ error, stack: error.stack }, 'Request failed');

Health Check Endpoint#

// app/api/health/route.ts
import { prisma } from '@/lib/db';
import { redis } from '@/lib/redis';

interface HealthStatus {
  status: 'healthy' | 'degraded' | 'unhealthy';
  checks: Record<string, { status: 'pass' | 'fail'; latency?: number }>;
  timestamp: string;
}

async function checkDatabase() {
  const start = Date.now();
  try {
    await prisma.$queryRaw`SELECT 1`;
    return { status: 'pass' as const, latency: Date.now() - start };
  } catch (error) {
    return { status: 'fail' as const, message: error.message };
  }
}

async function checkRedis() {
  const start = Date.now();
  try {
    await redis.ping();
    return { status: 'pass' as const, latency: Date.now() - start };
  } catch (error) {
    return { status: 'fail' as const, message: error.message };
  }
}

export async function GET() {
  const checks = {
    database: await checkDatabase(),
    redis: await checkRedis(),
  };

  const allPassing = Object.values(checks).every(c => c.status === 'pass');
  const allFailing = Object.values(checks).every(c => c.status === 'fail');

  const health: HealthStatus = {
    status: allPassing ? 'healthy' : allFailing ? 'unhealthy' : 'degraded',
    checks,
    timestamp: new Date().toISOString(),
  };

  return Response.json(health, {
    status: health.status === 'healthy' ? 200 : 503,
  });
}

Metrics Tracking#

// lib/metrics.ts
import { PostHog } from 'posthog-node';

const posthog = new PostHog(process.env.POSTHOG_API_KEY!, {
  host: process.env.POSTHOG_HOST,
});

export function trackEvent(
  userId: string,
  event: string,
  properties?: Record<string, any>
) {
  posthog.capture({
    distinctId: userId,
    event,
    properties,
  });
}

export const metrics = {
  userSignup: (userId: string) =>
    trackEvent(userId, 'user_signup'),
  subscriptionStarted: (userId: string, plan: string) =>
    trackEvent(userId, 'subscription_started', { plan }),
  featureUsed: (userId: string, feature: string) =>
    trackEvent(userId, 'feature_used', { feature }),
};

Sample Prompts#

Task	Prompt
Error tracking	"Set up Sentry for error tracking with user context"
Logging	"Implement structured logging with request tracing"
Health checks	"Create comprehensive health check endpoints"
Alerting	"Configure alerting for critical system events"
Dashboards	"Design monitoring dashboards for SaaS metrics"

Configuration#

// bootspring.config.js
module.exports = {
  agents: {
    customInstructions: {
      'monitoring-expert': `
        - Use Sentry for error tracking
        - Implement structured logging with Pino
        - Set up health check endpoints
        - Configure meaningful alerts
        - Track key business metrics
      `,
    },
  },
  monitoring: {
    errorTracking: 'sentry',
    analytics: 'posthog',
    logging: 'pino',
  },
};

DevOps Expert - Infrastructure monitoring
Performance Expert - Performance tracking
Backend Expert - API monitoring