Run Tasks Every 15 Minutes During Day | CronBase

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

logger.info('Initializing Node.js daytime cron scheduler...');

// Schedule: Every 15 minutes, between 08:00 and 20:59 daily
const task = cron.schedule('*/15 8-20 * * *', () => {
  logger.info('Starting scheduled daytime synchronization task...');
  
  const start = Date.now();
  exec('/usr/local/bin/sync-script.sh', (error, stdout, stderr) => {
    const duration = Date.now() - start;
    if (error) {
      logger.error({ err: error, duration, stderr }, 'Task execution failed');
      return;
    }
    logger.info({ duration, stdout }, 'Task completed successfully');
  });
});

// Handle graceful shutdown
process.on('SIGTERM', () => {
  logger.info('SIGTERM received. Stopping cron scheduler...');
  task.stop();
  process.exit(0);
});

#!/usr/bin/env bash
set -euo pipefail

# Production Bash execution wrapper for standard crontab
# Crontab entry: */15 8-20 * * * /usr/local/bin/sync_job.sh >> /var/log/cron_sync.log 2>&1

LOCKFILE=\"/var/run/sync_job.lock\"

# Acquire an exclusive lock to prevent overlapping executions
exec 9>\"$LOCKFILE\"
if ! flock -n 9; then
  echo \"[$(date -u)] Error: Another instance of this job is already running. Exiting.\" >&2
  exit 1
fi

echo \"[$(date -u)] Starting daytime sync job...\"

# Introduce randomized jitter (0-15 seconds) to avoid stampeding downstream APIs
JITTER=$(( RANDOM % 16 ))
sleep \"$JITTER\"

# Execute actual business logic
if /usr/local/bin/perform_sync_payload; then
  echo \"[$(date -u)] Job completed successfully.\"
else
  echo \"[$(date -u)] Job failed with exit code $?.\" >&2
  exit 2
fi

import logging
import sys
import time
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.cron import CronTrigger

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

def execute_daytime_sync():
    logger.info(\"Executing 15-minute daytime synchronizer...\")
    try:
        # Simulate business logic execution
        time.sleep(2)
        logger.info(\"Sync cycle completed successfully.\")
    except Exception as e:
        logger.error(f\"Sync cycle failed: {str(e)}\", exc_info=True)

if __name__ == '__main__':
    scheduler = BlockingScheduler()
    # Standard cron syntax: */15 8-20 * * *
    trigger = CronTrigger.from_crontab('*/15 8-20 * * *', timezone='America/New_York')
    
    scheduler.add_job(execute_daytime_sync, trigger=trigger, id='daytime_sync_job')
    
    logger.info(\"Scheduler started. Target schedule: Every 15 minutes, 8 AM to 8 PM ET.\")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info(\"Scheduler stopped gracefully.\")

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)
	
	// Use local timezone or load a specific one
	loc, err := time.LoadLocation(\"America/New_York\")
	if err != nil {
		logger.Fatalf(\"Failed to load timezone: %v\", err)
	}

	c := cron.New(cron.WithLocation(loc), cron.WithLogger(cron.VerbosePrintfLogger(logger)))

	_, err = c.AddFunc(\"*/15 8-20 * * *\", func() {
		logger.Println(\"Executing daytime data pipeline job...\")
		start := time.Now()
		
		// Execute actual work
		err := performDataPipeline()
		
		duration := time.Since(start)
		if err != nil {
			logger.Printf(\"Job failed after %v: %v\", duration, err)
		} else {
			logger.Printf(\"Job finished successfully in %v\", duration)
		}
	})
	if err != nil {
		logger.Fatalf(\"Error scheduling job: %v\", err)
	}

	c.Start()
	logger.Println(\"Daytime scheduler running...\")

	// Wait for interrupt signal to gracefully shut down
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
	<-sigChan

	logger.Println(\"Stopping scheduler...\")
	c.Stop()
	logger.Println(\"Scheduler stopped.\")
}

func performDataPipeline() error {
	// Mock processing delay
	time.Sleep(1 * 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;

import java.time.Instant;

@Component
public class DaytimeSyncScheduler {

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

    // Spring @Scheduled supports standard cron expressions with optional zone
    @Scheduled(cron = \"0 */15 8-20 * * *\", zone = \"America/New_York\")
    public void executeDaytimeSync() {
        logger.info(\"Starting daytime sync task at {}...\", Instant.now());
        
        try {
            processBusinessLogic();
            logger.info(\"Daytime sync task completed successfully.\");
        } catch (Exception e) {
            logger.error(\"Critical failure during daytime sync execution\", e);
            // Implement alert routing or dead-letter queueing here
        }
    }

    private void processBusinessLogic() throws Exception {
        // Business logic execution simulated
        Thread.sleep(5000);
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daytime-fifteen-minute-sync
  namespace: production
spec:
  schedule: \"*/15 8-20 * * *\"
  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
            resources:
              limits:
                cpu: \"500m\"
                memory: \"512Mi\"
              requests:
                cpu: \"200m\"
                memory: \"256Mi\"
            env:
            - name: ENVIRONMENT
              value: \"production\"
          restartPolicy: OnFailure