Run Daily Maintenance at 1:30 AM | CronBase

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

// Schedule task to run daily at 1:30 AM in UTC
cron.schedule('30 1 * * *', () => {
    console.log(`[${new Date().toISOString()}] Initiating daily database backup...`);
    try {
        exec('/usr/local/bin/backup-db.sh', (error, stdout, stderr) => {
            if (error) {
                console.error(`Backup execution error: ${error.message}`);
                return;
            }
            if (stderr) {
                console.warn(`Backup process warning: ${stderr}`);
            }
            console.log(`Backup completed: ${stdout}`);
        });
    } catch (err) {
        console.error('Unexpected execution error during daily cron:', err);
    }
}, {
    scheduled: true,
    timezone: "UTC"
});

#!/bin/bash
# System crontab entry for daily maintenance at 1:30 AM
# Uses flock to prevent overlapping runs and redirects output to a logfile with timestamps

# Installation: Add this to your crontab using 'crontab -e':
# 30 1 * * * /usr/local/bin/daily-cleanup.sh >> /var/log/daily-cleanup.log 2>&1

LOCKFILE="/var/run/daily-cleanup.lock"
exec 9>"$LOCKFILE"
if ! flock -n 9; then
    echo "[$(date -u)] Script is already running. Exiting to prevent overlap." >&2
    exit 1
fi

echo "[$(date -u)] Starting daily maintenance task..."
# Perform maintenance tasks (e.g., clearing tmp, rotating files)
# Add your production logic here...

exit 0

from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.cron import CronTrigger
import logging
import sys

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

def daily_sync_job():
    logging.info("Starting daily data synchronization pipeline...")
    try:
        # Place ETL or synchronization logic here
        pass
    except Exception as e:
        logging.error(f"Sync job failed: {str(e)}")
        # In production, hook into an alerting service like Sentry or PagerDuty

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # 30 1 * * * translates to hour=1, minute=30
    trigger = CronTrigger(hour=1, minute=30, timezone='UTC')
    scheduler.add_job(daily_sync_job, trigger=trigger, id='daily_sync_id')
    
    try:
        logging.info("Scheduler started. Waiting for 01:30 UTC...")
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logging.info("Scheduler stopped cleanly.")
        sys.exit(0)

package main

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

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

func main() {
	// Use UTC location to avoid Daylight Saving Time issues
	utc, err := time.LoadLocation("UTC")
	if err != nil {
		log.Fatalf("Failed to load UTC location: %v", err)
	}

	c := cron.New(cron.WithLocation(utc))

	// 30 1 * * * runs at 1:30 AM daily
	_, err = c.AddFunc("30 1 * * *", func() {
		log.Println("Daily data pipeline execution started...")
		executeDataPipeline()
	})
	if err != nil {
		log.Fatalf("Error scheduling daily job: %v", err)
	}

	c.Start()
	log.Println("Cron scheduler started in UTC mode.")

	// Handle graceful shutdown
	sig := make(chan os.Signal, 1)
	signal.Notify(sig, syscall.SIGINT, syscall.SIGTERM)
	<-sig

	log.Println("Stopping scheduler...")
	c.Stop()
}

func executeDataPipeline() {
	// Processing logic goes here
	log.Println("Daily data pipeline completed successfully.")
}

package com.example.scheduler;

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

@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.
    // "0 30 1 * * *" executes at 1:30:00 AM every day.
    // Zone is explicitly set to UTC to guarantee predictable execution times.
    @Scheduled(cron = "0 30 1 * * *", zone = "UTC")
    public void runDailyCleanup() {
        logger.info("Executing scheduled daily cleanup task...");
        try {
            performCleanupTasks();
            logger.info("Daily cleanup completed successfully.");
        } catch (Exception e) {
            logger.error("Error occurred during scheduled daily cleanup: ", e);
            // Implement alerting hook here
        }
    }

    private void performCleanupTasks() {
        // Application-specific cleanup logic
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-db-backup
  namespace: production
spec:
  schedule: "30 1 * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: backup-worker
            image: postgres:15-alpine
            command:
            - /bin/sh
            - -c
            - "pg_dump -h db-host -U postgres dbname > /mnt/backups/db-$(date +%F).sql"
            volumeMounts:
            - name: backup-storage
              mountPath: /mnt/backups
          restartPolicy: OnFailure
          volumes:
          - name: backup-storage
            persistentVolumeClaim:
              claimName: backup-pvc