What causes "listener cannot be nil" in m1k1o/neko?

Construct and pass a valid types.SampleListener implementation before calling AddListener

listener cannot be nil

Error message

listener cannot be nil

What it means

StreamSinkManagerCtx.AddListener rejects a nil types.SampleListener with 'listener cannot be nil'. The library requires a concrete listener because it would later call its callback on each sample; a nil entry would panic at emit time. This is an input-validation guard.

Source

Thrown at server/internal/capture/streamsink.go:215

func (manager *StreamSinkManagerCtx) removeListener(listener types.SampleListener) {
	ptr := reflect.ValueOf(listener).Pointer()

	manager.listenersMu.Lock()
	delete(manager.listeners, ptr)
	delete(manager.listenersKf, ptr) //	if it's a keyframe listener, remove it too
	manager.listenersMu.Unlock()

	manager.logger.Debug().Interface("ptr", ptr).Msgf("removing listener")
	manager.currentListeners.Set(float64(manager.ListenersCount()))
}

func (manager *StreamSinkManagerCtx) AddListener(listener types.SampleListener) error {
	manager.mu.Lock()
	defer manager.mu.Unlock()

	if listener == nil {
		return errors.New("listener cannot be nil")
	}

	// start if stopped
	if err := manager.start(); err != nil {
		return err
	}

	// add listener
	manager.addListener(listener)

	return nil
}

func (manager *StreamSinkManagerCtx) RemoveListener(listener types.SampleListener) error {
	manager.mu.Lock()
	defer manager.mu.Unlock()

	if listener == nil {

View on GitHub (pinned to b0f01cedea)

Solutions

Construct and pass a valid types.SampleListener implementation before calling AddListener
Guard call sites: only invoke AddListener when the listener variable is non-nil
Return an application-level error instead of adding when the listener is unavailable

Example fix

// before
var listener types.SampleListener
manager.AddListener(listener) // listener cannot be nil
// after
listener := NewStreamListener()
if listener != nil {
    if err := manager.AddListener(listener); err != nil { return err }
}

Defensive patterns

Strategy: validation

Validate before calling

if listener == nil {
    return errors.New("cannot add a nil stream listener")
}
if err := manager.AddListener(listener); err != nil { return err }

Type guard

func listenerValid(l types.SampleListener) bool { return l != nil }

Try / catch

if err := manager.AddListener(listener); err != nil {
    if err.Error() == "listener cannot be nil" {
        return fmt.Errorf("listener not initialized: %w", err)
    }
    return err
}

Prevention

Initialize listener variables at declaration or constructor time
Never pass function parameters straight to AddListener without a nil check
Store added listeners so later Remove/Move calls have valid references
Run nil-check linting (e.g. staticcheck) on listener call sites

When it happens

Trigger: Calling AddListener(nil), or passing an uninitialized/zero-valued interface variable of types.SampleListener.

Common situations: Struct field holding the listener never assigned; a function parameter defaulted to nil; refactors where the concrete listener creation was removed but the call remained.

Related errors

AI-assisted analysis of m1k1o/neko@b0f01cedea (2026-09-01). Data as JSON: /api/errors/2c7ebcb184782ce7. Report an issue: GitHub.