Run Yearly Jobs on January 1st | CronBase

const cron = require('node-cron');
const { execYearlyArchival } = require('./tasks/archive');

// Schedule task for January 1st at midnight (00:00)
cron.schedule('0 0 1 1 *', async () => {
  console.log('Starting annual maintenance and archival process...');
  try {
    await execYearlyArchival();
    console.log('Annual archival completed successfully.');
  } catch (error) {
    console.error('CRITICAL: Annual archival failed:', error);
    // Trigger external alerting system (e.g., PagerDuty, Slack webhook)
  }
}, {
  timezone: "UTC"
});

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

# Securely append the annual cron job to the user's crontab
CRON_JOB="0 0 1 1 * /usr/local/bin/annual-archive.sh >> /var/log/cron-annual.log 2>&1"

(crontab -l 2>/dev/null | grep -F -q "$CRON_JOB") || (
    (crontab -l 2>/dev/null; echo "$CRON_JOB") | crontab -
    echo "Successfully scheduled annual job in crontab."
)

from apscheduler.schedulers.blocking import BlockingScheduler
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger('annual_job')

def run_annual_job():
    logger.info("Starting annual year-end financial processing...")
    try:
        # Place your business logic here
        logger.info("Annual processing completed successfully.")
    except Exception as e:
        logger.critical(f"Annual job failed: {str(e)}", exc_info=True)

scheduler = BlockingScheduler(timezone="UTC")
# Run on month 1, day 1, hour 0, minute 0
scheduler.add_job(run_annual_job, 'cron', month=1, day=1, hour=0, minute=0)

if __name__ == '__main__':
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        pass

package main

import (
	"log"
	"os"
	"time"

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

func main() {
	utc, err := time.LoadLocation("UTC")
	if err != nil {
		log.Fatalf("Failed to load UTC timezone: %v", err)
	}

	c := cron.New(cron.WithLocation(utc))
	_, err = c.AddFunc("0 0 1 1 *", func() {
		log.Println("Executing annual system maintenance...")
		if err := performAnnualReset(); err != nil {
			log.Printf("CRITICAL: Annual reset failed: %v", err)
		}
	})
	if err != nil {
		log.Fatalf("Error scheduling cron job: %v", err)
	}

	c.Start()
	select {} // Block forever
}

func performAnnualReset() error {
	// Business logic goes here
	return nil
}

package com.example.cron;

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

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

    // Runs at 00:00 on January 1st every year
    @Scheduled(cron = "0 0 1 1 *", zone = "UTC")
    public void runAnnualTasks() {
        logger.info("Initiating annual database purging and reporting...");
        try {
            executePurge();
            logger.info("Annual tasks completed successfully.");
        } catch (Exception e) {
            logger.error("CRITICAL: Annual task execution failed", e);
        }
    }

    private void executePurge() throws Exception {
        // Enterprise database purge logic here
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: annual-data-archiver
  namespace: production
spec:
  schedule: "0 0 1 1 *"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: archiver
            image: registry.example.com/jobs/archiver:v1.2.0
            env:
            - name: TZ
              value: "UTC"
          restartPolicy: OnFailure