How to monitor app health in Replit

Create a /health endpoint that returns the application's current status. This endpoint serves two purposes: Replit's deployment system uses it for health checks (the homepage must respond within 5 seconds), and external monitoring services poll it to detect downtime. Return a JSON response with the application status, current uptime, memory usage, and timestamps. Keep the endpoint lightweight with no database queries or heavy computation so it always responds quickly, even when other parts of the application are under load.

1// Express.js health endpoint
2const express = require('express');
3const app = express();
4const startTime = Date.now();
5
6app.get('/health', (req, res) => {
7  const mem = process.memoryUsage();
8  res.json({
9    status: 'healthy',
10    uptime: Math.floor((Date.now() - startTime) / 1000) + 's',
11    timestamp: new Date().toISOString(),
12    memory: {
13      heapUsed: Math.round(mem.heapUsed / 1024 / 1024) + 'MB',
14      heapTotal: Math.round(mem.heapTotal / 1024 / 1024) + 'MB',
15      rss: Math.round(mem.rss / 1024 / 1024) + 'MB'
16    },
17    environment: process.env.REPLIT_DEPLOYMENT ? 'production' : 'development'
18  });
19});
20
21app.listen(3000, '0.0.0.0', () => {
22  console.log('Server running on port 3000');
23});

Expand the health endpoint to verify that critical dependencies like the database are reachable. Run a simple query like SELECT 1 to confirm the database connection is alive without putting load on it. If the database check fails, return a degraded status instead of crashing the endpoint. This lets monitoring tools distinguish between a completely down application and one running with degraded functionality. Set a timeout on the database check so a slow database does not cause the health endpoint itself to time out.

1const { Pool } = require('pg');
2const pool = new Pool({ connectionString: process.env.DATABASE_URL });
3
4app.get('/health', async (req, res) => {
5  const mem = process.memoryUsage();
6  const checks = { database: 'unknown' };
7
8  try {
9    const dbStart = Date.now();
10    await Promise.race([
11      pool.query('SELECT 1'),
12      new Promise((_, reject) =>
13        setTimeout(() => reject(new Error('DB timeout')), 3000)
14      )
15    ]);
16    checks.database = 'connected';
17    checks.dbLatency = (Date.now() - dbStart) + 'ms';
18  } catch (err) {
19    checks.database = 'disconnected';
20    checks.dbError = err.message;
21  }
22
23  const status = checks.database === 'connected' ? 'healthy' : 'degraded';
24
25  res.status(status === 'healthy' ? 200 : 503).json({
26    status,
27    uptime: Math.floor((Date.now() - startTime) / 1000) + 's',
28    timestamp: new Date().toISOString(),
29    memory: {
30      heapUsed: Math.round(mem.heapUsed / 1024 / 1024) + 'MB',
31      rss: Math.round(mem.rss / 1024 / 1024) + 'MB'
32    },
33    checks
34  });
35});

Replit's built-in Resources panel shows real-time CPU, RAM, and storage usage for your workspace. Click the stacked computers icon in the left sidebar to open it. While the Resources panel is primarily for the development workspace and not for production deployments, it helps you understand your application's resource profile during development. Watch the graphs while running load tests or normal usage to establish baseline memory and CPU patterns. If CPU consistently maxes out or RAM climbs continuously, address these issues before deploying.

Deployed Replit apps write logs that you can access from the Deployments pane. Open the Deployments tab and click on your active deployment to see its logs. These logs include stdout and stderr output from your application, startup messages, and error stack traces. When your deployed app crashes or behaves unexpectedly, deployment logs are your first debugging tool. Common issues visible in logs include missing environment variables (secret not set in deployment pane), port binding errors (server not listening on 0.0.0.0), and unhandled exceptions that crash the process.

1// Add structured logging to make deployment logs more useful
2function log(level, message, data = {}) {
3  console.log(JSON.stringify({
4    level,
5    message,
6    timestamp: new Date().toISOString(),
7    ...data
8  }));
9}
10
11// Use throughout your application
12log('info', 'Server started', { port: 3000 });
13log('error', 'Database connection failed', { error: err.message });
14log('warn', 'High memory usage', { heapUsed: mem.heapUsed });

Replit does not send alerts when your deployed app goes down. Set up an external monitoring service that polls your /health endpoint at regular intervals and sends notifications when it fails. Free options include UptimeRobot (50 monitors free, 5-minute intervals) and Betterstack (free tier with 10 monitors). Configure the monitor to check your deployed app's URL followed by /health, set the expected status code to 200, and configure alert channels like email, Slack, or SMS. This gives you immediate notification when your app becomes unreachable or returns a degraded status.

Add middleware that logs every incoming request with method, path, status code, and response time. This data helps you understand traffic patterns, identify slow endpoints, and catch errors that users experience. Keep the logs lightweight to avoid consuming excessive storage or slowing down responses. In production, consider logging only errors and requests that take longer than a threshold to reduce noise.

1// Request logging middleware
2app.use((req, res, next) => {
3  const start = Date.now();
4
5  res.on('finish', () => {
6    const duration = Date.now() - start;
7    const entry = {
8      method: req.method,
9      path: req.path,
10      status: res.statusCode,
11      duration: duration + 'ms',
12      timestamp: new Date().toISOString()
13    };
14
15    // Log all errors, and slow requests over 1s
16    if (res.statusCode >= 400 || duration > 1000) {
17      console.log(JSON.stringify({ level: 'warn', ...entry }));
18    }
19  });
20
21  next();
22});