Schedule Daily Late Night Tasks at 11 PM | CronBase

#!/usr/bin/env bash
# Production Bash Cron Job Wrapper
# Scheduled via: 0 23 * * * /path/to/script.sh

set -euo pipefail

LOCKFILE="/var/lock/daily_cleanup.lock"
exec 200>"$LOCKFILE"

# Acquire an exclusive lock without blocking
if ! flock -n 200; then
    echo "Error: Another instance of this late-night job is already running." >&2
    exit 1
fi

echo "[$(date -u)] Starting daily maintenance tasks..."
# Real task execution here
# /usr/local/bin/cleanup-database-logs

echo "[$(date -u)] Daily maintenance completed successfully."

// cron-job.js
// Requires: npm install node-cron
const cron = require('node-cron');
const { exec } = require('child_process');

console.log('Initializing late-night daily cron scheduler...');

// Schedule task to run daily at 23:00 (11:00 PM)
cron.schedule('0 23 * * *', () => {
    const timestamp = new Date().toISOString();
    console.log(`[${timestamp}] Starting daily database backup transaction...`);

    exec('/usr/local/bin/backup-db.sh', (error, stdout, stderr) => {
        if (error) {
            console.error(`[${timestamp}] Backup failed: ${error.message}`);
            return;
        }
        if (stderr) {
            console.warn(`[${timestamp}] Backup warning: ${stderr}`);
        }
        console.log(`[${timestamp}] Backup completed: ${stdout}`);
    });
}, {
    scheduled: true,
    timezone: "UTC"
});

# scheduler.py
# Requires: pip install apscheduler
import sys
import logging
from datetime import datetime
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.cron import CronTrigger

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

def execute_nightly_sync():
    logging.info("Starting scheduled nightly data synchronization pipeline...")
    try:
        # Place actual production database/API logic here
        pass
        logging.info("Nightly synchronization pipeline completed successfully.")
    except Exception as e:
        logging.error(f"Execution failed: {str(e)}", exc_info=True)

if __name__ == '__main__':
    scheduler = BlockingScheduler()
    # 0 23 * * * corresponds to hour=23, minute=0
    trigger = CronTrigger(hour=23, minute=0, timezone='UTC')
    scheduler.add_job(execute_nightly_sync, trigger=trigger, id='nightly_sync_job')

    logging.info("Starting scheduler daemon for daily 23:00 task...")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logging.info("Scheduler shutdown requested.")
        sys.exit(0)

package main

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

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

func main() {
    log.Println("Initializing daily 23:00 cron runner...")

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

    _, err := c.AddFunc("0 23 * * *", func() {
        log.Println("Starting scheduled daily cleanup process...")
        err := runCleanupTask()
        if err != nil {
            log.Printf("ERROR: Cleanup task failed: %v", err)
        } else {
            log.Println("SUCCESS: Cleanup task finished.")
        }
    })

    if err != nil {
        log.Fatalf("Failed to schedule cron job: %v", err)
    }

    c.Start()
    defer c.Stop()

    // Keep process running until interrupted
    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
    <-sigChan
    log.Println("Shutting down cron runner gracefully...")
}

func runCleanupTask() error {
    // Simulated production logic
    time.Sleep(5 * time.Second)
    return nil
}

package com.example.scheduler;

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

@Component
public class NightlyTaskScheduler {

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

    // Spring's schedule uses 6 fields (second, minute, hour, day, month, day-of-week).
    // "0 0 23 * * *" translates to 23:00:00 daily.
    @Scheduled(cron = "0 0 23 * * *", zone = "UTC")
    public void executeNightlyDatabaseMaintenance() {
        logger.info("Triggering nightly database index maintenance job...");
        try {
            performMaintenance();
            logger.info("Nightly database maintenance completed successfully.");
        } catch (Exception e) {
            logger.error("Critical error during nightly database maintenance: ", e);
            // Implement alerting/monitoring notification mechanism here
        }
    }

    private void performMaintenance() throws Exception {
        // Simulate production database optimization work
        Thread.sleep(10000);
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-reporting-pipeline
  namespace: production
spec:
  schedule: "0 23 * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  startingDeadlineSeconds: 600
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: pipeline-runner
            image: registry.example.com/data/pipeline-runner:v1.2.0
            imagePullPolicy: IfNotPresent
            resources:
              limits:
                cpu: "1"
                memory: 1Gi
              requests:
                cpu: "500m"
                memory: 512Mi
            env:
            - name: ENVIRONMENT
              value: "production"
          restartPolicy: OnFailure