Run Weekly Friday Evening Jobs at 6 PM | CronBase

const cron = require('node-cron');
const logger = require('./logger'); // Assume custom logging module

// Schedule task to run at 18:00 (6 PM) every Friday
cron.schedule('0 18 * * 5', async () => {
  logger.info('Starting weekly Friday evening maintenance task...');
  try {
    await runWeeklyMaintenance();
    logger.info('Weekly maintenance task completed successfully.');
  } catch (error) {
    logger.error('Failed to execute weekly maintenance task:', error);
    // Trigger alerting system (e.g., PagerDuty, Slack webhook)
  }
}, {
  scheduled: true,
  timezone: "Etc/UTC"
});

async function runWeeklyMaintenance() {
  // Production maintenance/reporting logic goes here
}

#!/usr/bin/env bash
# Friday evening backup and maintenance script
set -euo pipefail
LOG_FILE="/var/log/friday_backup.log"
exec >> "$LOG_FILE" 2>&1

echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Starting weekly maintenance job..."
# Add actual production backup or cleanup logic here
# Example: pg_dump -U postgres dbname > /backups/weekly_$(date +%F).sql
echo "[$(date -u +'%Y-%m-%dT%H:%M:%SZ')] Weekly job completed successfully."

import logging
import sys
from datetime import datetime

# Configure production logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s [%(levelname)s] %(message)s',
    handlers=[
        logging.FileHandler("/var/log/weekly_job.log"),
        logging.StreamHandler(sys.stdout)
    ]
)

def execute_weekly_job():
    logging.info("Initiating weekly Friday 6 PM database optimization...")
    try {
        # Place actual production database optimization or cleanup here
        pass
        logging.info("Weekly database optimization completed successfully.")
    except Exception as e:
        logging.error(f"Weekly job failed: {str(e)}", exc_info=True)
        sys.exit(1)

if __name__ == "__main__":
    execute_weekly_job()

package main

import (
	"log"
	"os"
	"time"

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

func main() {
	logger := log.New(os.Stdout, "CRON_WEEKLY: ", log.LstdFlags|log.Lshortfile)
	
	// Use UTC timezone explicitly for production predictability
	nyc, err := time.LoadLocation("America/New_York")
	if err != nil {
		logger.Fatalf("Failed to load timezone: %v", err)
	}

	c := cron.New(cron.WithLocation(nyc))
	
	// 0 18 * * 5 represents 18:00 on Friday
	_, err = c.AddFunc("0 18 * * 5", func() {
		logger.Println("Starting scheduled Friday 6 PM job...")
		if err := runWeeklyTask(); err != nil {
			logger.Printf("Error during weekly task execution: %v", err)
			// Implement alerting/monitoring dispatch here
		} else {
			logger.Println("Friday 6 PM job completed successfully.")
		}
	})
	if err != nil {
		logger.Fatalf("Error scheduling cron job: %v", err)
	}

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

func runWeeklyTask() error {
	// Production task logic
	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;

@Component
public class WeeklyMaintenanceScheduler {

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

    // Spring's @Scheduled uses a 6-field cron pattern: second, minute, hour, day, month, day-of-week
    @Scheduled(cron = "0 0 18 * * FRI", zone = "UTC")
    public void runFridayEveningMaintenance() {
        logger.info("Executing Friday evening maintenance job...");
        try {
            executeMaintenanceTasks();
            logger.info("Friday evening maintenance completed successfully.");
        } catch (Exception e) {
            logger.error("Error executing Friday evening maintenance: ", e);
            // Send alert to on-call engineer
        }
    }

    private void executeMaintenanceTasks() throws Exception {
        // Production-grade batch processing or cleanup logic
    }
}

apiVersion: batch/v1
kind: CronJob
metadata:
  name: weekly-friday-cleanup
  namespace: production
spec:
  schedule: "0 18 * * 5"
  concurrencyPolicy: Forbid
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 5
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: cleanup-worker
            image: postgres:15-alpine
            command:
            - /bin/sh
            - -c
            - "echo 'Starting weekly vacuum...'; vacuumdb -h db-service -U postgres -a -z"
            env:
            - name: PGPASSWORD
              valueFrom:
                secretKeyRef:
                  name: db-credentials
                  key: password
          restartPolicy: OnFailure