diff --git a/cmd/backup.go b/cmd/backup.go
index 00ea034..812f6f4 100644
--- a/cmd/backup.go
+++ b/cmd/backup.go
@@ -42,7 +42,7 @@ func (bk backup) Run(context wisski_distillery.Context) error {
 	if !bk.NoPrune {
 		defer logging.LogOperation(func() error {
 			return dis.Exporter().PruneExports(context.Context, context.Stderr)
-		}, context.Stderr, context.Context, "Pruning old backups")
+		}, context.Stderr, "Pruning old backups")
 	}
 
 	// do the handling
diff --git a/cmd/bootstrap.go b/cmd/bootstrap.go
index b5333c1..c00df19 100644
--- a/cmd/bootstrap.go
+++ b/cmd/bootstrap.go
@@ -80,7 +80,7 @@ func (bs cBootstrap) Run(context wisski_distillery.Context) error {
 	}
 
 	{
-		logging.LogMessage(context.Stderr, context.Context, "Creating root deployment directory")
+		logging.LogMessage(context.Stderr, "Creating root deployment directory")
 		if err := fsx.MkdirAll(root, fsx.DefaultDirPerm); err != nil {
 			return errBootstrapFailedToCreateDirectory.WithMessageF(root).Wrap(err)
 		}
@@ -105,7 +105,7 @@ func (bs cBootstrap) Run(context wisski_distillery.Context) error {
 	}
 
 	{
-		logging.LogMessage(context.Stderr, context.Context, "Copying over wdcli executable")
+		logging.LogMessage(context.Stderr, "Copying over wdcli executable")
 		exe, err := os.Executable()
 		if err != nil {
 			return errBoostrapFailedToCopyExe.WithMessageF(err)
@@ -144,7 +144,7 @@ func (bs cBootstrap) Run(context wisski_distillery.Context) error {
 				}
 
 				return nil
-			}, context.Stderr, context.Context, "Creating custom config files"); err != nil {
+			}, context.Stderr, "Creating custom config files"); err != nil {
 				return errBootstrapCreateFile.Wrap(err)
 			}
 
@@ -170,7 +170,7 @@ func (bs cBootstrap) Run(context wisski_distillery.Context) error {
 					_, err := configYML.Write(bytes)
 					return err
 				}
-			}, context.Stderr, context.Context, "Installing primary configuration file"); err != nil {
+			}, context.Stderr, "Installing primary configuration file"); err != nil {
 				return errBootstrapWriteConfig.Wrap(err)
 			}
 		}
@@ -178,7 +178,7 @@ func (bs cBootstrap) Run(context wisski_distillery.Context) error {
 	}
 
 	// re-read the configuration and print it!
-	logging.LogMessage(context.Stderr, context.Context, "Configuration is now complete")
+	logging.LogMessage(context.Stderr, "Configuration is now complete")
 	f, err := os.Open(cfgPath)
 	if err != nil {
 		return errBootstrapOpenConfig.Wrap(err)
@@ -192,7 +192,7 @@ func (bs cBootstrap) Run(context wisski_distillery.Context) error {
 	context.Println(cfg)
 
 	// Tell the user how to proceed
-	logging.LogMessage(context.Stderr, context.Context, "Bootstrap is complete")
+	logging.LogMessage(context.Stderr, "Bootstrap is complete")
 	context.Printf("Adjust the configuration file at %s\n", cfgPath)
 	context.Printf("Then make sure 'docker compose' is installed.\n")
 	context.Printf("Finally grab a GraphDB zipped source file and run:\n")
diff --git a/cmd/monday.go b/cmd/monday.go
index c32bcb6..d241c36 100644
--- a/cmd/monday.go
+++ b/cmd/monday.go
@@ -37,36 +37,36 @@ func (monday monday) AfterParse() error {
 func (monday monday) Run(context wisski_distillery.Context) error {
 	if err := logging.LogOperation(func() error {
 		return context.Exec("backup")
-	}, context.Stderr, context.Context, "Running backup"); err != nil {
+	}, context.Stderr, "Running backup"); err != nil {
 		return err
 	}
 
 	if err := logging.LogOperation(func() error {
 		return context.Exec("system_update", monday.Positionals.GraphdbZip)
-	}, context.Stderr, context.Context, "Running system_update"); err != nil {
+	}, context.Stderr, "Running system_update"); err != nil {
 		return err
 	}
 
 	if err := logging.LogOperation(func() error {
 		return context.Exec("rebuild")
-	}, context.Stderr, context.Context, "Running rebuild"); err != nil {
+	}, context.Stderr, "Running rebuild"); err != nil {
 		return err
 	}
 
 	if err := logging.LogOperation(func() error {
 		return context.Exec("update_prefix_config")
-	}, context.Stderr, context.Context, "Running update_prefix_config"); err != nil {
+	}, context.Stderr, "Running update_prefix_config"); err != nil {
 		return err
 	}
 
 	if monday.UpdateInstances {
 		if err := logging.LogOperation(func() error {
 			return context.Exec("blind_update")
-		}, context.Stderr, context.Context, "Running blind_update"); err != nil {
+		}, context.Stderr, "Running blind_update"); err != nil {
 			return err
 		}
 	}
 
-	logging.LogMessage(context.Stderr, context.Context, "Done, have a great week!")
+	logging.LogMessage(context.Stderr, "Done, have a great week!")
 	return nil
 }
diff --git a/cmd/provision.go b/cmd/provision.go
index cb39d00..7e15e7f 100644
--- a/cmd/provision.go
+++ b/cmd/provision.go
@@ -43,7 +43,7 @@ func (p pv) Run(context wisski_distillery.Context) error {
 	}
 
 	// and we're done!
-	logging.LogMessage(context.Stderr, context.Context, "Instance has been provisioned")
+	logging.LogMessage(context.Stderr, "Instance has been provisioned")
 	context.Printf("URL:      %s\n", instance.URL().String())
 	context.Printf("Username: %s\n", instance.DrupalUsername)
 	context.Printf("Password: %s\n", instance.DrupalPassword)
diff --git a/cmd/reserve.go b/cmd/reserve.go
index 303f405..7d87a01 100644
--- a/cmd/reserve.go
+++ b/cmd/reserve.go
@@ -47,7 +47,7 @@ func (r reserve) Run(context wisski_distillery.Context) (err error) {
 	slug := r.Positionals.Slug
 
 	// check that it doesn't already exist
-	logging.LogMessage(context.Stderr, context.Context, "Reserving new WissKI instance %s", slug)
+	logging.LogMessage(context.Stderr, "Reserving new WissKI instance %s", slug)
 	if exists, err := dis.Instances().Has(context.Context, slug); err != nil || exists {
 		return errReserveAlreadyExists.WithMessageF(slug)
 	}
@@ -59,7 +59,7 @@ func (r reserve) Run(context wisski_distillery.Context) (err error) {
 	}
 
 	// check that the base directory does not exist
-	logging.LogMessage(context.Stderr, context.Context, "Checking that base directory %s does not exist", instance.FilesystemBase)
+	logging.LogMessage(context.Stderr, "Checking that base directory %s does not exist", instance.FilesystemBase)
 	if fsx.IsDirectory(instance.FilesystemBase) {
 		return errReserveAlreadyExists.WithMessageF(slug)
 	}
@@ -69,19 +69,19 @@ func (r reserve) Run(context wisski_distillery.Context) (err error) {
 	{
 		if err := logging.LogOperation(func() error {
 			return s.Install(context.Context, context.Stderr, component.InstallationContext{})
-		}, context.Stderr, context.Context, "Installing docker stack"); err != nil {
+		}, context.Stderr, "Installing docker stack"); err != nil {
 			return err
 		}
 
 		if err := logging.LogOperation(func() error {
 			return s.Update(context.Context, context.Stderr, true)
-		}, context.Stderr, context.Context, "Updating docker stack"); err != nil {
+		}, context.Stderr, "Updating docker stack"); err != nil {
 			return err
 		}
 	}
 
 	// and we're done!
-	logging.LogMessage(context.Stderr, context.Context, "Instance has been reserved")
+	logging.LogMessage(context.Stderr, "Instance has been reserved")
 	context.Printf("URL:      %s\n", instance.URL().String())
 
 	return nil
diff --git a/cmd/system_pause.go b/cmd/system_pause.go
index 0fd76e7..4444c2f 100644
--- a/cmd/system_pause.go
+++ b/cmd/system_pause.go
@@ -60,7 +60,7 @@ func (sp systempause) Run(context wisski_distillery.Context) (err error) {
 }
 
 func (sp systempause) start(context wisski_distillery.Context, dis *dis.Distillery) error {
-	logging.LogMessage(context.Stderr, context.Context, "Starting Components")
+	logging.LogMessage(context.Stderr, "Starting Components")
 
 	// find all the core stacks
 	if err := status.RunErrorGroup(context.Stderr, status.Group[component.Installable, error]{
@@ -76,7 +76,7 @@ func (sp systempause) start(context wisski_distillery.Context, dis *dis.Distille
 		return err
 	}
 
-	logging.LogMessage(context.Stderr, context.Context, "Starting Up WissKIs")
+	logging.LogMessage(context.Stderr, "Starting Up WissKIs")
 
 	// find the instances
 	wissKIs, err := dis.Instances().All(context.Context)
@@ -102,7 +102,7 @@ func (sp systempause) start(context wisski_distillery.Context, dis *dis.Distille
 }
 
 func (sp systempause) stop(context wisski_distillery.Context, dis *dis.Distillery) error {
-	logging.LogMessage(context.Stderr, context.Context, "Shutting Down WissKIs")
+	logging.LogMessage(context.Stderr, "Shutting Down WissKIs")
 
 	// find the instances
 	wissKIs, err := dis.Instances().All(context.Context)
@@ -124,7 +124,7 @@ func (sp systempause) stop(context wisski_distillery.Context, dis *dis.Distiller
 		return err
 	}
 
-	logging.LogMessage(context.Stderr, context.Context, "Shutting Down Components")
+	logging.LogMessage(context.Stderr, "Shutting Down Components")
 
 	// find all the core stacks
 	if err := status.RunErrorGroup(context.Stderr, status.Group[component.Installable, error]{
diff --git a/cmd/system_update.go b/cmd/system_update.go
index 64567cc..1203fcd 100644
--- a/cmd/system_update.go
+++ b/cmd/system_update.go
@@ -83,7 +83,7 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
 	dis := context.Environment
 
 	// create all the other directories
-	logging.LogMessage(context.Stderr, context.Context, "Ensuring distillery installation directories exist")
+	logging.LogMessage(context.Stderr, "Ensuring distillery installation directories exist")
 	for _, d := range []string{
 		dis.Config.Paths.Root,
 		dis.Instances().Path(),
@@ -99,7 +99,7 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
 
 	if si.InstallDocker {
 		// install system updates
-		logging.LogMessage(context.Stderr, context.Context, "Updating Operating System Packages")
+		logging.LogMessage(context.Stderr, "Updating Operating System Packages")
 		if err := si.mustExec(context, "", "apt-get", "update"); err != nil {
 			return err
 		}
@@ -108,7 +108,7 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
 		}
 
 		// install docker
-		logging.LogMessage(context.Stderr, context.Context, "Installing / Updating Docker")
+		logging.LogMessage(context.Stderr, "Installing / Updating Docker")
 		if err := si.mustExec(context, "", "apt-get", "install", "curl"); err != nil {
 			return err
 		}
@@ -120,7 +120,7 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
 
 	// check that the docker api is available
 	{
-		logging.LogMessage(context.Stderr, context.Context, "Checking that the 'docker' api is reachable")
+		logging.LogMessage(context.Stderr, "Checking that the 'docker' api is reachable")
 		ping, err := dis.Docker().Ping(context.Context)
 		if err != nil {
 			return errDockerUnreachable.Wrap(err)
@@ -129,7 +129,7 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
 	}
 
 	{
-		logging.LogMessage(context.Stderr, context.Context, "Checking that 'docker compose' is available")
+		logging.LogMessage(context.Stderr, "Checking that 'docker compose' is available")
 		if err := si.mustExec(context, "", "docker", "compose", "version"); err != nil {
 			return err
 		}
@@ -137,7 +137,7 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
 
 	// create the docker networks
 	{
-		logging.LogMessage(context.Stderr, context.Context, "Configuring docker networks")
+		logging.LogMessage(context.Stderr, "Configuring docker networks")
 
 		for _, name := range dis.Config.Docker.Networks() {
 			id, existed, err := dis.Docker().CreateNetwork(context.Context, name)
@@ -192,7 +192,7 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
 				return ud.Update(context.Context, writer)
 			},
 		}, dis.Installable())
-	}, context.Stderr, context.Context, "Performing Stack Updates"); err != nil {
+	}, context.Stderr, "Performing Stack Updates"); err != nil {
 		return err
 	}
 
@@ -206,17 +206,17 @@ func (si systemupdate) Run(context wisski_distillery.Context) (err error) {
 					return nil
 				}
 				return item.Update(context.Context, context.Stderr)
-			}, context.Stderr, context.Context, "Updating Component: %s", name); err != nil {
+			}, context.Stderr, "Updating Component: %s", name); err != nil {
 				return errBootstrapComponent.WithMessageF(name).Wrap(err)
 			}
 		}
 		return nil
-	}, context.Stderr, context.Context, "Performing Component Updates"); err != nil {
+	}, context.Stderr, "Performing Component Updates"); err != nil {
 		return err
 	}
 	// TODO: Register cronjob in /etc/cron.d!
 
-	logging.LogMessage(context.Stderr, context.Context, "System has been updated")
+	logging.LogMessage(context.Stderr, "System has been updated")
 	return nil
 }
 
diff --git a/internal/dis/component/exporter/backup.go b/internal/dis/component/exporter/backup.go
index e06719d..f796763 100644
--- a/internal/dis/component/exporter/backup.go
+++ b/internal/dis/component/exporter/backup.go
@@ -64,7 +64,7 @@ func (exporter *Exporter) NewBackup(ctx context.Context, progress io.Writer, des
 		backup.EndTime = time.Now().UTC()
 
 		return nil
-	}, progress, ctx, "Writing backup files")
+	}, progress, "Writing backup files")
 
 	return
 }
@@ -109,7 +109,7 @@ func (backup *Backup) run(ctx context.Context, progress io.Writer, exporter *Exp
 		}
 
 		return nil
-	}, progress, ctx, "Backing up core components")
+	}, progress, "Backing up core components")
 
 	// backup instances
 	logging.LogOperation(func() error {
@@ -164,6 +164,6 @@ func (backup *Backup) run(ctx context.Context, progress io.Writer, exporter *Exp
 		})
 
 		return nil
-	}, progress, ctx, "Creating instance snapshots")
+	}, progress, "Creating instance snapshots")
 
 }
diff --git a/internal/dis/component/exporter/iface.go b/internal/dis/component/exporter/iface.go
index 6750ccc..cd1b2bf 100644
--- a/internal/dis/component/exporter/iface.go
+++ b/internal/dis/component/exporter/iface.go
@@ -56,7 +56,7 @@ func (exporter *Exporter) MakeExport(ctx context.Context, progress io.Writer, ta
 	}
 
 	// determine target paths
-	logging.LogMessage(progress, ctx, "Determining target paths")
+	logging.LogMessage(progress, "Determining target paths")
 	var stagingDir, archivePath string
 	if task.StagingOnly {
 		stagingDir = task.Dest
@@ -76,7 +76,7 @@ func (exporter *Exporter) MakeExport(ctx context.Context, progress io.Writer, ta
 	fmt.Fprintf(progress, "Archive Path:      %s\n", archivePath)
 
 	// create the staging directory
-	logging.LogMessage(progress, ctx, "Creating staging directory")
+	logging.LogMessage(progress, "Creating staging directory")
 	err = fsx.Mkdir(stagingDir, fsx.DefaultDirPerm)
 	if !errors.Is(err, fs.ErrExist) && err != nil {
 		return err
@@ -86,7 +86,7 @@ func (exporter *Exporter) MakeExport(ctx context.Context, progress io.Writer, ta
 	// we need the staging directory to be deleted at the end
 	if !task.StagingOnly {
 		defer func() {
-			logging.LogMessage(progress, ctx, "Removing staging directory")
+			logging.LogMessage(progress, "Removing staging directory")
 			os.RemoveAll(stagingDir)
 		}()
 	}
@@ -125,7 +125,7 @@ func (exporter *Exporter) MakeExport(ctx context.Context, progress io.Writer, ta
 			_, err := sl.Report(report)
 			return err
 		}
-	}, progress, ctx, "Generating %s", Title)
+	}, progress, "Generating %s", Title)
 
 	// if we only requested staging
 	// all that is left is to write the log entry
@@ -155,12 +155,12 @@ func (exporter *Exporter) MakeExport(ctx context.Context, progress io.Writer, ta
 		})
 
 		return err
-	}, progress, ctx, "Writing archive"); err != nil {
+	}, progress, "Writing archive"); err != nil {
 		return err
 	}
 
 	// write out the log entry
-	logging.LogMessage(progress, ctx, "Writing Log Entry")
+	logging.LogMessage(progress, "Writing Log Entry")
 	entry.Path = archivePath
 	entry.Packed = true
 	exporter.Dependencies.ExporterLogger.Add(ctx, entry)
diff --git a/internal/dis/component/exporter/snapshot.go b/internal/dis/component/exporter/snapshot.go
index 506b4ad..0df4076 100644
--- a/internal/dis/component/exporter/snapshot.go
+++ b/internal/dis/component/exporter/snapshot.go
@@ -46,7 +46,7 @@ type Snapshot struct {
 // Snapshot creates a new snapshot of this instance into dest
 func (snapshots *Exporter) NewSnapshot(ctx context.Context, instance *wisski.WissKI, progress io.Writer, desc SnapshotDescription) (snapshot Snapshot) {
 
-	logging.LogMessage(progress, ctx, "Locking instance")
+	logging.LogMessage(progress, "Locking instance")
 	if !instance.Locker().TryLock(ctx) {
 		err := locker.Locked
 		fmt.Fprintln(progress, err)
@@ -57,7 +57,7 @@ func (snapshots *Exporter) NewSnapshot(ctx context.Context, instance *wisski.Wis
 		}
 	}
 	defer func() {
-		logging.LogMessage(progress, ctx, "Unlocking instance")
+		logging.LogMessage(progress, "Unlocking instance")
 		instance.Locker().Unlock(ctx)
 	}()
 
@@ -79,7 +79,7 @@ func (snapshots *Exporter) NewSnapshot(ctx context.Context, instance *wisski.Wis
 
 		snapshot.EndTime = time.Now().UTC()
 		return nil
-	}, progress, ctx, "Writing snapshot files")
+	}, progress, "Writing snapshot files")
 
 	slices.Sort(snapshot.Manifest)
 	return
@@ -89,11 +89,11 @@ func (snapshot *Snapshot) makeParts(ctx context.Context, progress io.Writer, sna
 	if !needsRunning && !snapshot.Description.Keepalive {
 		stack := instance.Barrel().Stack()
 
-		logging.LogMessage(progress, ctx, "Stopping instance")
+		logging.LogMessage(progress, "Stopping instance")
 		snapshot.ErrStop = stack.Down(ctx, progress)
 
 		defer func() {
-			logging.LogMessage(progress, ctx, "Starting instance")
+			logging.LogMessage(progress, "Starting instance")
 			snapshot.ErrStart = stack.Up(ctx, progress)
 		}()
 	}
diff --git a/internal/dis/component/instances/purger/purger.go b/internal/dis/component/instances/purger/purger.go
index 7fd2fad..8755f0c 100644
--- a/internal/dis/component/instances/purger/purger.go
+++ b/internal/dis/component/instances/purger/purger.go
@@ -33,7 +33,7 @@ var errPurgeGeneric = exit.Error{
 // Purge permanently purges an instance from the distillery.
 // The instance does not have to exist; in which case the resources are also deleted.
 func (purger *Purger) Purge(ctx context.Context, out io.Writer, slug string) error {
-	logging.LogMessage(out, ctx, "Checking bookkeeping table")
+	logging.LogMessage(out, "Checking bookkeeping table")
 	instance, err := purger.Dependencies.Instances.WissKI(ctx, slug)
 	if err == instances.ErrWissKINotFound {
 		fmt.Fprintln(out, "Not found in bookkeeping table, assuming defaults")
@@ -44,13 +44,13 @@ func (purger *Purger) Purge(ctx context.Context, out io.Writer, slug string) err
 	}
 
 	// remove docker stack
-	logging.LogMessage(out, ctx, "Stopping and removing docker container")
+	logging.LogMessage(out, "Stopping and removing docker container")
 	if err := instance.Barrel().Stack().Down(ctx, out); err != nil {
 		fmt.Fprintln(out, err)
 	}
 
 	// remove the filesystem
-	logging.LogMessage(out, ctx, "Removing from filesystem %s", instance.FilesystemBase)
+	logging.LogMessage(out, "Removing from filesystem %s", instance.FilesystemBase)
 	if err := os.RemoveAll(instance.FilesystemBase); err != nil {
 		fmt.Fprintln(out, err)
 	}
@@ -59,7 +59,7 @@ func (purger *Purger) Purge(ctx context.Context, out io.Writer, slug string) err
 	if err := logging.LogOperation(func() error {
 		domain := instance.Domain()
 		for _, pc := range purger.Dependencies.Provisionable {
-			logging.LogMessage(out, ctx, "Purging %s resources", pc.Name())
+			logging.LogMessage(out, "Purging %s resources", pc.Name())
 			err := pc.Purge(ctx, instance.Instance, domain)
 			if err != nil {
 				return err
@@ -67,18 +67,18 @@ func (purger *Purger) Purge(ctx context.Context, out io.Writer, slug string) err
 		}
 
 		return nil
-	}, out, ctx, "Purging instance-specific resources"); err != nil {
+	}, out, "Purging instance-specific resources"); err != nil {
 		return errPurgeGeneric.WithMessageF(slug, err)
 	}
 
 	// remove from bookkeeping
-	logging.LogMessage(out, ctx, "Removing instance from bookkeeping")
+	logging.LogMessage(out, "Removing instance from bookkeeping")
 	if err := instance.Bookkeeping().Delete(ctx); err != nil {
 		fmt.Fprintln(out, err)
 	}
 
 	// remove the filesystem
-	logging.LogMessage(out, ctx, "Remove lock data")
+	logging.LogMessage(out, "Remove lock data")
 	if instance.Locker().TryUnlock(ctx) {
 		fmt.Fprintln(out, "instance was not locked")
 	}
diff --git a/internal/dis/component/provision/provision.go b/internal/dis/component/provision/provision.go
index 7e1363b..231866a 100644
--- a/internal/dis/component/provision/provision.go
+++ b/internal/dis/component/provision/provision.go
@@ -30,7 +30,7 @@ var ErrInstanceAlreadyExists = errors.New("instance with provided slug already e
 // Provision provisions a new docker compose instance.
 func (pv *Provision) Provision(progress io.Writer, ctx context.Context, flags ProvisionFlags) (*wisski.WissKI, error) {
 	// check that it doesn't already exist
-	logging.LogMessage(progress, ctx, "Provisioning new WissKI instance %s", flags.Slug)
+	logging.LogMessage(progress, "Provisioning new WissKI instance %s", flags.Slug)
 	if exists, err := pv.Dependencies.Instances.Has(ctx, flags.Slug); err != nil || exists {
 		return nil, ErrInstanceAlreadyExists
 	}
@@ -42,7 +42,7 @@ func (pv *Provision) Provision(progress io.Writer, ctx context.Context, flags Pr
 	}
 
 	// check that the base directory does not exist
-	logging.LogMessage(progress, ctx, "Checking that base directory %s does not exist", instance.FilesystemBase)
+	logging.LogMessage(progress, "Checking that base directory %s does not exist", instance.FilesystemBase)
 	if fsx.IsDirectory(instance.FilesystemBase) {
 		return nil, ErrInstanceAlreadyExists
 	}
@@ -54,7 +54,7 @@ func (pv *Provision) Provision(progress io.Writer, ctx context.Context, flags Pr
 		}
 
 		return nil
-	}, progress, ctx, "Updating bookkeeping database"); err != nil {
+	}, progress, "Updating bookkeeping database"); err != nil {
 		return nil, err
 	}
 
@@ -62,7 +62,7 @@ func (pv *Provision) Provision(progress io.Writer, ctx context.Context, flags Pr
 	if err := logging.LogOperation(func() error {
 		domain := instance.Domain()
 		for _, pc := range pv.Dependencies.Provisionable {
-			logging.LogMessage(progress, ctx, "Provisioning %s resources", pc.Name())
+			logging.LogMessage(progress, "Provisioning %s resources", pc.Name())
 			err := pc.Provision(ctx, instance.Instance, domain)
 			if err != nil {
 				return err
@@ -70,19 +70,19 @@ func (pv *Provision) Provision(progress io.Writer, ctx context.Context, flags Pr
 		}
 
 		return nil
-	}, progress, ctx, "Provisioning instance-specific resources"); err != nil {
+	}, progress, "Provisioning instance-specific resources"); err != nil {
 		return nil, err
 	}
 
 	// run the provision script
 	if err := logging.LogOperation(func() error {
 		return instance.Provisioner().Provision(ctx, progress)
-	}, progress, ctx, "Running setup scripts"); err != nil {
+	}, progress, "Running setup scripts"); err != nil {
 		return nil, err
 	}
 
 	// start the container!
-	logging.LogMessage(progress, ctx, "Starting Container")
+	logging.LogMessage(progress, "Starting Container")
 	if err := instance.Barrel().Stack().Up(ctx, progress); err != nil {
 		return nil, err
 	}
diff --git a/internal/dis/component/sql/update.go b/internal/dis/component/sql/update.go
index 59467e4..44c69fa 100644
--- a/internal/dis/component/sql/update.go
+++ b/internal/dis/component/sql/update.go
@@ -52,7 +52,7 @@ func (sql *SQL) Update(ctx context.Context, progress io.Writer) error {
 		if err := sql.unsafeWaitShell(ctx); err != nil {
 			return err
 		}
-		logging.LogMessage(progress, ctx, "Creating administrative user")
+		logging.LogMessage(progress, "Creating administrative user")
 		{
 			username := sql.Config.SQL.AdminUsername
 			password := sql.Config.SQL.AdminPassword
@@ -63,7 +63,7 @@ func (sql *SQL) Update(ctx context.Context, progress io.Writer) error {
 	}
 
 	// create the admin user
-	logging.LogMessage(progress, ctx, "Creating sql database")
+	logging.LogMessage(progress, "Creating sql database")
 	{
 		if !sqlx.IsSafeDatabaseLiteral(sql.Config.SQL.Database) {
 			return errSQLUnsafeDatabaseName
@@ -75,7 +75,7 @@ func (sql *SQL) Update(ctx context.Context, progress io.Writer) error {
 	}
 
 	// wait for the database to come up
-	logging.LogMessage(progress, ctx, "Waiting for database update to be complete")
+	logging.LogMessage(progress, "Waiting for database update to be complete")
 	if err := sql.WaitQueryTable(ctx); err != nil {
 		return err
 	}
@@ -84,7 +84,7 @@ func (sql *SQL) Update(ctx context.Context, progress io.Writer) error {
 	return logging.LogOperation(func() error {
 		for _, table := range sql.Dependencies.Tables {
 			info := table.TableInfo()
-			logging.LogMessage(progress, ctx, "migrating %q table", table.Name)
+			logging.LogMessage(progress, "migrating %q table", table.Name)
 			db, err := sql.queryTable(ctx, false, info.Name)
 			if err != nil {
 				return errSQLUnableToMigrate.WithMessageF(table.Name, "unable to access table")
@@ -97,5 +97,5 @@ func (sql *SQL) Update(ctx context.Context, progress io.Writer) error {
 			}
 		}
 		return nil
-	}, progress, ctx, "migrating database tables")
+	}, progress, "migrating database tables")
 }
diff --git a/internal/dis/component/triplestore/update.go b/internal/dis/component/triplestore/update.go
index e764740..99f1221 100644
--- a/internal/dis/component/triplestore/update.go
+++ b/internal/dis/component/triplestore/update.go
@@ -13,12 +13,12 @@ import (
 var errTriplestoreFailedSecurity = errors.New("failed to enable triplestore security: request did not succeed with HTTP 200 OK")
 
 func (ts Triplestore) Update(ctx context.Context, progress io.Writer) error {
-	logging.LogMessage(progress, ctx, "Waiting for Triplestore")
+	logging.LogMessage(progress, "Waiting for Triplestore")
 	if err := ts.Wait(ctx); err != nil {
 		return err
 	}
 
-	logging.LogMessage(progress, ctx, "Resetting admin user password")
+	logging.LogMessage(progress, "Resetting admin user password")
 	{
 		res, err := ts.OpenRaw(ctx, "PUT", "/rest/security/users/"+ts.Config.TS.AdminUsername, TriplestoreUserPayload{
 			Password: ts.Config.TS.AdminPassword,
@@ -43,14 +43,14 @@ func (ts Triplestore) Update(ctx context.Context, progress io.Writer) error {
 		case http.StatusUnauthorized:
 			// a password is needed => security is already enabled.
 			// the password may or may not work, but that's a problem for later
-			logging.LogMessage(progress, ctx, "Security is already enabled")
+			logging.LogMessage(progress, "Security is already enabled")
 			return nil
 		default:
 			return fmt.Errorf("failed to create triplestore user: %s", err)
 		}
 	}
 
-	logging.LogMessage(progress, ctx, "Enabling Triplestore security")
+	logging.LogMessage(progress, "Enabling Triplestore security")
 	{
 		res, err := ts.OpenRaw(ctx, "POST", "/rest/security", true, "", "")
 		if err != nil {
diff --git a/pkg/logging/log.go b/pkg/logging/log.go
index 293c13e..76ae243 100644
--- a/pkg/logging/log.go
+++ b/pkg/logging/log.go
@@ -1,7 +1,6 @@
 package logging
 
 import (
-	"context"
 	"fmt"
 	"io"
 	"strings"
@@ -10,8 +9,8 @@ import (
 )
 
 // LogOperation logs a message that is displayed to the user, and then increases the log indent level.
-func LogOperation(operation func() error, progress io.Writer, ctx context.Context, format string, args ...interface{}) error {
-	logOperation(progress, ctx, getIndent(progress), format, args...)
+func LogOperation(operation func() error, progress io.Writer, format string, args ...interface{}) error {
+	logOperation(progress, getIndent(progress), format, args...)
 	incIndent(progress)
 	defer decIndent(progress)
 
@@ -19,11 +18,11 @@ func LogOperation(operation func() error, progress io.Writer, ctx context.Contex
 }
 
 // LogMessage logs a message that is displayed to the user
-func LogMessage(progress io.Writer, ctx context.Context, format string, args ...interface{}) (int, error) {
-	return logOperation(progress, ctx, getIndent(progress), format, args...)
+func LogMessage(progress io.Writer, format string, args ...interface{}) (int, error) {
+	return logOperation(progress, getIndent(progress), format, args...)
 }
 
-func logOperation(progress io.Writer, ctx context.Context, indent int, format string, args ...interface{}) (int, error) {
+func logOperation(progress io.Writer, indent int, format string, args ...interface{}) (int, error) {
 	message := "\033[1m" + strings.Repeat(" ", indent+1) + "=> " + format + "\033[0m\n"
 	if !streamIsTerminal(progress) {
 		message = " => " + format + "\n"