Every 5 Minutes on Weekdays Cron Schedule | CronBase

#!/usr/bin/env bash

# Production Bash execution wrapper for standard cron
# Cron entry: */5 * * * 1-5 /usr/local/bin/weekday_sync.sh >> /var/log/cron_sync.log 2>&1

set -euo pipefail

LOCKFILE="/var/run/weekday_sync.lock"
TIMEOUT_SECONDS=280 # Exit before the next 5-minute invocation

# Ensure only one instance runs at a time using flock
exec 9>>"$LOCKFILE"
if ! flock -n 9; then
    echo "[$(date -u '+\%Y-\%m-\%dT\%H:\%M:\%SZ')] Warning: Previous execution is still running. Exiting to prevent overlap."
    exit 0
fi

# Execute actual payload with a timeout
echo "[$(date -u '+\%Y-\%m-\%dT\%H:\%M:\%SZ')] Starting weekday synchronization..."
timeout "$TIMEOUT_SECONDS" curl -fsS --retry 3 https://api.internal.service/v1/sync || {
    echo "[$(date -u '+\%Y-\%m-\%dT\%H:\%M:\%SZ')] Error: Sync failed or timed out."
    exit 1
}

echo "[$(date -u '+\%Y-\%m-\%dT\%H:\%M:\%SZ')] Sync completed successfully."

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

// Schedule: */5 * * * 1-5 (Every 5 minutes, Monday through Friday)
const cronExpression = '*/5 * * * 1-5';
let isRunning = false;

console.log(`Scheduler initialized. Active pattern: ${cronExpression}`);

const task = cron.schedule(cronExpression, async () => {
    if (isRunning) {
        console.warn(`[${new Date().toISOString()}] Task overlap detected; skipping execution.`);
        return;
    }

    isRunning = true;
    console.log(`[${new Date().toISOString()}] Executing weekday queue processing...`);

    try {
        await new Promise((resolve, reject) => {
            // Simulate database queue processing
            setTimeout(() => {
                const success = true;
                if (success) resolve();
                else reject(new Error('Database query failure'));
            }, 5000);
        });
        console.log(`[${new Date().toISOString()}] Queue processing completed.`);
    } catch (error) {
        console.error(`[${new Date().toISOString()}] Error during execution:`, error.message);
    } finally {
        isRunning = false;
    }
}, {
    scheduled: true,
    timezone: "UTC"
});

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

def execute_ingestion_job():
    logger.info("Starting high-frequency weekday ingestion...")
    try:
        # Simulate data pipeline execution
        time.sleep(10)
        logger.info("Ingestion completed successfully.")
    except Exception as e:
        logger.error(f"Ingestion failed: {str(e)}")

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # */5 * * * 1-5 maps to: minute='*/5', hour='*', day='*', month='*', day_of_week='mon-fri'
    trigger = CronTrigger(minute='*/5', day_of_week='mon-fri', timezone='UTC')
    
    scheduler.add_job(
        execute_ingestion_job,
        trigger=trigger,
        id='weekday_ingestion_job',
        max_instances=1, # Prevent concurrent execution
        coalesce=True
    )
    
    logger.info("Starting APScheduler daemon for weekday interval...")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped cleanly.")

package main

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

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

func main() {
	logger := log.New(os.Stdout, "CRON: ", log.LstdFlags|log.Lshortfile)

	// Use UTC as standard practice for cloud native crons
	c := cron.New(cron.WithLocation(time.UTC))

	// */5 * * * 1-5 standard schedule translated to robfig/cron
	_, err := c.AddFunc("*/5 * * * 1-5", func() {
		ctx, cancel := context.WithTimeout(context.Background(), 4*time.Minute)
		defer cancel()

		logger.Println("Running scheduled weekday healthcheck...")
		if err := runHealthcheck(ctx); err != nil {
			logger.Printf("Healthcheck failed: %v\n", err)
		} else {
			logger.Println("Healthcheck finished successfully.")
		}
	})

	if err != nil {
		logger.Fatalf("Error scheduling job: %v", err)
	}

	c.Start()
	logger.Println("Cron scheduler started successfully")

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

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

func runHealthcheck(ctx context.Context) error {
	select {
	case <-time.After(2 * time.Second):
		return nil
	case <-ctx.Done():
		return ctx.Err()
	}
}

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 WeekdayDataSyncScheduler {

    private static final Logger logger = LoggerFactory.getLogger(WeekdayDataSyncScheduler.class);
    private static boolean isJobRunning = false;

    // Spring Cron format: second, minute, hour, day of month, month, day(s) of week
    // "0 */5 * * * MON-FRI" evaluates to every 5 minutes on weekdays
    @Scheduled(cron = "0 */5 * * * MON-FRI", zone = "UTC")
    public synchronized void performWeekdaySync() {
        if (isJobRunning) {
            logger.warn("Previous sync task is still running. Skipping execution.");
            return;
        }

        isJobRunning = true;
        logger.info("Starting sync operation...");

        try {
            // Perform actual database or API processing
            Thread.sleep(15000); 
            logger.info("Sync completed successfully.");
        } catch (InterruptedException e) {
            logger.error("Sync job was interrupted", e);
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            logger.error("Error during sync processing", e);
        } finally {
            isJobRunning = false;
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekday-batch-processor
  namespace: default
spec:
  schedule: "*/5 * * * 1-5"
  concurrencyPolicy: Forbid
  startingDeadlineSeconds: 100
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      activeDeadlineSeconds: 280
      template:
        spec:
          containers:
          - name: processor
            image: python:3.9-slim
            command:
            - python
            - -c
            - |
              import sys
              import urllib.request
              try:
                  print("Processing weekday metrics...")
                  with urllib.request.urlopen("https://api.internal.service/v1/heartbeat", timeout=10) as response:
                      print(f"Status: {response.getcode()}")
              except Exception as e:
                  print(f"Error: {e}")
                  sys.exit(1)
            resources:
              requests:
                cpu: "100m"
                memory: "128Mi"
              limits:
                cpu: "300m"
                memory: "256Mi"
          restartPolicy: OnFailure