Schedule Daily Tasks at 2:30 PM | CronBase

#!/usr/bin/env bash
# Production crontab deployment script for daily 2:30 PM task
set -euo pipefail

CRON_ENTRY="30 14 * * * /usr/local/bin/backup-job.sh >> /var/log/backup-job.log 2>&1"

# Check if cron job already exists to prevent duplicate entries
if crontab -l 2>/dev/null | grep -Fq "/usr/local/bin/backup-job.sh"; then
    echo "Cron job already exists. Skipping installation."
else
    (crontab -l 2>/dev/null; echo "$CRON_ENTRY") | crontab -
    echo "Successfully scheduled daily task at 14:30."
fi

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

// Schedule daily execution at 14:30 (2:30 PM) server time
const task = cron.schedule('30 14 * * *', () => {
    console.log(`[${new Date().toISOString()}] Starting daily afternoon synchronization...`);
    exec('/usr/local/bin/sync-script.sh', (error, stdout, stderr) => {
        if (error) {
            console.error(`Execution error: ${error.message}`);
            return;
        }
        if (stderr) {
            console.warn(`Execution warning output: ${stderr}`);
        }
        console.log(`Job output: ${stdout}`);
    });
}, {
    scheduled: true,
    timezone: "America/New_York" // Explicitly define timezone to prevent shift issues
});

import logging
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 daily_afternoon_job():
    logging.info("Executing scheduled afternoon job...")
    try:
        # Place production business logic here
        pass
    except Exception as e:
        logging.error(f"Job failed with exception: {e}")

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # 30 14 * * * equivalent trigger with explicit timezone setting
    trigger = CronTrigger(hour=14, minute=30, timezone="UTC")
    scheduler.add_job(daily_afternoon_job, trigger)
    logging.info("Scheduler started. Job scheduled for 14:30 UTC daily.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logging.info("Scheduler stopped cleanly.")

package main

import (
    "fmt"
    "log"
    "time"

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

func main() {
    // Use NewWithLocation to explicitly pin execution to a reliable timezone
    loc, err := time.LoadLocation("America/Chicago")
    if err != nil {
        log.Fatalf("Failed to load timezone: %v", err)
    }

    c := cron.New(cron.WithLocation(loc))
    
    // 30 14 * * * runs daily at 14:30
    _, err = c.AddFunc("30 14 * * *", func() {
        log.Println("Daily 2:30 PM job initiated.")
        if err := runDailyTask(); err != nil {
            log.Printf("Error during daily task execution: %v", err)
        }
    })
    if err != nil {
        log.Fatalf("Error scheduling cron job: %v", err)
    }

    c.Start()
    log.Println("Cron engine started, waiting for 14:30 execution...")
    select {} // Block main thread indefinitely
}

func runDailyTask() error {
    // Production execution logic goes here
    fmt.Println("Processing daily business reports...")
    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 DailyTaskScheduler {

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

    // "30 14 * * *" equivalent. Spring schedule format supports 6 fields (seconds optional/not used here)
    // zone attribute ensures consistency regardless of host server's local configuration
    @Scheduled(cron = "0 30 14 * * *", zone = "America/New_York")
    public void executeDailyTask() {
        logger.info("Daily afternoon job started at 14:30 New York time.");
        try {
            performMaintenance();
            logger.info("Daily afternoon job completed successfully.");
        } catch (Exception e) {
            logger.error("Critical error executing daily afternoon job: ", e);
        }
    }

    private void performMaintenance() {
        // Production logic for daily afternoon maintenance
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-afternoon-sync
  namespace: production
spec:
  schedule: "30 14 * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: sync-worker
            image: registry.example.com/sync-worker:v1.2.0
            command:
            - /bin/sh
            - -c
            - "python3 /app/run_sync.py"
            resources:
              limits:
                cpu: "500m"
                memory: "512Mi"
              requests:
                cpu: "250m"
                memory: "256Mi"
          restartPolicy: OnFailure