Run Jobs Every Two Hours on the Hour | CronBase

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

// Schedule task to run every two hours: 0 */2 * * *
cron.schedule('0 */2 * * *', async () => {
    const startTime = new Date().toISOString();
    console.log(`[${startTime}] Starting bi-hourly cache invalidation...`);
    try {
        await performCacheClean();
        console.log(`[${new Date().toISOString()}] Cache invalidation completed successfully.`);
    } catch (error) {
        console.error(`[${new Date().toISOString()}] Critical error during cache invalidation:`, error.message);
        // In production, integrate with Sentry, PagerDuty, or Datadog here
    }
}, {
    scheduled: true,
    timezone: "Etc/UTC"
});

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

#!/usr/bin/env bash
# System cron entry: 0 */2 * * * /usr/local/bin/sync_assets.sh
set -euo pipefail
LOCKFILE="/var/lock/sync_assets.lock"
exec 9>"$LOCKFILE"
if ! flock -n 9; then
    echo "Error: Asset synchronization job is already running." >&2
    exit 1
fi
echo "Starting bi-hourly asset synchronization..."
# Perform actual work
if ! /usr/local/bin/perform_sync; then
    echo "Error: Sync failed. Sending alert." >&2
    exit 2
fi
echo "Synchronization completed successfully."

import logging
import sys
from datetime import datetime
from apscheduler.schedulers.blocking import BlockingScheduler

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

def execute_bi_hourly_backup():
    logger.info("Initiating database backup process...")
    try:
        # Simulated backup logic
        logger.info("Database backup completed successfully.")
    except Exception as e:
        logger.error(f"Database backup failed: {str(e)}", exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    scheduler.add_job(execute_bi_hourly_backup, 'cron', hour='*/2', minute=0, timezone='UTC')
    logger.info("Scheduler initialized. Running every 2 hours on the hour.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped cleanly.")
        sys.exit(0)

package main

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

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

func main() {
	logger := log.New(os.Stdout, "[Cron-Service] ", log.LstdFlags|log.Lshortfile)
	c := cron.New(cron.WithLocation(time.UTC))

	_, err := c.AddFunc("0 */2 * * *", func() {
		logger.Println("Starting bi-hourly API ingestion pipeline...")
		ctx, cancel := context.WithTimeout(context.Background(), 15*time.Minute)
		defer cancel()

		if err := runIngestion(ctx); err != nil {
			logger.Printf("CRITICAL: Ingestion failed: %v", err)
		} else {
			logger.Println("Ingestion pipeline 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 gracefully...")
	c.Stop()
}

func runIngestion(ctx context.Context) 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;
import java.time.Instant;

@Component
public class BiHourlyDataSyncJob {
    private static final Logger logger = LoggerFactory.getLogger(BiHourlyDataSyncJob.class);

    @Scheduled(cron = "0 0 */2 * * *", zone = "UTC")
    public void executeTask() {
        logger.info("Starting bi-hourly data synchronization task at {}", Instant.now());
        try {
            performSynchronization();
            logger.info("Bi-hourly data synchronization completed successfully.");
        } catch (Exception e) {
            logger.error("Error occurred during data synchronization: ", e);
        }
    }

    private void performSynchronization() throws Exception {
        Thread.sleep(2000);
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: bi-hourly-db-vacuum
  namespace: database-ops
spec:
  schedule: "0 */2 * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  startingDeadlineSeconds: 600
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: vacuum-worker
            image: postgres:15-alpine
            command:
            - /bin/sh
            - -c
            - "vacuumdb -U postgres -d main_production --analyze-only"
            env:
            - name: PGPASSWORD
              valueFrom:
                secretKeyRef:
                  name: db-credentials
                  key: password
          restartPolicy: OnFailure