Run Hourly Tasks During Business Hours | CronBase

const cron = require('node-cron');

// Schedule to run hourly from 9 AM to 5 PM, Monday to Friday
// Cron syntax: 0 9-17 * * 1-5
cron.schedule('0 9-17 * * 1-5', async () => {
    console.log(`[${new Date().toISOString()}] Initiating business hours task...`);
    try {
        await runTask();
        console.log(`[${new Date().toISOString()}] Task completed successfully.`);
    } catch (error) {
        console.error(`[${new Date().toISOString()}] Task failed:`, error);
    }
}, {
    scheduled: true,
    timezone: "America/New_York" // Explicitly define business timezone
});

async function runTask() {
    return new Promise((resolve) => {
        // Implement business logic here
        resolve();
    });
}

#!/usr/bin/env bash
# Production wrapper script for running tasks hourly during business hours
set -euo pipefail

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

# Acquire an exclusive lock to prevent overlapping runs
if ! flock -n 9; then
    echo "Error: Another instance of the job is currently running." >&2
    exit 1
fi

echo "[$(date -u)] Starting business hours hourly synchronization..."
# Execute the actual workload here
# /usr/local/bin/sync-data.sh

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

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_business_task():
    logger.info("Starting scheduled business-hour task execution.")
    try:
        # Core business logic goes here
        pass
        logger.info("Task execution completed successfully.")
    except Exception as e:
        logger.error(f"Execution failed: {str(e)}", exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # Trigger hourly (0 minute) from 9am to 5pm, Mon-Fri
    trigger = CronTrigger(
        minute=0,
        hour="9-17",
        day_of_week="mon-fri",
        timezone="America/New_York"
    )
    scheduler.add_job(execute_business_task, trigger)
    logger.info("Scheduler initialized for business-hours schedule (0 9-17 * * 1-5).")
    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() {
	logger := log.New(os.Stdout, "[CRON] ", log.LstdFlags|log.Lshortfile)
	
	nyc, err := time.LoadLocation("America/New_York")
	if err != nil {
		logger.Fatalf("Failed to load timezone: %v", err)
	}
	
	c := cron.New(cron.WithLocation(nyc))
	
	_, err = c.AddFunc("0 9-17 * * 1-5", func() {
		logger.Println("Starting business-hour synchronization job...")
		if err := performSync(); err != nil {
			logger.Printf("Job execution failed: %v", err)
		} else {
			logger.Println("Job execution finished successfully.")
		}
	})
	if err != nil {
		logger.Fatalf("Error scheduling job: %v", err)
	}

	c.Start()
	logger.Println("Cron runner active. Listening for 0 9-17 * * 1-5...")

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

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

func performSync() error {
	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 BusinessHourScheduler {

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

    // Runs hourly from 9 AM to 5 PM, Monday through Friday
    @Scheduled(cron = "0 0 9-17 * * MON-FRI", zone = "America/New_York")
    public void executeHourlyTask() {
        log.info("Starting scheduled business-hour task execution.");
        try {
            runBusinessProcess();
            log.info("Business-hour task executed successfully.");
        } catch (Exception e) {
            log.error("Error occurred during task execution", e);
        }
    }

    private void runBusinessProcess() throws Exception {
        // Business logic goes here
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: business-hours-hourly-sync
  namespace: default
spec:
  schedule: "0 9-17 * * 1-5"
  timeZone: "America/New_York"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec: 
      template:
        spec:
          containers:
          - name: sync-worker
            image: registry.example.com/sync-worker:v1.2.0
            resources:
              limits:
                cpu: "500m"
                memory: "512Mi"
              requests:
                cpu: "200m"
                memory: "256Mi"
          restartPolicy: OnFailure