Run Daily Late-Night Maintenance at 11:45 PM | CronBase

#!/usr/bin/env bash
# Production-ready daily late-night backup script designed for 23:45 execution.
# Uses flock to prevent concurrent execution if a previous run hangs.
set -euo pipefail

LOCKFILE="/var/lock/daily_backup_2345.lock"
exec 9>"$LOCKFILE"

if ! flock -n 9; then
    echo "Error: Another instance of the daily backup is already running." >&2
    exit 1
fi

echo "[$(date -u)] Starting late-night daily database backup..."
# Simulate database backup
if pg_dump -U postgres prod_db > /backups/db_$(date +%F).sql; then
    echo "[$(date -u)] Daily backup completed successfully."
else
    echo "[$(date -u)] Daily backup failed!" >&2
    exit 2
fi

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

// Schedule the task to run every day at 23:45 (11:45 PM)
// Cron expression: 45 23 * * *
cron.schedule('45 23 * * *', () => {
    console.log(`[${new Date().toISOString()}] Initiating scheduled late-night cleanup...`);
    
    exec('/usr/local/bin/cleanup-logs.sh', (error, stdout, stderr) => {
        if (error) {
            console.error(`[ERROR] Cleanup failed: ${error.message}`);
            return;
        }
        if (stderr) {
            console.warn(`[WARN] Cleanup stderr: ${stderr}`);
        }
        console.log(`[SUCCESS] Cleanup stdout: ${stdout}`);
    });
}, {
    scheduled: true,
    timezone: "UTC"
});

import logging
from datetime import datetime
from apscheduler.schedulers.blocking import BlockingScheduler

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

def run_daily_reconciliation():
    logger.info("Starting daily financial reconciliation task...")
    try:
        # Perform end-of-day transaction reconciling operations
        logger.info("Daily reconciliation completed successfully.")
    except Exception as e:
        logger.error(f"Reconciliation task failed: {str(e)}", exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # 45 23 * * * translates to hour=23, minute=45 daily
    scheduler.add_job(
        run_daily_reconciliation, 
        'cron', 
        hour=23, 
        minute=45, 
        timezone='UTC'
    )
    logger.info("Scheduler started. Job configured for 23:45 UTC daily.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped cleanly.")

package main

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

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

func main() {
	// Use UTC timezone to prevent DST issues
	nyc, err := time.LoadLocation("UTC")
	if err != nil {
		log.Fatalf("Failed to load timezone: %v", err)
	}

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

	// Schedule daily late-night report generation at 23:45
	_, err = c.AddFunc("45 23 * * *", func() {
		log.Println("Starting scheduled daily reporting job...")
		if err := runDailyReport(); err != nil {
			log.Printf("ERROR: Daily report job failed: %v", err)
		} else {
			log.Println("SUCCESS: Daily report job completed.")
		}
	})
	if err != nil {
		log.Fatalf("Error scheduling cron job: %v", err)
	}

	c.Start()
	log.Println("Cron scheduler started for 23:45 daily...")

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

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

func runDailyReport() error {
	// Production logic goes here
	time.Sleep(5 * time.Second)
	return nil
}

package com.cronbase.scheduler;

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

@Component
public class LateNightTaskScheduler {

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

    // Cron expression for 23:45 (11:45 PM) every day.
    // Spring @Scheduled cron format: "second minute hour day-of-month month day-of-week"
    // We specify "0 45 23 * * *" to target the 45th minute of the 23rd hour.
    @Scheduled(cron = "0 45 23 * * *", zone = "UTC")
    public void executeDailyCleanup() {
        logger.info("Starting scheduled daily cleanup and optimization task...");
        try {
            performDatabaseOptimization();
            logger.info("Daily cleanup and optimization completed successfully.");
        } catch (Exception e) {
            logger.error("Error occurred during daily cleanup execution: ", e);
        }
    }

    private void performDatabaseOptimization() {
        // Production logic for late-night database maintenance goes here
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-cleanup-2345
  namespace: production
spec:
  schedule: "45 23 * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: cleanup-agent
            image: postgres:15-alpine
            command:
            - /bin/sh
            - -c
            - "echo 'Starting late-night database indexing...' && psql -h db-service -U postgres -d prod_db -c 'REINDEX DATABASE prod_db;'"
            env:
            - name: PGPASSWORD
              valueFrom:
                secretKeyRef:
                  name: db-credentials
                  key: password
          restartPolicy: OnFailure