// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0

package otlploggrpc // import "go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc"

import (
	"context"
	"errors"
	"net"
	"sync"
	"testing"
	"time"

	"github.com/google/go-cmp/cmp"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	collogpb "go.opentelemetry.io/proto/otlp/collector/logs/v1"
	cpb "go.opentelemetry.io/proto/otlp/common/v1"
	lpb "go.opentelemetry.io/proto/otlp/logs/v1"
	rpb "go.opentelemetry.io/proto/otlp/resource/v1"
	"google.golang.org/genproto/googleapis/rpc/errdetails"
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/credentials"
	"google.golang.org/grpc/credentials/insecure"
	"google.golang.org/grpc/metadata"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/proto"
	"google.golang.org/protobuf/types/known/durationpb"

	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal"
	"go.opentelemetry.io/otel/exporters/otlp/otlplog/otlploggrpc/internal/observ"
	"go.opentelemetry.io/otel/sdk/instrumentation"
	"go.opentelemetry.io/otel/sdk/log"
	"go.opentelemetry.io/otel/sdk/metric"
	"go.opentelemetry.io/otel/sdk/metric/metricdata"
	"go.opentelemetry.io/otel/sdk/metric/metricdata/metricdatatest"
	semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
	"go.opentelemetry.io/otel/semconv/v1.40.0/otelconv"
)

var (
	// Sat Jan 01 2000 00:00:00 GMT+0000.
	ts  = time.Date(2000, time.January, 0o1, 0, 0, 0, 0, time.FixedZone("GMT", 0))
	obs = ts.Add(30 * time.Second)

	kvAlice = &cpb.KeyValue{Key: "user", Value: &cpb.AnyValue{
		Value: &cpb.AnyValue_StringValue{StringValue: "alice"},
	}}
	kvBob = &cpb.KeyValue{Key: "user", Value: &cpb.AnyValue{
		Value: &cpb.AnyValue_StringValue{StringValue: "bob"},
	}}
	kvSrvName = &cpb.KeyValue{Key: "service.name", Value: &cpb.AnyValue{
		Value: &cpb.AnyValue_StringValue{StringValue: "test server"},
	}}
	kvSrvVer = &cpb.KeyValue{Key: "service.version", Value: &cpb.AnyValue{
		Value: &cpb.AnyValue_StringValue{StringValue: "v0.1.0"},
	}}

	pbSevA = lpb.SeverityNumber_SEVERITY_NUMBER_INFO
	pbSevB = lpb.SeverityNumber_SEVERITY_NUMBER_ERROR

	pbBodyA = &cpb.AnyValue{
		Value: &cpb.AnyValue_StringValue{
			StringValue: "a",
		},
	}
	pbBodyB = &cpb.AnyValue{
		Value: &cpb.AnyValue_StringValue{
			StringValue: "b",
		},
	}

	spanIDA  = []byte{0, 0, 0, 0, 0, 0, 0, 1}
	spanIDB  = []byte{0, 0, 0, 0, 0, 0, 0, 2}
	traceIDA = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}
	traceIDB = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2}
	flagsA   = byte(1)
	flagsB   = byte(0)

	logRecords = []*lpb.LogRecord{
		{
			TimeUnixNano:         uint64(ts.UnixNano()),
			ObservedTimeUnixNano: uint64(obs.UnixNano()),
			SeverityNumber:       pbSevA,
			SeverityText:         "A",
			Body:                 pbBodyA,
			Attributes:           []*cpb.KeyValue{kvAlice},
			Flags:                uint32(flagsA),
			TraceId:              traceIDA,
			SpanId:               spanIDA,
		},
		{
			TimeUnixNano:         uint64(ts.UnixNano()),
			ObservedTimeUnixNano: uint64(obs.UnixNano()),
			SeverityNumber:       pbSevA,
			SeverityText:         "A",
			Body:                 pbBodyA,
			Attributes:           []*cpb.KeyValue{kvBob},
			Flags:                uint32(flagsA),
			TraceId:              traceIDA,
			SpanId:               spanIDA,
		},
		{
			TimeUnixNano:         uint64(ts.UnixNano()),
			ObservedTimeUnixNano: uint64(obs.UnixNano()),
			SeverityNumber:       pbSevB,
			SeverityText:         "B",
			Body:                 pbBodyB,
			Attributes:           []*cpb.KeyValue{kvAlice},
			Flags:                uint32(flagsB),
			TraceId:              traceIDB,
			SpanId:               spanIDB,
		},
		{
			TimeUnixNano:         uint64(ts.UnixNano()),
			ObservedTimeUnixNano: uint64(obs.UnixNano()),
			SeverityNumber:       pbSevB,
			SeverityText:         "B",
			Body:                 pbBodyB,
			Attributes:           []*cpb.KeyValue{kvBob},
			Flags:                uint32(flagsB),
			TraceId:              traceIDB,
			SpanId:               spanIDB,
		},
	}

	scope = &cpb.InstrumentationScope{
		Name:    "test/code/path",
		Version: "v0.1.0",
	}
	scopeLogs = []*lpb.ScopeLogs{
		{
			Scope:      scope,
			LogRecords: logRecords,
			SchemaUrl:  semconv.SchemaURL,
		},
	}

	res = &rpb.Resource{
		Attributes: []*cpb.KeyValue{kvSrvName, kvSrvVer},
	}
	resourceLogs = []*lpb.ResourceLogs{{
		Resource:  res,
		ScopeLogs: scopeLogs,
		SchemaUrl: semconv.SchemaURL,
	}}
)

func TestThrottleDelay(t *testing.T) {
	c := codes.ResourceExhausted
	testcases := []struct {
		status       *status.Status
		wantOK       bool
		wantDuration time.Duration
	}{
		{
			status:       status.New(c, "NoRetryInfo"),
			wantOK:       false,
			wantDuration: 0,
		},
		{
			status: func() *status.Status {
				s, err := status.New(c, "SingleRetryInfo").WithDetails(
					&errdetails.RetryInfo{
						RetryDelay: durationpb.New(15 * time.Millisecond),
					},
				)
				require.NoError(t, err)
				return s
			}(),
			wantOK:       true,
			wantDuration: 15 * time.Millisecond,
		},
		{
			status: func() *status.Status {
				s, err := status.New(c, "ErrorInfo").WithDetails(
					&errdetails.ErrorInfo{Reason: "no throttle detail"},
				)
				require.NoError(t, err)
				return s
			}(),
			wantOK:       false,
			wantDuration: 0,
		},
		{
			status: func() *status.Status {
				s, err := status.New(c, "ErrorAndRetryInfo").WithDetails(
					&errdetails.ErrorInfo{Reason: "with throttle detail"},
					&errdetails.RetryInfo{
						RetryDelay: durationpb.New(13 * time.Minute),
					},
				)
				require.NoError(t, err)
				return s
			}(),
			wantOK:       true,
			wantDuration: 13 * time.Minute,
		},
		{
			status: func() *status.Status {
				s, err := status.New(c, "DoubleRetryInfo").WithDetails(
					&errdetails.RetryInfo{
						RetryDelay: durationpb.New(13 * time.Minute),
					},
					&errdetails.RetryInfo{
						RetryDelay: durationpb.New(15 * time.Minute),
					},
				)
				require.NoError(t, err)
				return s
			}(),
			wantOK:       true,
			wantDuration: 13 * time.Minute,
		},
	}

	for _, tc := range testcases {
		t.Run(tc.status.Message(), func(t *testing.T) {
			ok, d := throttleDelay(tc.status)
			assert.Equal(t, tc.wantOK, ok)
			assert.Equal(t, tc.wantDuration, d)
		})
	}
}

func TestRetryable(t *testing.T) {
	retryableCodes := map[codes.Code]bool{
		codes.OK:                 false,
		codes.Canceled:           true,
		codes.Unknown:            false,
		codes.InvalidArgument:    false,
		codes.DeadlineExceeded:   true,
		codes.NotFound:           false,
		codes.AlreadyExists:      false,
		codes.PermissionDenied:   false,
		codes.ResourceExhausted:  false,
		codes.FailedPrecondition: false,
		codes.Aborted:            true,
		codes.OutOfRange:         true,
		codes.Unimplemented:      false,
		codes.Internal:           false,
		codes.Unavailable:        true,
		codes.DataLoss:           true,
		codes.Unauthenticated:    false,
	}

	for c, want := range retryableCodes {
		got, _ := retryable(status.Error(c, ""))
		assert.Equalf(t, want, got, "evaluate(%s)", c)
	}
}

func TestRetryableGRPCStatusResourceExhaustedWithRetryInfo(t *testing.T) {
	delay := 15 * time.Millisecond
	s, err := status.New(codes.ResourceExhausted, "WithRetryInfo").WithDetails(
		&errdetails.RetryInfo{
			RetryDelay: durationpb.New(delay),
		},
	)
	require.NoError(t, err)

	ok, d := retryableGRPCStatus(s)
	assert.True(t, ok)
	assert.Equal(t, delay, d)
}

func TestNewClient(t *testing.T) {
	newGRPCClientFnSwap := newGRPCClientFn
	t.Cleanup(func() {
		newGRPCClientFn = newGRPCClientFnSwap
	})

	// The gRPC connection created by newClient.
	conn, err := grpc.NewClient("test", grpc.WithTransportCredentials(insecure.NewCredentials()))
	require.NoError(t, err)
	newGRPCClientFn = func(string, ...grpc.DialOption) (*grpc.ClientConn, error) {
		return conn, nil
	}

	// The gRPC connection created by users.
	userConn, err := grpc.NewClient("test 2", grpc.WithTransportCredentials(insecure.NewCredentials()))
	require.NoError(t, err)

	testCases := []struct {
		name string
		cfg  config
		cli  *client
	}{
		{
			name: "empty config",
			cli: &client{
				ourConn: true,
				conn:    conn,
				lsc:     collogpb.NewLogsServiceClient(conn),
			},
		},
		{
			name: "with headers",
			cfg: config{
				headers: newSetting(map[string]string{
					"key": "value",
				}),
			},
			cli: &client{
				ourConn:  true,
				conn:     conn,
				lsc:      collogpb.NewLogsServiceClient(conn),
				metadata: map[string][]string{"key": {"value"}},
			},
		},
		{
			name: "with gRPC connection",
			cfg: config{
				gRPCConn: newSetting(userConn),
			},
			cli: &client{
				ourConn: false,
				conn:    userConn,
				lsc:     collogpb.NewLogsServiceClient(userConn),
			},
		},
		{
			// It is not possible to compare grpc dial options directly, so we just check that the client is created
			// and no panic occurs.
			name: "with dial options",
			cfg: config{
				serviceConfig:      newSetting("service config"),
				gRPCCredentials:    newSetting(credentials.NewTLS(nil)),
				compression:        newSetting(GzipCompression),
				reconnectionPeriod: newSetting(10 * time.Second),
			},
			cli: &client{
				ourConn: true,
				conn:    conn,
				lsc:     collogpb.NewLogsServiceClient(conn),
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			cli, err := newClient(tc.cfg)
			require.NoError(t, err)

			assert.Equal(t, tc.cli.metadata, cli.metadata)
			assert.Equal(t, tc.cli.exportTimeout, cli.exportTimeout)
			assert.Equal(t, tc.cli.ourConn, cli.ourConn)
			assert.Equal(t, tc.cli.conn, cli.conn)
			assert.Equal(t, tc.cli.lsc, cli.lsc)
		})
	}
}

type exportResult struct {
	Response *collogpb.ExportLogsServiceResponse
	Err      error
}

// storage stores uploaded OTLP log data in their proto form.
type storage struct {
	dataMu sync.Mutex
	data   []*lpb.ResourceLogs
}

// newStorage returns a configure storage ready to store received requests.
func newStorage() *storage {
	return &storage{}
}

// Add adds the request to the Storage.
func (s *storage) Add(request *collogpb.ExportLogsServiceRequest) {
	s.dataMu.Lock()
	defer s.dataMu.Unlock()
	s.data = append(s.data, request.ResourceLogs...)
}

// Dump returns all added ResourceLogs and clears the storage.
func (s *storage) Dump() []*lpb.ResourceLogs {
	s.dataMu.Lock()
	defer s.dataMu.Unlock()

	var data []*lpb.ResourceLogs
	data, s.data = s.data, []*lpb.ResourceLogs{}
	return data
}

// grpcCollector is an OTLP gRPC server that collects all requests it receives.
type grpcCollector struct {
	collogpb.UnimplementedLogsServiceServer

	headersMu sync.Mutex
	headers   metadata.MD
	storage   *storage

	resultCh <-chan exportResult
	listener net.Listener
	srv      *grpc.Server
}

var _ collogpb.LogsServiceServer = (*grpcCollector)(nil)

// newGRPCCollector returns a *grpcCollector that is listening at the provided
// endpoint.
//
// If endpoint is an empty string, the returned collector will be listening on
// the localhost interface at an OS chosen port.
//
// If errCh is not nil, the collector will respond to Export calls with errors
// sent on that channel. This means that if errCh is not nil Export calls will
// block until an error is received.
func newGRPCCollector(ctx context.Context, endpoint string, resultCh <-chan exportResult) (*grpcCollector, error) {
	if endpoint == "" {
		endpoint = "localhost:0"
	}

	c := &grpcCollector{
		storage:  newStorage(),
		resultCh: resultCh,
	}

	var err error
	c.listener, err = (&net.ListenConfig{}).Listen(ctx, "tcp", endpoint)
	if err != nil {
		return nil, err
	}

	c.srv = grpc.NewServer()
	collogpb.RegisterLogsServiceServer(c.srv, c)
	go func() { _ = c.srv.Serve(c.listener) }()

	return c, nil
}

// Export handles the export req.
func (c *grpcCollector) Export(
	ctx context.Context,
	req *collogpb.ExportLogsServiceRequest,
) (*collogpb.ExportLogsServiceResponse, error) {
	c.storage.Add(req)

	if h, ok := metadata.FromIncomingContext(ctx); ok {
		c.headersMu.Lock()
		c.headers = metadata.Join(c.headers, h)
		c.headersMu.Unlock()
	}

	if c.resultCh != nil {
		r := <-c.resultCh
		if r.Response == nil {
			return &collogpb.ExportLogsServiceResponse{}, r.Err
		}
		return r.Response, r.Err
	}
	return &collogpb.ExportLogsServiceResponse{}, nil
}

// Collect returns the Storage holding all collected requests.
func (c *grpcCollector) Collect() *storage {
	return c.storage
}

func clientFactory(t *testing.T, rCh <-chan exportResult) (*client, *grpcCollector) {
	t.Helper()
	coll, err := newGRPCCollector(t.Context(), "", rCh)
	require.NoError(t, err)

	addr := coll.listener.Addr().String()
	opts := []Option{WithEndpoint(addr), WithInsecure()}
	cfg := newConfig(opts)
	client, err := newClient(cfg)
	require.NoError(t, err)
	return client, coll
}

func testCtxErrs(factory func() func(context.Context) error) func(t *testing.T) {
	return func(t *testing.T) {
		t.Helper()
		ctx, cancel := context.WithCancel(t.Context())
		t.Cleanup(cancel)

		t.Run("DeadlineExceeded", func(t *testing.T) {
			innerCtx, innerCancel := context.WithTimeout(ctx, time.Nanosecond)
			t.Cleanup(innerCancel)
			<-innerCtx.Done()

			f := factory()
			assert.ErrorIs(t, f(innerCtx), context.DeadlineExceeded)
		})

		t.Run("Canceled", func(t *testing.T) {
			innerCtx, innerCancel := context.WithCancel(ctx)
			innerCancel()

			f := factory()
			assert.ErrorIs(t, f(innerCtx), context.Canceled)
		})
	}
}

func TestClient(t *testing.T) {
	t.Run("ClientHonorsContextErrors", func(t *testing.T) {
		t.Run("Shutdown", testCtxErrs(func() func(context.Context) error {
			c, _ := clientFactory(t, nil)
			return c.Shutdown
		}))

		t.Run("UploadLog", testCtxErrs(func() func(context.Context) error {
			c, _ := clientFactory(t, nil)
			return func(ctx context.Context) error {
				return c.UploadLogs(ctx, nil)
			}
		}))
	})

	t.Run("UploadLogs", func(t *testing.T) {
		ctx := t.Context()
		client, coll := clientFactory(t, nil)

		require.NoError(t, client.UploadLogs(ctx, resourceLogs))
		require.NoError(t, client.Shutdown(ctx))
		got := coll.Collect().Dump()
		require.Len(t, got, 1, "upload of one ResourceLogs")
		diff := cmp.Diff(got[0], resourceLogs[0], cmp.Comparer(proto.Equal))
		if diff != "" {
			t.Fatalf("unexpected ResourceLogs:\n%s", diff)
		}
	})

	t.Run("PartialSuccess", func(t *testing.T) {
		const n, msg = 2, "bad data"
		rCh := make(chan exportResult, 3)
		rCh <- exportResult{
			Response: &collogpb.ExportLogsServiceResponse{
				PartialSuccess: &collogpb.ExportLogsPartialSuccess{
					RejectedLogRecords: n,
					ErrorMessage:       msg,
				},
			},
		}
		rCh <- exportResult{
			Response: &collogpb.ExportLogsServiceResponse{
				PartialSuccess: &collogpb.ExportLogsPartialSuccess{
					// Should not be logged.
					RejectedLogRecords: 0,
					ErrorMessage:       "",
				},
			},
		}
		rCh <- exportResult{
			Response: &collogpb.ExportLogsServiceResponse{},
		}

		ctx := t.Context()
		client, _ := clientFactory(t, rCh)

		assert.ErrorIs(t, client.UploadLogs(ctx, resourceLogs), internal.PartialSuccess{})
		assert.NoError(t, client.UploadLogs(ctx, resourceLogs))
		assert.NoError(t, client.UploadLogs(ctx, resourceLogs))
	})
}

func TestConfig(t *testing.T) {
	factoryFunc := func(rCh <-chan exportResult, o ...Option) (log.Exporter, *grpcCollector) {
		coll, err := newGRPCCollector(t.Context(), "", rCh)
		require.NoError(t, err)

		ctx := t.Context()
		opts := append([]Option{
			WithEndpoint(coll.listener.Addr().String()),
			WithInsecure(),
		}, o...)
		exp, err := New(ctx, opts...)
		require.NoError(t, err)
		return exp, coll
	}

	t.Run("WithHeaders", func(t *testing.T) {
		key := "my-custom-header"
		headers := map[string]string{key: "custom-value"}
		exp, coll := factoryFunc(nil, WithHeaders(headers))
		t.Cleanup(coll.srv.Stop)

		ctx := t.Context()
		additionalKey := "additional-custom-header"
		ctx = metadata.AppendToOutgoingContext(ctx, additionalKey, "additional-value")
		require.NoError(t, exp.Export(ctx, make([]log.Record, 1)))
		// Ensure everything is flushed.
		require.NoError(t, exp.Shutdown(ctx))

		got := metadata.Join(coll.headers)
		require.Regexp(t, "OTel Go OTLP over gRPC logs exporter/[01]\\..*", got)
		require.Contains(t, got, key)
		require.Contains(t, got, additionalKey)
		assert.Equal(t, []string{headers[key]}, got[key])
	})
}

// SetExporterID sets the exporter ID counter to v and returns the previous
// value.
//
// This function is useful for testing purposes, allowing you to reset the
// counter. It should not be used in production code.
func SetExporterID(v int64) int64 {
	return exporterN.Swap(v)
}

func TestClientObservability(t *testing.T) {
	testCases := []struct {
		name    string
		enabled bool
		test    func(t *testing.T, scopeMetrics func() metricdata.ScopeMetrics)
	}{
		{
			name:    "disable",
			enabled: false,
			test: func(t *testing.T, _ func() metricdata.ScopeMetrics) {
				client, _ := clientFactory(t, nil)
				assert.Empty(t, client.instrumentation)
			},
		},
		{
			name:    "upload success",
			enabled: true,
			test: func(t *testing.T, scopeMetrics func() metricdata.ScopeMetrics) {
				ctx := t.Context()
				client, coll := clientFactory(t, nil)

				componentName := observ.GetComponentName(0)
				serverAddrAttrs := observ.ServerAddrAttrs(client.conn.CanonicalTarget())
				wantMetrics := metricdata.ScopeMetrics{
					Scope: instrumentation.Scope{
						Name:      observ.ScopeName,
						Version:   observ.Version,
						SchemaURL: semconv.SchemaURL,
					},
					Metrics: []metricdata.Metrics{
						{
							Name:        otelconv.SDKExporterLogInflight{}.Name(),
							Description: otelconv.SDKExporterLogInflight{}.Description(),
							Unit:        otelconv.SDKExporterLogInflight{}.Unit(),
							Data: metricdata.Sum[int64]{
								Temporality: metricdata.CumulativeTemporality,
								DataPoints: []metricdata.DataPoint[int64]{
									{
										Attributes: attribute.NewSet(
											otelconv.SDKExporterLogInflight{}.AttrComponentName(componentName),
											otelconv.SDKExporterLogInflight{}.AttrComponentType(
												otelconv.ComponentTypeOtlpGRPCLogExporter,
											),
											serverAddrAttrs[0],
											serverAddrAttrs[1],
										),
										Value: 0,
									},
								},
							},
						},
						{
							Name:        otelconv.SDKExporterLogExported{}.Name(),
							Description: otelconv.SDKExporterLogExported{}.Description(),
							Unit:        otelconv.SDKExporterLogExported{}.Unit(),
							Data: metricdata.Sum[int64]{
								Temporality: metricdata.CumulativeTemporality,
								IsMonotonic: true,
								DataPoints: []metricdata.DataPoint[int64]{
									{
										Attributes: attribute.NewSet(
											otelconv.SDKExporterLogExported{}.AttrComponentName(componentName),
											otelconv.SDKExporterLogExported{}.AttrComponentType(
												otelconv.ComponentTypeOtlpGRPCLogExporter,
											),
											serverAddrAttrs[0],
											serverAddrAttrs[1],
										),
										Value: int64(len(resourceLogs)),
									},
								},
							},
						},
						{
							Name:        otelconv.SDKExporterOperationDuration{}.Name(),
							Description: otelconv.SDKExporterOperationDuration{}.Description(),
							Unit:        otelconv.SDKExporterOperationDuration{}.Unit(),
							Data: metricdata.Histogram[float64]{
								Temporality: metricdata.CumulativeTemporality,
								DataPoints: []metricdata.HistogramDataPoint[float64]{
									{
										Attributes: attribute.NewSet(
											otelconv.SDKExporterLogExported{}.AttrComponentName(componentName),
											otelconv.SDKExporterOperationDuration{}.AttrComponentType(
												otelconv.ComponentTypeOtlpGRPCLogExporter,
											),
											otelconv.SDKExporterOperationDuration{}.AttrRPCResponseStatusCode(
												codes.OK.String(),
											),
											serverAddrAttrs[0],
											serverAddrAttrs[1],
										),
										Count: 1,
									},
								},
							},
						},
					},
				}

				require.NoError(t, client.UploadLogs(ctx, resourceLogs))
				require.NoError(t, client.Shutdown(ctx))
				got := coll.Collect().Dump()
				require.Len(t, got, 1, "upload of one ResourceLogs")
				diff := cmp.Diff(got[0], resourceLogs[0], cmp.Comparer(proto.Equal))
				if diff != "" {
					t.Fatalf("unexpected ResourceLogs:\n%s", diff)
				}

				assert.Equal(t, instrumentation.Scope{
					Name:      observ.ScopeName,
					Version:   observ.Version,
					SchemaURL: semconv.SchemaURL,
				}, wantMetrics.Scope)

				g := scopeMetrics()
				metricdatatest.AssertEqual(t, wantMetrics.Metrics[0], g.Metrics[0], metricdatatest.IgnoreTimestamp())
				metricdatatest.AssertEqual(t, wantMetrics.Metrics[1], g.Metrics[1], metricdatatest.IgnoreTimestamp())
				metricdatatest.AssertEqual(
					t,
					wantMetrics.Metrics[2],
					g.Metrics[2],
					metricdatatest.IgnoreTimestamp(),
					metricdatatest.IgnoreValue(),
				)
			},
		},
		{
			name:    "partial success",
			enabled: true,
			test: func(t *testing.T, scopeMetrics func() metricdata.ScopeMetrics) {
				const n, msg = 2, "bad data"
				rCh := make(chan exportResult, 1)
				rCh <- exportResult{
					Response: &collogpb.ExportLogsServiceResponse{
						PartialSuccess: &collogpb.ExportLogsPartialSuccess{
							RejectedLogRecords: n,
							ErrorMessage:       msg,
						},
					},
				}
				ctx := t.Context()
				client, _ := clientFactory(t, rCh)

				componentName := observ.GetComponentName(0)
				serverAddrAttrs := observ.ServerAddrAttrs(client.conn.CanonicalTarget())
				var wantErr error
				wantErr = errors.Join(wantErr, internal.LogPartialSuccessError(n, msg))
				wantMetrics := metricdata.ScopeMetrics{
					Scope: instrumentation.Scope{
						Name:      observ.ScopeName,
						Version:   observ.Version,
						SchemaURL: semconv.SchemaURL,
					},
					Metrics: []metricdata.Metrics{
						{
							Name:        otelconv.SDKExporterLogInflight{}.Name(),
							Description: otelconv.SDKExporterLogInflight{}.Description(),
							Unit:        otelconv.SDKExporterLogInflight{}.Unit(),
							Data: metricdata.Sum[int64]{
								Temporality: metricdata.CumulativeTemporality,
								DataPoints: []metricdata.DataPoint[int64]{
									{
										Attributes: attribute.NewSet(
											otelconv.SDKExporterLogInflight{}.AttrComponentName(componentName),
											otelconv.SDKExporterLogInflight{}.AttrComponentType(
												otelconv.ComponentTypeOtlpGRPCLogExporter,
											),
											serverAddrAttrs[0],
											serverAddrAttrs[1],
										),

										Value: 0,
									},
								},
							},
						},
						{
							Name:        otelconv.SDKExporterLogExported{}.Name(),
							Description: otelconv.SDKExporterLogExported{}.Description(),
							Unit:        otelconv.SDKExporterLogExported{}.Unit(),
							Data: metricdata.Sum[int64]{
								Temporality: metricdata.CumulativeTemporality,
								IsMonotonic: true,
								DataPoints: []metricdata.DataPoint[int64]{
									{
										Attributes: attribute.NewSet(
											otelconv.SDKExporterLogExported{}.AttrComponentName(componentName),
											otelconv.SDKExporterLogExported{}.AttrComponentType(
												otelconv.ComponentTypeOtlpGRPCLogExporter,
											),
											serverAddrAttrs[0],
											serverAddrAttrs[1],
										),
										Value: 0,
									},
									{
										Attributes: attribute.NewSet(
											otelconv.SDKExporterLogExported{}.AttrComponentName(componentName),
											otelconv.SDKExporterLogExported{}.AttrComponentType(
												otelconv.ComponentTypeOtlpGRPCLogExporter,
											),
											serverAddrAttrs[0],
											serverAddrAttrs[1],
											semconv.ErrorType(wantErr),
										),
										Value: 1,
									},
								},
							},
						},
						{
							Name:        otelconv.SDKExporterOperationDuration{}.Name(),
							Description: otelconv.SDKExporterOperationDuration{}.Description(),
							Unit:        otelconv.SDKExporterOperationDuration{}.Unit(),
							Data: metricdata.Histogram[float64]{
								Temporality: metricdata.CumulativeTemporality,
								DataPoints: []metricdata.HistogramDataPoint[float64]{
									{
										Attributes: attribute.NewSet(
											otelconv.SDKExporterLogExported{}.AttrComponentName(componentName),
											otelconv.SDKExporterOperationDuration{}.AttrComponentType(
												otelconv.ComponentTypeOtlpGRPCLogExporter,
											),
											otelconv.SDKExporterOperationDuration{}.AttrRPCResponseStatusCode(
												status.Code(wantErr).String(),
											),
											serverAddrAttrs[0],
											serverAddrAttrs[1],
											semconv.ErrorType(wantErr),
										),
										Count: 1,
									},
								},
							},
						},
					},
				}

				err := client.UploadLogs(ctx, resourceLogs)
				assert.ErrorContains(t, err, wantErr.Error())

				assert.Equal(t, instrumentation.Scope{
					Name:      observ.ScopeName,
					Version:   observ.Version,
					SchemaURL: semconv.SchemaURL,
				}, wantMetrics.Scope)

				g := scopeMetrics()
				metricdatatest.AssertEqual(t, wantMetrics.Metrics[0], g.Metrics[0], metricdatatest.IgnoreTimestamp())
				metricdatatest.AssertEqual(t, wantMetrics.Metrics[1], g.Metrics[1], metricdatatest.IgnoreTimestamp())
				metricdatatest.AssertEqual(
					t,
					wantMetrics.Metrics[2],
					g.Metrics[2],
					metricdatatest.IgnoreTimestamp(),
					metricdatatest.IgnoreValue(),
				)
			},
		},
		{
			name:    "upload failure",
			enabled: true,
			test: func(t *testing.T, scopeMetrics func() metricdata.ScopeMetrics) {
				err := status.Error(codes.InvalidArgument, "request contains invalid arguments")
				var wantErr error
				wantErr = errors.Join(wantErr, err)

				wantErrTypeAttr := semconv.ErrorType(wantErr)
				wantGRPCStatus := codes.InvalidArgument
				rCh := make(chan exportResult, 1)
				rCh <- exportResult{
					Err: err,
				}
				ctx := t.Context()
				client, _ := clientFactory(t, rCh)
				uploadErr := client.UploadLogs(ctx, resourceLogs)
				assert.ErrorContains(t, uploadErr, "request contains invalid arguments")

				componentName := observ.GetComponentName(0)

				serverAddrAttrs := observ.ServerAddrAttrs(client.conn.CanonicalTarget())
				wantMetrics := metricdata.ScopeMetrics{
					Scope: instrumentation.Scope{
						Name:      observ.ScopeName,
						Version:   observ.Version,
						SchemaURL: semconv.SchemaURL,
					},
					Metrics: []metricdata.Metrics{
						{
							Name:        otelconv.SDKExporterLogInflight{}.Name(),
							Description: otelconv.SDKExporterLogInflight{}.Description(),
							Unit:        otelconv.SDKExporterLogInflight{}.Unit(),
							Data: metricdata.Sum[int64]{
								Temporality: metricdata.CumulativeTemporality,
								DataPoints: []metricdata.DataPoint[int64]{
									{
										Attributes: attribute.NewSet(
											otelconv.SDKExporterLogInflight{}.AttrComponentName(componentName),
											otelconv.SDKExporterLogInflight{}.AttrComponentType(
												otelconv.ComponentTypeOtlpGRPCLogExporter,
											),
											serverAddrAttrs[0],
											serverAddrAttrs[1],
										),
										Value: 0,
									},
								},
							},
						},
						{
							Name:        otelconv.SDKExporterLogExported{}.Name(),
							Description: otelconv.SDKExporterLogExported{}.Description(),
							Unit:        otelconv.SDKExporterLogExported{}.Unit(),
							Data: metricdata.Sum[int64]{
								Temporality: metricdata.CumulativeTemporality,
								IsMonotonic: true,
								DataPoints: []metricdata.DataPoint[int64]{
									{
										Attributes: attribute.NewSet(
											otelconv.SDKExporterLogExported{}.AttrComponentName(componentName),
											otelconv.SDKExporterLogExported{}.AttrComponentType(
												otelconv.ComponentTypeOtlpGRPCLogExporter,
											),
											serverAddrAttrs[0],
											serverAddrAttrs[1],
										),
										Value: 0,
									},
									{
										Attributes: attribute.NewSet(
											otelconv.SDKExporterLogExported{}.AttrComponentName(componentName),
											otelconv.SDKExporterLogExported{}.AttrComponentType(
												otelconv.ComponentTypeOtlpGRPCLogExporter,
											),
											serverAddrAttrs[0],
											serverAddrAttrs[1],
											wantErrTypeAttr,
										),
										Value: 1,
									},
								},
							},
						},
						{
							Name:        otelconv.SDKExporterOperationDuration{}.Name(),
							Description: otelconv.SDKExporterOperationDuration{}.Description(),
							Unit:        otelconv.SDKExporterOperationDuration{}.Unit(),
							Data: metricdata.Histogram[float64]{
								Temporality: metricdata.CumulativeTemporality,
								DataPoints: []metricdata.HistogramDataPoint[float64]{
									{
										Attributes: attribute.NewSet(
											otelconv.SDKExporterLogExported{}.AttrComponentName(componentName),
											otelconv.SDKExporterOperationDuration{}.AttrComponentType(
												otelconv.ComponentTypeOtlpGRPCLogExporter,
											),
											otelconv.SDKExporterOperationDuration{}.AttrRPCResponseStatusCode(
												wantGRPCStatus.String(),
											),
											serverAddrAttrs[0],
											serverAddrAttrs[1],
											wantErrTypeAttr,
										),
										Count: 1,
									},
								},
							},
						},
					},
				}
				g := scopeMetrics()
				assert.Equal(t, instrumentation.Scope{
					Name:      observ.ScopeName,
					Version:   observ.Version,
					SchemaURL: semconv.SchemaURL,
				}, wantMetrics.Scope)

				metricdatatest.AssertEqual(t, wantMetrics.Metrics[0], g.Metrics[0], metricdatatest.IgnoreTimestamp())
				metricdatatest.AssertEqual(t, wantMetrics.Metrics[1], g.Metrics[1], metricdatatest.IgnoreTimestamp())
				metricdatatest.AssertEqual(
					t,
					wantMetrics.Metrics[2],
					g.Metrics[2],
					metricdatatest.IgnoreTimestamp(),
					metricdatatest.IgnoreValue(),
				)
			},
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			if tc.enabled {
				t.Setenv("OTEL_GO_X_OBSERVABILITY", "true")

				// Reset component name counter for each test.
				_ = SetExporterID(0)
			}
			prev := otel.GetMeterProvider()
			t.Cleanup(func() {
				otel.SetMeterProvider(prev)
			})
			r := metric.NewManualReader()
			mp := metric.NewMeterProvider(metric.WithReader(r))
			otel.SetMeterProvider(mp)

			scopeMetrics := func() metricdata.ScopeMetrics {
				var got metricdata.ResourceMetrics
				err := r.Collect(t.Context(), &got)
				require.NoError(t, err)
				require.Len(t, got.ScopeMetrics, 1)
				return got.ScopeMetrics[0]
			}
			tc.test(t, scopeMetrics)
		})
	}
}

func TestClientObservabilityWithRetry(t *testing.T) {
	t.Setenv("OTEL_GO_X_OBSERVABILITY", "true")

	_ = SetExporterID(0)
	prev := otel.GetMeterProvider()
	t.Cleanup(func() {
		otel.SetMeterProvider(prev)
	})

	r := metric.NewManualReader()
	mp := metric.NewMeterProvider(metric.WithReader(r))
	otel.SetMeterProvider(mp)

	scopeMetrics := func() metricdata.ScopeMetrics {
		var got metricdata.ResourceMetrics
		err := r.Collect(t.Context(), &got)
		require.NoError(t, err)
		require.Len(t, got.ScopeMetrics, 1)
		return got.ScopeMetrics[0]
	}

	rCh := make(chan exportResult, 2)
	rCh <- exportResult{
		Err: status.Error(codes.Unavailable, "service temporarily unavailable"),
	}
	const n, msg = 1, "some logs rejected"
	rCh <- exportResult{
		Response: &collogpb.ExportLogsServiceResponse{
			PartialSuccess: &collogpb.ExportLogsPartialSuccess{
				RejectedLogRecords: n,
				ErrorMessage:       msg,
			},
		},
	}

	ctx := t.Context()
	client, _ := clientFactory(t, rCh)

	componentName := observ.GetComponentName(0)

	serverAddrAttrs := observ.ServerAddrAttrs(client.conn.CanonicalTarget())
	var wantErr error
	wantErr = errors.Join(wantErr, internal.LogPartialSuccessError(n, msg))

	wantMetrics := metricdata.ScopeMetrics{
		Scope: instrumentation.Scope{
			Name:      observ.ScopeName,
			Version:   observ.Version,
			SchemaURL: semconv.SchemaURL,
		},
		Metrics: []metricdata.Metrics{
			{
				Name:        otelconv.SDKExporterLogInflight{}.Name(),
				Description: otelconv.SDKExporterLogInflight{}.Description(),
				Unit:        otelconv.SDKExporterLogInflight{}.Unit(),
				Data: metricdata.Sum[int64]{
					Temporality: metricdata.CumulativeTemporality,
					DataPoints: []metricdata.DataPoint[int64]{
						{
							Attributes: attribute.NewSet(
								otelconv.SDKExporterLogInflight{}.AttrComponentName(componentName),
								otelconv.SDKExporterLogInflight{}.AttrComponentType(
									otelconv.ComponentTypeOtlpGRPCLogExporter,
								),
								serverAddrAttrs[0],
								serverAddrAttrs[1],
							),
							Value: 0,
						},
					},
				},
			},
			{
				Name:        otelconv.SDKExporterLogExported{}.Name(),
				Description: otelconv.SDKExporterLogExported{}.Description(),
				Unit:        otelconv.SDKExporterLogExported{}.Unit(),
				Data: metricdata.Sum[int64]{
					Temporality: metricdata.CumulativeTemporality,
					IsMonotonic: true,
					DataPoints: []metricdata.DataPoint[int64]{
						{
							Attributes: attribute.NewSet(
								otelconv.SDKExporterLogExported{}.AttrComponentName(componentName),
								otelconv.SDKExporterLogExported{}.AttrComponentType(
									otelconv.ComponentTypeOtlpGRPCLogExporter,
								),
								serverAddrAttrs[0],
								serverAddrAttrs[1],
							),
							Value: int64(len(resourceLogs)) - n,
						},
						{
							Attributes: attribute.NewSet(
								otelconv.SDKExporterLogExported{}.AttrComponentName(componentName),
								otelconv.SDKExporterLogExported{}.AttrComponentType(
									otelconv.ComponentTypeOtlpGRPCLogExporter,
								),
								serverAddrAttrs[0],
								serverAddrAttrs[1],
								semconv.ErrorType(wantErr),
							),
							Value: n,
						},
					},
				},
			},
			{
				Name:        otelconv.SDKExporterOperationDuration{}.Name(),
				Description: otelconv.SDKExporterOperationDuration{}.Description(),
				Unit:        otelconv.SDKExporterOperationDuration{}.Unit(),
				Data: metricdata.Histogram[float64]{
					Temporality: metricdata.CumulativeTemporality,
					DataPoints: []metricdata.HistogramDataPoint[float64]{
						{
							Attributes: attribute.NewSet(
								otelconv.SDKExporterLogExported{}.AttrComponentName(componentName),
								otelconv.SDKExporterOperationDuration{}.AttrComponentType(
									otelconv.ComponentTypeOtlpGRPCLogExporter,
								),
								otelconv.SDKExporterOperationDuration{}.AttrRPCResponseStatusCode(
									status.Code(wantErr).String(),
								),
								serverAddrAttrs[0],
								serverAddrAttrs[1],
								semconv.ErrorType(wantErr),
							),
							Count: 1,
						},
					},
				},
			},
		},
	}

	err := client.UploadLogs(ctx, resourceLogs)
	assert.ErrorContains(t, err, wantErr.Error())

	assert.Equal(t, instrumentation.Scope{
		Name:      observ.ScopeName,
		Version:   observ.Version,
		SchemaURL: semconv.SchemaURL,
	}, wantMetrics.Scope)

	g := scopeMetrics()
	metricdatatest.AssertEqual(t, wantMetrics.Metrics[0], g.Metrics[0], metricdatatest.IgnoreTimestamp())
	metricdatatest.AssertEqual(t, wantMetrics.Metrics[1], g.Metrics[1], metricdatatest.IgnoreTimestamp())
	metricdatatest.AssertEqual(
		t,
		wantMetrics.Metrics[2],
		g.Metrics[2],
		metricdatatest.IgnoreTimestamp(),
		metricdatatest.IgnoreValue(),
	)
}

func BenchmarkExporterExportLogs(b *testing.B) {
	const logRecordsCount = 100

	run := func(b *testing.B) {
		coll, err := newGRPCCollector(b.Context(), "", nil)
		require.NoError(b, err)
		b.Cleanup(func() {
			coll.srv.Stop()
		})

		ctx := b.Context()
		opts := []Option{
			WithEndpoint(coll.listener.Addr().String()),
			WithInsecure(),
			WithTimeout(5 * time.Second),
		}
		exp, err := New(ctx, opts...)
		require.NoError(b, err)
		b.Cleanup(func() {
			//nolint:usetesting // required to avoid getting a canceled context at cleanup.
			assert.NoError(b, exp.Shutdown(context.Background()))
		})

		logs := make([]log.Record, logRecordsCount)
		now := time.Now()
		for i := range logs {
			logs[i].SetTimestamp(now)
			logs[i].SetObservedTimestamp(now)
		}

		b.ReportAllocs()
		b.ResetTimer()

		for b.Loop() {
			err := exp.Export(b.Context(), logs)
			require.NoError(b, err)
		}
	}

	b.Run("Observability", func(b *testing.B) {
		b.Setenv("OTEL_GO_X_OBSERVABILITY", "true")
		run(b)
	})

	b.Run("NoObservability", func(b *testing.B) {
		b.Setenv("OTEL_GO_X_OBSERVABILITY", "false")
		run(b)
	})
}

func TestNextExporterID(t *testing.T) {
	SetExporterID(0)

	var expected int64
	for range 10 {
		id := nextExporterID()
		if id != expected {
			t.Errorf("nextExporterID() = %d; want %d", id, expected)
		}
		expected++
	}
}

func TestSetExporterID(t *testing.T) {
	SetExporterID(0)

	prev := SetExporterID(42)
	if prev != 0 {
		t.Errorf("SetExporterID(42) returned %d; want 0", prev)
	}

	id := nextExporterID()
	if id != 42 {
		t.Errorf("nextExporterID() = %d; want 42", id)
	}
}

func TestNextExporterIDConcurrentSafe(t *testing.T) {
	SetExporterID(0)

	const goroutines = 100
	const increments = 10

	var wg sync.WaitGroup
	wg.Add(goroutines)

	for range goroutines {
		go func() {
			defer wg.Done()
			for range increments {
				nextExporterID()
			}
		}()
	}

	wg.Wait()

	expected := int64(goroutines * increments)
	if id := nextExporterID(); id != expected {
		t.Errorf("nextExporterID() = %d; want %d", id, expected)
	}
}
