Run Jobs at Start, Midday, and End of Weekdays | CronBase

#!/usr/bin/env bash
# Production-ready crontab entry and execution script
# Cron expression: 0 8,12,17 * * 1-5
# Executes at 08:00, 12:00, and 17:00, Monday through Friday

set -euo pipefail

log_message() {
    echo "$(date -u '+%Y-%m-%d %H:%M:%S UTC') - [INFO] - $1"
}

log_message "Starting business checkpoint task..."

# Simulate workload execution with error handling
if ! /usr/local/bin/sync-business-data.sh; then
    log_message "ERROR: Synchronization task failed." >&2
    exit 1
fi

log_message "Business checkpoint completed successfully."

// Ensure you have run: npm install node-cron
const cron = require('node-cron');
const { exec } = require('child_process');

// Schedule: 0 8,12,17 * * 1-5 (Monday to Friday at 8am, 12pm, 5pm)
const scheduleExpression = '0 8,12,17 * * 1-5';

const task = cron.schedule(scheduleExpression, () => {
    console.log(`[${new Date().toISOString()}] Initiating scheduled database synchronization...`);
    
    exec('/opt/scripts/sync_db.sh', (error, stdout, stderr) => {
        if (error) {
            console.error(`[ERROR] Task execution failed: ${error.message}`);
            return;
        }
        if (stderr) {
            console.warn(`[WARN] Task stderr: ${stderr}`);
        }
        console.log(`[SUCCESS] Task output: ${stdout.trim()}`);
    });
}, {
    scheduled: true,
    timezone: "America/New_York"
});

task.start();

# Ensure you have run: pip install apscheduler pytz
import logging
import sys
from datetime import datetime
from apscheduler.schedulers.blocking import BlockingScheduler
from pytz import timezone

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[logging.StreamHandler(sys.stdout)]
)

def execute_reconciliation_job():
    logging.info("Starting weekday sync and reconciliation job...")
    try:
        # Business logic execution goes here
        logging.info("Reconciliation process completed successfully.")
    except Exception as e:
        logging.error(f"Critical failure during job execution: {str(e)}")

scheduler = BlockingScheduler()

# '0 8,12,17 * * 1-5' translates to hours 8, 12, 17 on days_of_week mon-fri
scheduler.add_job(
    execute_reconciliation_job,
    'cron',
    day_of_week='mon-fri',
    hour='8,12,17',
    minute=0,
    timezone=timezone('America/New_York'),
    id='business_checkpoint_sync'
)

try:
    logging.info("Starting scheduler for business-day checkpoints...")
    scheduler.start()
except (KeyboardInterrupt, SystemExit):
    logging.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-JOB] ", log.LstdFlags|log.Lshortfile)
	logger.Println("Initializing scheduler...")

	loc, err := time.LoadLocation("America/New_York")
	if err != nil {
		logger.Fatalf("Failed to load timezone: %v", err)
	}

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

	_, err = c.AddFunc("0 8,12,17 * * 1-5", func() {
		logger.Println("Executing business hours sync run...")
		if err := runSyncTask(); err != nil {
			logger.Printf("ERROR: Task failed: %v", err)
		} else {
			logger.Println("Task completed successfully.")
		}
	})
	if err != nil {
		logger.Fatalf("Failed to schedule cron job: %v", err)
	}

	c.Start()
	logger.Println("Scheduler running. Press Ctrl+C to exit.")

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

	logger.Println("Shutting down scheduler...")
	c.Stop()
}

func runSyncTask() error {
	time.Sleep(2 * 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 BusinessCheckpointScheduler {

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

    // Spring cron format: second, minute, hour, day of month, month, day of week
    @Scheduled(cron = "0 0 8,12,17 * * MON-FRI", zone = "America/New_York")
    public void executeBusinessSync() {
        logger.info("Executing scheduled business-hours synchronization task...");
        try {
            performDatabaseSync();
            logger.info("Database synchronization completed successfully.");
        } catch (Exception e) {
            logger.error("Error occurred during scheduled database synchronization", e);
        }
    }

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

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekday-business-sync
  namespace: production
  labels: 
    app: sync-service
spec:
  schedule: "0 8,12,17 * * 1-5"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: sync-worker
            image: registry.example.com/sync-worker:v1.2.0
            imagePullPolicy: IfNotPresent
            env:
            - name: TZ
              value: "America/New_York"
            resources:
              requests:
                cpu: "500m"
                memory: "512Mi"
              limits:
                cpu: "1000m"
                memory: "1Gi"
          restartPolicy: OnFailure