chore(sender): simplify error handling

[glinton]

The former error function in Sender would somehow swallow errors and not get them onto the channel. This method ensures that every error is delivered.

Tested with the following test:

func TestError(t *testing.T) {
	var (
		eChan   = make(chan error, 1)
		done    = make(chan struct{})
		sender  = &Sender{Errors: eChan}
		ErrNone = errors.New("thing")
		max     = 5
	)

	go func() {
		for i := 0; i < max; i++ {
			err := <-eChan
			assert.Equal(t, ErrNone, err)
		}
		close(eChan)
		done <- struct{}{}
	}()

	for i := 0; i < max; i++ {
		sender.error(ErrNone)

		// swap the following with the above call to [sender.error] for a working solution. 
		//     sender.Errors <- ErrNone
	}

	// if not running with timeout, close the channel. if working properly, this would cause a panic.
	// due to closing closed chan.
	//    close(eChan)
	<-done
}

Note:
After a discussion with @aaronfuj, I have to note that this breaks compatibility, specifically for clients that aren't reading from the error channel (causes a deadlock). If the intention of the error channel is best-effort delivery with no guarantees, go ahead and close this pr.

[aaronfuj]

Based on my understanding of error() and the use/purpose of this function is to submit a 'best effort' error to the channel for consumption. If there is no consumer (or a slow consumer) of the error channel, this would result in a blocking of the rest of execution until the errors had been read.

I was able to test/validate that via adjusting the error channel in your example test, i.e. eChan where if you set it to a buffered value >= max, this unit test should always complete successfully. The reason it is "failing" or dropping errors in the test is because the goroutine is not keeping up with the same rate as submission (likely due to the extra assertion code and having to read from the channel itself).

Therefore I think this is workin by design (despite the intent not being commented). Adjusting the code with the proposed change would introduce flow control or backpressure based on the errors channel, which may not be backwards compatible with existing implementations.