Getting context canceled from Client.Del when I expect it to complete when I'm interrupting the program

[NorseGaud]

Hi! I'm fairly new to golang and would love some advice.

I have an app with main.go, one.go, and contextUtil.go.

In main.go

package main

import (
	"context"
	"fmt"
	"log/slog"
	"os"
	"os/signal"
	"sync"
	"time"

	"github.com/norsegaud/anklet/internal/config"
	"github.com/norsegaud/anklet/internal/database"
	"github.com/norsegaud/anklet/internal/logging"
	"github.com/norsegaud/anklet/internal/run"
	contextUtil "github.com/norsegaud/anklet/internal/utils"
)

func main() {
	logger := logging.New()
	ctx, cancel := context.WithCancel(context.Background())
	c := make(chan os.Signal, 1)
	signal.Notify(c, os.Interrupt)
	go func() {
		<-c
		logger.InfoContext(ctx, "received an interrupt, stopping services")
		cancel() // Signal all services to stop
	}()

	loadedConfig, err := config.LoadConfig()
	if err != nil {
		panic(err)
	}

	var wg sync.WaitGroup
	for _, service := range loadedConfig.Services {
		wg.Add(1)
		go func(s config.Service) {
			defer wg.Done()
			serviceCtx, serviceCancel := context.WithCancel(ctx) // Inherit from parent context
			defer serviceCancel()                                // Ensure we cancel the context when service exits

			if s.Name == "" {
				panic("name is required for services")
			}

			serviceCtx = context.WithValue(serviceCtx, contextUtil.ContextKeyService, s)
			serviceCtx = context.WithValue(serviceCtx, contextUtil.ContextKeyLogger, logger)
			serviceCtx = logging.AppendCtx(serviceCtx, slog.String("serviceName", s.Name))
			databaseClient, err := database.NewClient(serviceCtx, loadedConfig.Database)
			if err != nil {
				panic(fmt.Sprintf("unable to access database: %v", err))
			}
			serviceCtx = context.WithValue(serviceCtx, contextUtil.ContextKeyDatabase, database.Database{
				Client: databaseClient,
			})

			for {
				select {
				case <-serviceCtx.Done(): // Check if context has been cancelled
					fmt.Printf("Service %s is stopping\n", s.Name)
					return // Exit the loop and hence the goroutine
				default:
					run.Plugin(serviceCtx, logger)
					time.Sleep(1 * time.Second) // Simulate work
				}
			}
		}(service)
	}
	wg.Wait() // Wait for all services to finish
	fmt.Println("All services stopped. Exiting now.")
}

In one.go I run some logic that just calls defer contextUtil.AnkaDelete(ctx, vmName) and defer contextUtil.RemoveUniqueKeyFromDB(ctx)

In contextUtil.go:

func (cli *Cli) AnkaDelete(ctx context.Context, vmName string) error {
	logger := contextUtil.GetLoggerFromContext(ctx)
	deleteOutput, err := cli.ExecuteParseJson(ctx, "anka", "delete", "--yes", vmName)
	if err != nil {
		return err
	}
	logger.InfoContext(ctx, "successfully deleted vm", "vm_name", vmName, "std", deleteOutput.Message)
	return nil
}

func RemoveUniqueKeyFromDB(ctx context.Context) {
	database, ok := ctx.Value(ContextKeyDatabase).(database.Database)
	if !ok {
		panic("database not found in context")
	}
	logging := GetLoggerFromContext(ctx)
	logging.DebugContext(ctx, fmt.Sprintf("removing unique key %s from database", database.UniqueRunKey))
	fmt.Printf("%+v\n", database.UniqueRunKey)
	deletion, err := database.Client.Del(ctx, database.UniqueRunKey).Result()
	fmt.Printf("%+v\n", err.Error())
	if err != nil {
		panic(err)
	}
	logging.DebugContext(ctx, fmt.Sprintf("deletion returned %d (1 is success, 0 failed)", deletion))
}

I can issue ctrl+c to trigger the interrupt and it starts doing the defers from one.go. However,database.Client.Del throws context canceled and never deletes the key from the database. I've confirmed database.UniqueRunKey is right. My only thought is that database.Client.Del is respecting the main's cancel that's sent. I need to prevent that so that certain things ALWAYS run before the process exists.

Am I missing anything? I'm guessing I can just send in a different ctx/context to database.Client.Del to solve this, but wanted to see if I'm thinking about this incorrectly and there is a better way.

[NorseGaud]

Side note: using context.Background() instead solves this. Something makes me feel like the Client.Del should allow me to ignore the context though... Thoughts?