diff --git a/go.mod b/go.mod
index 0ff5100a661..a7e586e7824 100644
--- a/go.mod
+++ b/go.mod
@@ -22,7 +22,7 @@ require (
 	github.com/golang/snappy v0.0.4
 	github.com/google/gopacket v1.1.19
 	github.com/gorilla/mux v1.8.1
-	github.com/grafana/dskit v0.0.0-20241011202249-8e7752e59bab
+	github.com/grafana/dskit v0.0.0-20241013223235-619c42124e93
 	github.com/grafana/e2e v0.1.2-0.20240118170847-db90b84177fc
 	github.com/hashicorp/golang-lru v1.0.2 // indirect
 	github.com/json-iterator/go v1.1.12
diff --git a/go.sum b/go.sum
index 67aaa10bb4f..0c985fcd2ce 100644
--- a/go.sum
+++ b/go.sum
@@ -1256,8 +1256,8 @@ github.com/grafana-tools/sdk v0.0.0-20220919052116-6562121319fc h1:PXZQA2WCxe85T
 github.com/grafana-tools/sdk v0.0.0-20220919052116-6562121319fc/go.mod h1:AHHlOEv1+GGQ3ktHMlhuTUwo3zljV3QJbC0+8o2kn+4=
 github.com/grafana/alerting v0.0.0-20240926144415-27f4e81b4b6b h1:UO4mv94pG1kzKCgBKh20TXdACBCAK2vYjV3Q2MlcpEQ=
 github.com/grafana/alerting v0.0.0-20240926144415-27f4e81b4b6b/go.mod h1:GMLi6d09Xqo96fCVUjNk//rcjP5NKEdjOzfWIffD5r4=
-github.com/grafana/dskit v0.0.0-20241011202249-8e7752e59bab h1:jrQwxBzwH5bjLUWXpaoTbq6BenhCCo2EjBLX10Hm0d4=
-github.com/grafana/dskit v0.0.0-20241011202249-8e7752e59bab/go.mod h1:SPLNCARd4xdjCkue0O6hvuoveuS1dGJjDnfxYe405YQ=
+github.com/grafana/dskit v0.0.0-20241013223235-619c42124e93 h1:MgJ51Z/pgKDx9t0UaenBXp4u2Q80yH/yLNvQ5Oe9OQQ=
+github.com/grafana/dskit v0.0.0-20241013223235-619c42124e93/go.mod h1:SPLNCARd4xdjCkue0O6hvuoveuS1dGJjDnfxYe405YQ=
 github.com/grafana/e2e v0.1.2-0.20240118170847-db90b84177fc h1:BW+LjKJDz0So5LI8UZfW5neWeKpSkWqhmGjQFzcFfLM=
 github.com/grafana/e2e v0.1.2-0.20240118170847-db90b84177fc/go.mod h1:JVmqPBe8A/pZWwRoJW5ZjyALeY5OXMzPl7LrVXOdZAI=
 github.com/grafana/franz-go v0.0.0-20241009101240-fa97d35e871f h1:nsrRsQHfpqs6dWxErIOS3gD6R20H/9XM0ItykNtBFW8=
diff --git a/vendor/github.com/grafana/dskit/concurrency/worker.go b/vendor/github.com/grafana/dskit/concurrency/worker.go
index f40f0334800..72acc7dd0fe 100644
--- a/vendor/github.com/grafana/dskit/concurrency/worker.go
+++ b/vendor/github.com/grafana/dskit/concurrency/worker.go
@@ -1,5 +1,9 @@
 package concurrency
 
+import (
+	"sync"
+)
+
 // NewReusableGoroutinesPool creates a new worker pool with the given size.
 // These workers will run the workloads passed through Go() calls.
 // If all workers are busy, Go() will spawn a new goroutine to run the workload.
@@ -18,12 +22,23 @@ func NewReusableGoroutinesPool(size int) *ReusableGoroutinesPool {
 }
 
 type ReusableGoroutinesPool struct {
-	jobs chan func()
+	jobsMu sync.RWMutex
+	closed bool
+	jobs   chan func()
 }
 
 // Go will run the given function in a worker of the pool.
 // If all workers are busy, Go() will spawn a new goroutine to run the workload.
 func (p *ReusableGoroutinesPool) Go(f func()) {
+	p.jobsMu.RLock()
+	defer p.jobsMu.RUnlock()
+
+	// If the pool is closed, run the function in a new goroutine.
+	if p.closed {
+		go f()
+		return
+	}
+
 	select {
 	case p.jobs <- f:
 	default:
@@ -32,7 +47,12 @@ func (p *ReusableGoroutinesPool) Go(f func()) {
 }
 
 // Close stops the workers of the pool.
-// No new Do() calls should be performed after calling Close().
+// No new Go() calls should be performed after calling Close().
 // Close does NOT wait for all jobs to finish, it is the caller's responsibility to ensure that in the provided workloads.
 // Close is intended to be used in tests to ensure that no goroutines are leaked.
-func (p *ReusableGoroutinesPool) Close() { close(p.jobs) }
+func (p *ReusableGoroutinesPool) Close() {
+	p.jobsMu.Lock()
+	defer p.jobsMu.Unlock()
+	p.closed = true
+	close(p.jobs)
+}
diff --git a/vendor/github.com/grafana/dskit/spanlogger/spanlogger.go b/vendor/github.com/grafana/dskit/spanlogger/spanlogger.go
index 8daad995c95..f32bce6f6bc 100644
--- a/vendor/github.com/grafana/dskit/spanlogger/spanlogger.go
+++ b/vendor/github.com/grafana/dskit/spanlogger/spanlogger.go
@@ -1,8 +1,13 @@
+// Provenance-includes-location: https://github.com/go-kit/log/blob/main/value.go
+// Provenance-includes-license: MIT
+// Provenance-includes-copyright: Go kit
+
 package spanlogger
 
 import (
 	"context"
 	"runtime"
+	"strconv"
 	"strings"
 
 	"go.uber.org/atomic" // Really just need sync/atomic but there is a lint rule preventing it.
@@ -163,9 +168,6 @@ func (s *SpanLogger) getLogger() log.Logger {
 		logger = log.With(logger, "trace_id", traceID)
 	}
 
-	// Replace the default valuer for the 'caller' attribute with one that gets the caller of the methods in this file.
-	logger = log.With(logger, "caller", spanLoggerAwareCaller())
-
 	// If the value has been set by another goroutine, fetch that other value and discard the one we made.
 	if !s.logger.CompareAndSwap(nil, &logger) {
 		pLogger := s.logger.Load()
@@ -188,46 +190,64 @@ func (s *SpanLogger) SetSpanAndLogTag(key string, value interface{}) {
 	s.logger.Store(&wrappedLogger)
 }
 
-// spanLoggerAwareCaller is like log.Caller, but ensures that the caller information is
-// that of the caller to SpanLogger, not SpanLogger itself.
-func spanLoggerAwareCaller() log.Valuer {
-	valuer := atomic.NewPointer[log.Valuer](nil)
-
+// Caller is like github.com/go-kit/log's Caller, but ensures that the caller information is
+// that of the caller to SpanLogger (if SpanLogger is being used), not SpanLogger itself.
+//
+// defaultStackDepth should be the number of stack frames to skip by default, as would be
+// passed to github.com/go-kit/log's Caller method.
+func Caller(defaultStackDepth int) log.Valuer {
 	return func() interface{} {
-		// If we've already determined the correct stack depth, use it.
-		existingValuer := valuer.Load()
-		if existingValuer != nil {
-			return (*existingValuer)()
-		}
-
-		// We haven't been called before, determine the correct stack depth to
-		// skip the configured logger's internals and the SpanLogger's internals too.
-		//
-		// Note that we can't do this in spanLoggerAwareCaller() directly because we
-		// need to do this when invoked by the configured logger - otherwise we cannot
-		// measure the stack depth of the logger's internals.
-
-		stackDepth := 3 // log.DefaultCaller uses a stack depth of 3, so start searching for the correct stack depth there.
+		stackDepth := defaultStackDepth + 1 // +1 to account for this method.
+		seenSpanLogger := false
+		pc := make([]uintptr, 1)
 
 		for {
-			_, file, _, ok := runtime.Caller(stackDepth)
+			function, file, line, ok := caller(stackDepth, pc)
 			if !ok {
 				// We've run out of possible stack frames. Give up.
-				valuer.Store(&unknownCaller)
-				return unknownCaller()
+				return "<unknown>"
 			}
 
-			if strings.HasSuffix(file, "spanlogger/spanlogger.go") {
-				stackValuer := log.Caller(stackDepth + 2) // Add one to skip the stack frame for the SpanLogger method, and another to skip the stack frame for the valuer which we'll invoke below.
-				valuer.Store(&stackValuer)
-				return stackValuer()
+			// If we're in a SpanLogger method, we need to continue searching.
+			//
+			// Matching on the exact function name like this does mean this will break if we rename or refactor SpanLogger, but
+			// the tests should catch this. In the worst case scenario, we'll log incorrect caller information, which isn't the
+			// end of the world.
+			if function == "github.com/grafana/dskit/spanlogger.(*SpanLogger).Log" || function == "github.com/grafana/dskit/spanlogger.(*SpanLogger).DebugLog" {
+				seenSpanLogger = true
+				stackDepth++
+				continue
 			}
 
-			stackDepth++
+			// We need to check for go-kit/log stack frames like this because using log.With, log.WithPrefix or log.WithSuffix
+			// (including the various level methods like level.Debug, level.Info etc.) to wrap a SpanLogger introduce an
+			// additional context.Log stack frame that calls into the SpanLogger. This is because the use of SpanLogger
+			// as the logger means the optimisation to avoid creating a new logger in
+			// https://github.com/go-kit/log/blob/c7bf81493e581feca11e11a7672b14be3591ca43/log.go#L141-L146 used by those methods
+			// can't be used, and so the SpanLogger is wrapped in a new logger.
+			if seenSpanLogger && function == "github.com/go-kit/log.(*context).Log" {
+				stackDepth++
+				continue
+			}
+
+			return formatCallerInfoForLog(file, line)
 		}
 	}
 }
 
-var unknownCaller log.Valuer = func() interface{} {
-	return "<unknown>"
+// caller is like runtime.Caller, but modified to allow reuse of the uintptr slice and return the function name.
+func caller(stackDepth int, pc []uintptr) (function string, file string, line int, ok bool) {
+	n := runtime.Callers(stackDepth+1, pc)
+	if n < 1 {
+		return "", "", 0, false
+	}
+
+	frame, _ := runtime.CallersFrames(pc).Next()
+	return frame.Function, frame.File, frame.Line, frame.PC != 0
+}
+
+// This is based on github.com/go-kit/log's Caller, but modified for use by Caller above.
+func formatCallerInfoForLog(file string, line int) string {
+	idx := strings.LastIndexByte(file, '/')
+	return file[idx+1:] + ":" + strconv.Itoa(line)
 }
diff --git a/vendor/modules.txt b/vendor/modules.txt
index c295f412ba8..aa02a36a6e4 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -611,7 +611,7 @@ github.com/grafana/alerting/receivers/webex
 github.com/grafana/alerting/receivers/webhook
 github.com/grafana/alerting/receivers/wecom
 github.com/grafana/alerting/templates
-# github.com/grafana/dskit v0.0.0-20241011202249-8e7752e59bab
+# github.com/grafana/dskit v0.0.0-20241013223235-619c42124e93
 ## explicit; go 1.21
 github.com/grafana/dskit/backoff
 github.com/grafana/dskit/ballast