Execute Daily 4 AM Maintenance Tasks | CronBase

const cron = require('node-cron');
const { exec } = require('child_process');

console.log('Daily maintenance scheduler initialized.');

// Schedule task to run daily at 4:00 AM
cron.schedule('0 4 * * *', () => {
    console.log(`[${new Date().toISOString()}] Initiating daily database cleanup...`);
    
    exec('npm run db:cleanup', (error, stdout, stderr) => {
        if (error) {
            console.error(`Error during cleanup: ${error.message}`);
            return;
        }
        if (stderr) {
            console.warn(`Warnings during cleanup: ${stderr}`);
        }
        console.log(`Cleanup completed: ${stdout}`);
    });
}, {
    scheduled: true,
    timezone: "Etc/UTC"
});

#!/usr/bin/env bash

# Ensure the script exits immediately if any command fails
set -euo pipefail

LOG_FILE="/var/log/daily_backup.log"

# Function to log messages with timestamps
log_message() {
    echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] $1" >> "$LOG_FILE"
}

log_message "Starting daily maintenance task..."

# Implement jitter to avoid thundering herd issues
SLEEP_TIME=$((RANDOM % 300))
log_message "Sleeping for ${SLEEP_TIME} seconds to distribute load..."
sleep "$SLEEP_TIME"

# Execute the backup process
if pg_dump -U db_user -h localhost production_db > /backups/prod_$(date +%F).sql; then
    log_message "Backup completed successfully."
else
    log_message "ERROR: Backup process failed!"
    exit 1
fi

import sys
import logging
from apt_pkg import init
from apscheduler.schedulers.blocking import BlockingScheduler
from datetime import datetime

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

def daily_maintenance_job():
    logger.info("Starting daily system cleanup and index optimization...")
    try:
        # Simulate work
        logger.info("Optimization successfully completed.")
    except Exception as e:
        logger.error(f"Maintenance job failed: {str(e)}")
        # In production, integrate alert mechanisms here

if __name__ == '__main__':
    scheduler = BlockingScheduler()
    # Schedule the job for daily at 4:00 AM UTC
    scheduler.add_job(daily_maintenance_job, 'cron', hour=4, minute=0, timezone='UTC')
    logger.info("Scheduler started. Task configured for 04:00 UTC daily.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped.")
        sys.exit(0)

package main

import (
	"log"
	"os"
	"os/signal"
	"syscall"
	"time"

	"github.com/robfig/cron/v3"
)

func main() {
	logger := log.New(os.Stdout, "CRON: ", log.LstdFlags|log.Lshortfile)
	logger.Println("Initializing daily cron scheduler...")

	// Use UTC timezone for predictable schedule execution
	c := cron.New(cron.WithLocation(time.UTC))

	_, err := c.AddFunc("0 4 * * *", func() {
		logger.Println("Executing daily analytical aggregation...")
		// Perform the actual work here
		logger.Println("Analytical aggregation finished successfully.")
	})

	if err != nil {
		logger.Fatalf("Error scheduling job: %v", err)
	}

	c.Start()
	logger.Println("Scheduler started. Running daily at 04:00 UTC.")

	// Keep the process alive until interrupted
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
	<-sigChan
	logger.Println("Shutting down scheduler gracefully...")
	c.Stop()
}

package com.example.cron;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.time.Instant;

@Component
public class DailyMaintenanceScheduler {

    private static final Logger logger = LoggerFactory.getLogger(DailyMaintenanceScheduler.class);

    // Spring Cron uses 6 fields: second, minute, hour, day, month, day-of-week
    @Scheduled(cron = "0 0 4 * * *", zone = "UTC")
    public void runDailyMaintenance() {
        logger.info("Daily maintenance task started at: {}", Instant.now());
        try {
            // Business logic for daily data pruning
            pruneOldRecords();
            logger.info("Daily maintenance task completed successfully.");
        } catch (Exception ex) {
            logger.error("Error during daily maintenance: ", ex);
        }
    }

    private void pruneOldRecords() {
        // Simulated database call
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-cleanup-job
  namespace: production
spec:
  schedule: "0 4 * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: database-cleaner
            image: postgres:15-alpine
            command:
            - /bin/sh
            - -c
            - "psql -h db-service -U postgres -d app_prod -c 'VACUUM ANALYZE;'"
            env:
            - name: PGPASSWORD
              valueFrom:
                secretKeyRef:
                  name: db-secrets
                  key: password
          restartPolicy: OnFailure