weaviate/weaviate · error

frequencyWhilePropagating too large: %d ms exceeds max %d ms

Error message

frequencyWhilePropagating too large: %d ms exceeds max %d ms

What it means

Weaviate rejects frequencyWhilePropagating values larger than MaxDurationMillis (math.MaxInt64 / time.Millisecond ≈ 9.2e12 ms, about 292 years). Any larger millisecond value would overflow time.Duration when converted, so validation rejects it up front.

Source

Thrown at entities/replication/async_config_validation.go:73

				return fmt.Errorf("hashtreeHeight: %w", err)
			}
			return nil
		}},
		{&cfg.Frequency, func(v int64) error {
			if v < 0 {
				return fmt.Errorf("frequency must be >= 0")
			}
			if v > MaxDurationMillis {
				return fmt.Errorf("frequency too large: %d ms exceeds max %d ms", v, MaxDurationMillis)
			}
			return nil
		}},
		{&cfg.FrequencyWhilePropagating, func(v int64) error {
			if v < 0 {
				return fmt.Errorf("frequencyWhilePropagating must be >= 0")
			}
			if v > MaxDurationMillis {
				return fmt.Errorf("frequencyWhilePropagating too large: %d ms exceeds max %d ms", v, MaxDurationMillis)
			}
			return nil
		}},
		{&cfg.LoggingFrequency, func(v int64) error {
			if time.Duration(v)*time.Second <= 0 {
				return fmt.Errorf("loggingFrequency must be > 0")
			}
			return nil
		}},
		{&cfg.DiffBatchSize, func(v int64) error {
			if err := validateIntRange(int(v), MinDiffBatchSize, MaxDiffBatchSize); err != nil {
				return fmt.Errorf("diffBatchSize: %w", err)
			}
			return nil
		}},
		{&cfg.DiffPerNodeTimeout, func(v int64) error {
			if time.Duration(v)*time.Second <= 0 {
				return fmt.Errorf("diffPerNodeTimeout must be > 0")

View on GitHub (pinned to 75aa4b6d11)

Solutions

1. Reduce frequencyWhilePropagating to a realistic millisecond interval (e.g. 1000 for 1 second).
2. If the value came from a time.Duration, convert with d.Milliseconds() before sending.
3. Omit the field to use the server default.

Example fix

// before (nanoseconds passed as ms)
frequencyWhilePropagating: 5000000000
// after
frequencyWhilePropagating: int64((5 * time.Second).Milliseconds()) // 5000

const maxDurationMillis = int64(math.MaxInt64 / int64(time.Millisecond))
func validFreqMs(v *int64) bool { return v == nil || (*v >= 0 && *v <= maxDurationMillis) }

func fitsInDuration(v int64) bool { return v <= math.MaxInt64/int64(time.Millisecond) }

if err := doCreate(ctx, class); err != nil && strings.Contains(err.Error(), "frequencyWhilePropagating too large") {
	return fmt.Errorf("reduce frequencyWhilePropagating: %w", err)
}

When it happens

Trigger: Posting a schema class with frequencyWhilePropagating set to an astronomically large number, e.g. 1e19 ms, which no longer fits into a Go time.Duration.

Common situations: Unit confusion (passing nanoseconds or an unconverted time.Duration nanosecond count as milliseconds), or integer overflow in the caller's own code producing a huge value.

Understand the failure class

Background: "Invalid value" and "allowed values are" config errors: what your library rejected and how to fix it — this error's family across 41 libraries.

Related errors

• frequencyWhilePropagating must be >= 0
• loggingFrequency must be > 0
• diffPerNodeTimeout must be > 0
• prePropagationTimeout must be > 0
• propagationTimeout must be > 0

AI-assisted analysis of weaviate/weaviate@75aa4b6d11 (2026-09-04). Data as JSON: /api/errors/e55d10258b0f5bf7. Report an issue: GitHub.