Run Jobs Every 15 Minutes Safely | CronBase

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

# Define lock file to prevent overlapping executions
LOCKFILE="/var/lock/quarter_hourly_job.lock"
exec 9>"$LOCKFILE"

# Attempt to acquire an exclusive lock without blocking
if ! flock -n 9; then
    echo "[$(date '+$Y-%m-%d %H:%M:%S')] Error: Job is already running. Exiting." >&2
    exit 1
fi

echo "[$(date '+$Y-%m-%d %H:%M:%S')] Starting 15-minute maintenance task..."
# Place your production logic here (e.g., database cleanup, log shipping)
# /usr/local/bin/sync-script.sh

echo "[$(date '+$Y-%m-%d %H:%M:%S')] Task completed successfully."

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

let isJobRunning = false;

// Schedule task to run every 15 minutes
cron.schedule('*/15 * * * *', async () => {
    if (isJobRunning) {
        logger.warn('Previous execution is still running. Skipping this cycle to prevent overlaps.');
        return;
    }

    isJobRunning = true;
    logger.info('Starting 15-minute synchronization task...');
    const startTime = Date.now();

    try {
        // Place async business logic here
        await performSynchronization();
        logger.info({ durationMs: Date.now() - startTime }, 'Task completed successfully.');
    } catch (error) {
        logger.error({ err: error }, 'Task execution failed.');
    } finally {
        isJobRunning = false;
    }
});

async function performSynchronization() {
    return new Promise(resolve => setTimeout(resolve, 5000));
}

import logging
import time
from apscheduler.schedulers.blocking import BlockingScheduler

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger("QuarterHourlyJob")

scheduler = BlockingScheduler()

# Coalesce: if multiple executions are missed, run only once. 
# max_instances: prevent multiple concurrent instances of this job.
@scheduler.scheduled_job('cron', minute='*/15', coalesce=True, max_instances=1)
def run_task():
    logger.info("Executing 15-minute pipeline task...")
    start_time = time.time()
    try:
        # Insert your pipeline, data-sync, or API pulling logic here
        time.sleep(10)  # Simulating processing
        logger.info(f"Job completed successfully in {time.time() - start_time:.2f} seconds.")
    except Exception as e:
        logger.error(f"Execution encountered an error: {e}", exc_info=True)

if __name__ == "__main__":
    try:
        logger.info("Starting scheduler daemon...")
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped gracefully.")

package main

import (
	"context"
	"log"
	"sync/atomic"
	"time"

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

func main() {
	c := cron.New()
	var activeRuns int32

	_, err := c.AddFunc("*/15 * * * *", func() {
		// Atomic lock to guarantee single concurrency
		if !atomic.CompareAndSwapInt32(&activeRuns, 0, 1) {
			log.Println("Warning: Overlap detected. Skipping execution.")
			return
		}
		defer atomic.StoreInt32(&activeRuns, 0)

		// Set a hard timeout slightly below the schedule interval
		ctx, cancel := context.WithTimeout(context.Background(), 14*time.Minute)
		defer cancel()

		log.Println("Starting quarter-hourly job...")
		performWork(ctx)
		log.Println("Job run completed.")
	})

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

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

func performWork(ctx context.Context) {
	select {
	case <-time.After(5 * time.Second):
		// Work finished
	case <-ctx.Done():
		log.Println("Error: Task timed out before completion.")
	}
}

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

    private static final Logger log = LoggerFactory.getLogger(QuarterHourlyScheduler.class);
    private boolean isRunning = false;

    // Standard cron format: second, minute, hour, day of month, month, day of week
    @Scheduled(cron = "0 */15 * * * *")
    public synchronized void executeTask() {
        if (isRunning) {
            log.warn("Previous scheduled run is still active. Skipping execution.");
            return;
        }
        
        isRunning = true;
        log.info("Starting 15-minute synchronization task...");
        long startTime = System.currentTimeMillis();

        try {
            // Implement high-performance batch operations here
            Thread.sleep(3000); 
            log.info("Task completed in {} ms.", (System.currentTimeMillis() - startTime));
        } catch (InterruptedException e) {
            log.error("Task was interrupted", e);
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            log.error("Error during scheduled execution", e);
        } finally {
            isRunning = false;
        }
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: quarter-hourly-cleanup
  namespace: production
spec:
  schedule: "*/15 * * * *"
  concurrencyPolicy: Forbid
  startingDeadlineSeconds: 60
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: worker
            image: registry.example.com/ops/utility-worker:v1.2.0
            imagePullPolicy: IfNotPresent
            resources:
              limits:
                cpu: "500m"
                memory: "512Mi"
              requests:
                cpu: "100m"
                memory: "128Mi"
          restartPolicy: OnFailure