Run Hourly Tasks During Business Hours | CronBase

#!/usr/bin/env bash
# Production-ready wrapper for hourly business tasks
set -euo pipefail

LOCKFILE="/var/lock/business-hourly-sync.lock"
# Prevent concurrent execution if a previous run hangs
exec 9>"$LOCKFILE"
if ! flock -n 9; then
    echo "Error: Another instance of this job is already running." >&2
    exit 1
fi

echo "[$(date -u)] Starting business hours sync..."
# Execute actual task
/usr/local/bin/sync-erp-data.sh --verbose

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

// Use the 'cron' package for timezone-aware execution
const { CronJob } = require('cron');

const job = new CronJob(
    '0 8-17 * * 1-5',
    async function() {
        console.log(`[${new Date().toISOString()}] Starting hourly business sync...`);
        try {
            await runBusinessSync();
            console.log('Sync completed successfully.');
        } catch (error) {
            console.error('Execution failed:', error);
            // Implement external alerting (e.g., Sentry, PagerDuty) here
        }
    },
    null,
    true,
    'America/New_York' // Explicit timezone handling is crucial
);

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')
logger = logging.getLogger(__name__)

def execute_job():
    logger.info("Executing hourly business process...")
    try:
        # Business logic goes here
        pass
    except Exception as e:
        logger.error(f"Job failed with error: {e}", exc_info=True)

if __name__ == '__main__':
    scheduler = BlockingScheduler()
    # Define trigger with explicit timezone to handle DST shifts
    trigger = CronTrigger.from_crontab('0 8-17 * * 1-5', timezone='America/New_York')
    scheduler.add_job(execute_job, trigger)
    logger.info("Scheduler started for weekday business hours.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped.")

package main

import (
    "context"
    "log"
    "time"

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

func main() {
    // Use America/New_York location to respect DST adjustments
    loc, err := time.LoadLocation("America/New_York")
    if err != nil {
        log.Fatalf("Failed to load timezone: %v", err)
    }

    c := cron.New(cron.WithLocation(loc))
    _, err = c.AddFunc("0 8-17 * * 1-5", func() {
        ctx, cancel := context.WithTimeout(context.Background(), 45*time.Minute)
        defer cancel()
        
        log.Println("Starting business hour execution...")
        if err := runTask(ctx); err != nil {
            log.Printf("Error running task: %v", err)
        }
    })
    if err != nil {
        log.Fatalf("Failed to schedule cron job: %v", err)
    }

    c.Start()
    select {} // Keep application running
}

func runTask(ctx context.Context) error {
    // Production logic goes here
    return nil
}

package com.example.cron;

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

@Component
public class BusinessHoursScheduler {

    private static final Logger log = LoggerFactory.getLogger(BusinessHoursScheduler.class);

    // Runs hourly from 8 AM to 5 PM, Monday through Friday
    // zone attribute ensures DST compliance regardless of host OS timezone
    @Scheduled(cron = "0 0 8-17 * * MON-FRI", zone = "America/New_York")
    public void executeBusinessTask() {
        log.info("Starting scheduled business task execution");
        try {
            performBusinessLogic();
            log.info("Business task executed successfully");
        } catch (Exception e) {
            log.error("Error executing business task", e);
        }
    }

    private void performBusinessLogic() {
        // Actual business logic implementation goes here
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekday-business-sync
  namespace: default
spec:
  schedule: "0 8-17 * * 1-5"
  timeZone: "America/New_York" # Requires K8s 1.27+
  concurrencyPolicy: Forbid # Avoid overlapping runs if a job stalls
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: worker
            image: registry.example.com/sync-worker:v1.2.0
            resources:
              limits:
                cpu: "500m"
                memory: "512Mi"
              requests:
                cpu: "200m"
                memory: "256Mi"
          restartPolicy: OnFailure