What causes "storage '%s' does not support purging" in jaegertracing/jaeger?

Use a storage backend whose factory implements storage.Purger when purge is needed

storage '%s' does not support purging

Error message

storage '%s' does not support purging

What it means

GetPurger retrieves the named trace storage factory and asserts it implements storage.Purger, used by the purge-all-data operation (e.g. jaeger-all-in-one purge tooling). Backends that have no purge implementation fail this Go type assertion and produce this error.

Source

Thrown at cmd/jaeger/internal/extension/jaegerstorage/extension.go:96

	}

	ssf, ok := f.(storage.SamplingStoreFactory)
	if !ok {
		return nil, fmt.Errorf("storage '%s' does not support sampling store", name)
	}

	return ssf, nil
}

func GetPurger(name string, host component.Host) (storage.Purger, error) {
	f, err := getStorageFactory(name, host)
	if err != nil {
		return nil, err
	}

	purger, ok := f.(storage.Purger)
	if !ok {
		return nil, fmt.Errorf("storage '%s' does not support purging", name)
	}

	return purger, nil
}

func findExtension(host component.Host) (Extension, error) {
	var id component.ID
	var comp component.Component
	for i, ext := range host.GetExtensions() {
		if i.Type() == componentType {
			id, comp = i, ext
			break
		}
	}
	if comp == nil {
		return nil, fmt.Errorf(
			"cannot find extension '%s' (make sure it's defined earlier in the config)",
			componentType,

View on GitHub (pinned to 806f444784)

Solutions

Use a storage backend whose factory implements storage.Purger when purge is needed
Skip/remove the purge operation for backends without purge support
Implement storage.Purger on a custom factory to add purge capability

Example fix

// before: purge attempted against unsupported backend
purger, err := jaegerstorage.GetPurger("my-backend", host)
// after: guard by capability first
f, _ := jaegerstorage.GetTraceStoreFactory("my-backend", host)
if _, ok := f.(storage.Purger); !ok {
    // skip purge: backend does not support it
    return nil
}
purger, err := jaegerstorage.GetPurger("my-backend", host)

Defensive patterns

Strategy: type-guard

Validate before calling

f, err := jaegerstorage.GetTraceStoreFactory(name, host)
if err == nil {
    if _, ok := f.(storage.Purger); !ok {
        // purge not supported by this backend
    }
}

Type guard

func supportsPurge(f tracestore.Factory) bool {
    _, ok := f.(storage.Purger)
    return ok
}

Try / catch

purger, err := jaegerstorage.GetPurger(name, host)
if err != nil {
    if strings.Contains(err.Error(), "does not support purging") {
        return errUnsupportedPurge
    }
    return err
}

Prevention

Check storage.Purger support before exposing purge endpoints/tooling
Restrict purge operations to backend types with purge implementations
Document per-backend purge support in deployment docs

When it happens

Trigger: Calling jaegerstorage.GetPurger(name, host) for a storage whose tracestore.Factory does not implement storage.Purger — the ok check on the type assertion fails and the error is returned.

Common situations: Attempting to purge data in a storage backend that does not support the purge API (e.g. a backend lacking bulk delete), typically from the all-in-one binary's purge endpoint or test harness.

Related errors

AI-assisted analysis of jaegertracing/jaeger@806f444784 (2026-09-01). Data as JSON: /api/errors/b6c9b1a6bb98bbbf. Report an issue: GitHub.