mirror of
https://github.com/open-telemetry/opentelemetry-go.git
synced 2024-12-14 10:13:10 +02:00
5a728db2e9
* Move connection logic into grpcConnection object
If we will need to maintain more than one connection in future, this
splitting off will come in handy.
Co-authored-by: Stefan Prisca <stefan.prisca@gmail.com>
* Make another channel a signal channel
There is another channel that serves as a one-time signal, where
channel's data type does not matter.
* Reorder and document connection members
This is to make clear that the lock is guarding only the connection
since it can be changed by multiple goroutines, and other members are
either atomic or read-only.
* Move stop signal into connection
The stop channel was rather useless on the exporter side - the primary
reason for existence of this channel is to stop a background
reconnecting goroutine. Since the goroutine lives entirely within
grpcConnection object, move the stop channel here. Also expose a
function to unify the stop channel with the context cancellation, so
exporter can use it without knowing anything about stop channels.
Also make export functions a bit more consistent.
* Do not run reconnection routine when being stopped too
It's possible that both disconnected channel and stop channel will be
triggered around the same time, so the goroutine is as likely to start
reconnecting as to return from the goroutine. Make sure we return if
the stop channel is closed.
* Nil clients on connection error
Set clients to nil on connection error, so we don't try to send the
data over a bad connection, but return a "no client" error
immediately.
* Do not call new connection handler within critical section
It's rather risky to call a callback coming from outside within a
critical section. Move it out.
* Add context parameter to connection routines
Connecting to the collector may also take its time, so it can be
useful in some cases to pass a context with a deadline. Currently we
just pass a background context, so this commit does not really change
any behavior. The follow-up commits will make a use of it, though.
* Add context parameter to NewExporter and Start
It makes it possible to limit the time spent on connecting to the
collector.
* Stop connecting on shutdown
Dialling to grpc service ignored the closing of the stop channel, but
this can be easily changed.
* Close connection after background is shut down
That way we can make sure that there won't be a window between closing
a connection and waiting for the background goroutine to return, where
the new connection could be established.
* Remove unnecessary nil check
This member is never nil, unless the Exporter is created like
&Exporter{}, which is not a thing we support anyway.
* Update changelog
Co-authored-by: Stefan Prisca <stefan.prisca@gmail.com>
116 lines
3.0 KiB
Go
116 lines
3.0 KiB
Go
// Copyright The OpenTelemetry Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package otlp
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestExporterShutdownHonorsTimeout(t *testing.T) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
|
|
defer cancel()
|
|
|
|
e := NewUnstartedExporter()
|
|
orig := e.cc.closeBackgroundConnectionDoneCh
|
|
e.cc.closeBackgroundConnectionDoneCh = func(ch chan struct{}) {
|
|
go func() {
|
|
<-ctx.Done()
|
|
orig(ch)
|
|
}()
|
|
}
|
|
if err := e.Start(ctx); err != nil {
|
|
t.Fatalf("failed to start exporter: %v", err)
|
|
}
|
|
|
|
innerCtx, innerCancel := context.WithTimeout(ctx, time.Microsecond)
|
|
if err := e.Shutdown(innerCtx); err == nil {
|
|
t.Error("expected context DeadlineExceeded error, got nil")
|
|
} else if !errors.Is(err, context.DeadlineExceeded) {
|
|
t.Errorf("expected context DeadlineExceeded error, got %v", err)
|
|
}
|
|
innerCancel()
|
|
}
|
|
|
|
func TestExporterShutdownHonorsCancel(t *testing.T) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
|
|
defer cancel()
|
|
|
|
e := NewUnstartedExporter()
|
|
orig := e.cc.closeBackgroundConnectionDoneCh
|
|
e.cc.closeBackgroundConnectionDoneCh = func(ch chan struct{}) {
|
|
go func() {
|
|
<-ctx.Done()
|
|
orig(ch)
|
|
}()
|
|
}
|
|
if err := e.Start(ctx); err != nil {
|
|
t.Fatalf("failed to start exporter: %v", err)
|
|
}
|
|
|
|
var innerCancel context.CancelFunc
|
|
ctx, innerCancel = context.WithCancel(ctx)
|
|
innerCancel()
|
|
if err := e.Shutdown(ctx); err == nil {
|
|
t.Error("expected context canceled error, got nil")
|
|
} else if !errors.Is(err, context.Canceled) {
|
|
t.Errorf("expected context canceled error, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestExporterShutdownNoError(t *testing.T) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
|
|
defer cancel()
|
|
|
|
e := NewUnstartedExporter()
|
|
if err := e.Start(ctx); err != nil {
|
|
t.Fatalf("failed to start exporter: %v", err)
|
|
}
|
|
|
|
if err := e.Shutdown(ctx); err != nil {
|
|
t.Errorf("shutdown errored: expected nil, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestExporterShutdownManyTimes(t *testing.T) {
|
|
ctx := context.Background()
|
|
e, err := NewExporter(ctx)
|
|
if err != nil {
|
|
t.Fatalf("failed to start an exporter: %v", err)
|
|
}
|
|
ch := make(chan struct{})
|
|
wg := sync.WaitGroup{}
|
|
const num int = 20
|
|
wg.Add(num)
|
|
errs := make([]error, num)
|
|
for i := 0; i < num; i++ {
|
|
go func(idx int) {
|
|
defer wg.Done()
|
|
<-ch
|
|
errs[idx] = e.Shutdown(ctx)
|
|
}(i)
|
|
}
|
|
close(ch)
|
|
wg.Wait()
|
|
for _, err := range errs {
|
|
if err != nil {
|
|
t.Fatalf("failed to shutdown exporter: %v", err)
|
|
}
|
|
}
|
|
}
|