Run Jobs Hourly at the Top of the Hour | CronBase

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

// Schedule the task to run at minute 0 of every hour
cron.schedule('0 * * * *', async () => {
    console.log(`[${new Date().toISOString()}] Initiating hourly cache invalidation...`);
    try {
        await clearExpiredSessions();
        console.log('Hourly cache invalidation completed.');
    } catch (error) {
        console.error('Unexpected execution error during hourly task:', error);
    }
});

async function clearExpiredSessions() {
    // Production session clearing logic goes here
    return Promise.resolve();
}

#!/usr/bin/env bash
# Hourly maintenance task with flock to prevent overlapping executions
set -euo pipefail

LOCKFILE="/var/lock/hourly_maintenance.lock"
exec 9>"$LOCKFILE"

if ! flock -n 9; then
    echo "Error: Another instance of the hourly job is still running." >&2
    exit 1
fi

echo "[$(date -u)] Starting hourly database cleanup..."
# Perform cleanup operation here
# e.g., pg_dump or temporary file removal
echo "[$(date -u)] Hourly cleanup completed successfully."

import logging
from apscheduler.schedulers.blocking import BlockingScheduler

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

def hourly_data_sync():
    logger.info("Starting hourly data synchronization pipeline...")
    try:
        # Real-world ETL / API synchronization logic goes here
        pass
        logger.info("Hourly data synchronization finished successfully.")
    except Exception as e:
        logger.error(f"Data synchronization failed: {e}", exc_info=True)

if __name__ == "__main__":
    scheduler = BlockingScheduler()
    # '0 * * * *' translates to running at minute 0 of every hour
    scheduler.add_job(hourly_data_sync, 'cron', minute=0)
    logger.info("Hourly scheduler initialized.")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("Scheduler stopped cleanly.")

package main

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

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

func main() {
	logger := log.New(os.Stdout, "HOURLY_JOB: ", log.LstdFlags|log.Lshortfile)
	
	// Initialize cron scheduler with standard 5-field parser
	c := cron.New(cron.WithParser(cron.NewParser(
		cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor,
	)))

	_, err := c.AddFunc("0 * * * *", func() {
		logger.Println("Executing hourly log rotation and metrics flush...")
		if err := performHourlyTask(); err != nil {
			logger.Printf("ERROR: Hourly task failed: %v\n", err)
		}
	})
	if err != nil {
		logger.Fatalf("Failed to schedule job: %v", err)
	}

	c.Start()
	logger.Println("Scheduler started. Waiting for execution...")

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

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

func performHourlyTask() error {
	return nil
}

package com.example.cron;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Component
public class HourlyTaskScheduler {

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

    // Spring's @Scheduled uses a 6-field pattern (second, minute, hour, day, month, weekday)
    // "0 0 * * * *" means at second 0, minute 0 of every hour
    @Scheduled(cron = "0 0 * * * *")
    public void runHourlyMaintenance() {
        logger.info("Starting hourly database index optimization...");
        try {
            optimizeIndexes();
            logger.info("Hourly index optimization completed.");
        } catch (Exception e) {
            logger.error("Error during index optimization", e);
        }
    }

    private void optimizeIndexes() {
        // Logic to execute database index optimization
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: hourly-data-pruner
  namespace: default
spec:
  schedule: "0 * * * *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: pruner
            image: alpine:3.18
            command:
            - /bin/sh
            - -c
            - "echo 'Starting pruning...'; sleep 10; echo 'Pruning complete.'"
          restartPolicy: OnFailure