[chore] Use T for generics instead of K, consistent with rest of the repo (#12755)

Signed-off-by: Bogdan Drutu <bogdandrutu@gmail.com>

Author: bogdandrutu

exporter/exporterhelper/internal/queue_sender.go

@@ -19,9 +19,9 @@ import (
 )
 
 // QueueBatchSettings is a subset of the queuebatch.Settings that are needed when used within an Exporter.
-type QueueBatchSettings[K any] struct {
-Encoding queuebatch.Encoding[K]
-Sizers map[request.SizerType]request.Sizer[K]
+type QueueBatchSettings[T any] struct {
+Encoding queuebatch.Encoding[T]
+Sizers map[request.SizerType]request.Sizer[T]
 }
 
 // NewDefaultQueueConfig returns the default config for queuebatch.Config.

exporter/exporterhelper/internal/queuebatch/batcher.go

@@ -10,7 +10,7 @@ import (
 )
 
 // Batcher is in charge of reading items from the queue and send them out asynchronously.
-type Batcher[K any] interface {
+type Batcher[T any] interface {
 component.Component
-Consume(context.Context, K, Done)
+Consume(context.Context, T, Done)
 }

exporter/exporterhelper/internal/queuebatch/default_batcher.go

@@ -21,10 +21,10 @@ type batch struct {
 done multiDone
 }
 
-type batcherSettings[K any] struct {
+type batcherSettings[T any] struct {
 sizerType request.SizerType
-sizer request.Sizer[K]
-next sender.SendFunc[K]
+sizer request.Sizer[T]
+next sender.SendFunc[T]
 maxWorkers int
 }
 

exporter/exporterhelper/internal/queuebatch/disabled_batcher.go

@@ -22,6 +22,6 @@ func (db *disabledBatcher[T]) Consume(ctx context.Context, req T, done Done) {
 done.OnDone(db.consumeFunc(ctx, req))
 }
 
-func newDisabledBatcher[K any](consumeFunc sender.SendFunc[K]) Batcher[K] {
-return &disabledBatcher[K]{consumeFunc: consumeFunc}
+func newDisabledBatcher[T any](consumeFunc sender.SendFunc[T]) Batcher[T] {
+return &disabledBatcher[T]{consumeFunc: consumeFunc}
 }

exporter/exporterhelper/internal/queuebatch/queue_batch.go

@@ -15,12 +15,12 @@ import (
 )
 
 // Settings defines settings for creating a QueueBatch.
-type Settings[K any] struct {
+type Settings[T any] struct {
 Signal pipeline.Signal
 ID component.ID
 Telemetry component.TelemetrySettings
-Encoding Encoding[K]
-Sizers map[request.SizerType]request.Sizer[K]
+Encoding Encoding[T]
+Sizers map[request.SizerType]request.Sizer[T]
 }
 
 type QueueBatch struct {

exporter/exporterhelper/internal/sender/sender.go

@@ -9,24 +9,24 @@ import (
 "go.opentelemetry.io/collector/component"
 )
 
-type Sender[K any] interface {
+type Sender[T any] interface {
 component.Component
-Send(context.Context, K) error
+Send(context.Context, T) error
 }
 
-type SendFunc[K any] func(ctx context.Context, data K) error
+type SendFunc[T any] func(ctx context.Context, data T) error
 
-func NewSender[K any](consFunc SendFunc[K]) Sender[K] {
-return &sender[K]{consFunc: consFunc}
+func NewSender[T any](consFunc SendFunc[T]) Sender[T] {
+return &sender[T]{consFunc: consFunc}
 }
 
 // sender is a Sender that emits the incoming request to the exporter consumer func.
-type sender[K any] struct {
+type sender[T any] struct {
 component.StartFunc
 component.ShutdownFunc
-consFunc SendFunc[K]
+consFunc SendFunc[T]
 }
 
-func (es *sender[K]) Send(ctx context.Context, req K) error {
+func (es *sender[T]) Send(ctx context.Context, req T) error {
 return es.consFunc(ctx, req)
 }

exporter/exporterhelper/internal/sendertest/sendertest.go

@@ -9,14 +9,14 @@ import (
 "go.opentelemetry.io/collector/exporter/exporterhelper/internal/sender"
 )
 
-func NewNopSenderFunc[K any]() sender.SendFunc[K] {
-return func(context.Context, K) error {
+func NewNopSenderFunc[T any]() sender.SendFunc[T] {
+return func(context.Context, T) error {
 return nil
 }
 }
 
-func NewErrSenderFunc[K any](err error) sender.SendFunc[K] {
-return func(context.Context, K) error {
+func NewErrSenderFunc[T any](err error) sender.SendFunc[T] {
+return func(context.Context, T) error {
 return err
 }
 }

exporter/exporterhelper/internal/timeout_sender.go

@@ -35,18 +35,18 @@ func NewDefaultTimeoutConfig() TimeoutConfig {
 }
 
 // timeoutSender is a requestSender that adds a `timeout` to every request that passes this sender.
-type timeoutSender[K any] struct {
+type timeoutSender[T any] struct {
 component.StartFunc
 component.ShutdownFunc
 cfg TimeoutConfig
-next sender.Sender[K]
+next sender.Sender[T]
 }
 
-func newTimeoutSender[K any](cfg TimeoutConfig, next sender.Sender[K]) sender.Sender[K] {
-return &timeoutSender[K]{cfg: cfg, next: next}
+func newTimeoutSender[T any](cfg TimeoutConfig, next sender.Sender[T]) sender.Sender[T] {
+return &timeoutSender[T]{cfg: cfg, next: next}
 }
 
-func (ts *timeoutSender[K]) Send(ctx context.Context, req K) error {
+func (ts *timeoutSender[T]) Send(ctx context.Context, req T) error {
 // Intentionally don't overwrite the context inside the request, because in case of retries deadline will not be
 // updated because this deadline most likely is before the next one.
 tCtx, cancelFunc := context.WithTimeout(ctx, ts.cfg.Timeout)

exporter/exporterhelper/request.go

@@ -26,7 +26,7 @@ type RequestErrorHandler = request.ErrorHandler
 // RequestConverterFunc converts pdata telemetry into a user-defined Request.
 // Experimental: This API is at the early stage of development and may change without backward compatibility
 // until https://github.com/open-telemetry/opentelemetry-collector/issues/8122 is resolved.
-type RequestConverterFunc[K any] func(context.Context, K) (Request, error)
+type RequestConverterFunc[T any] func(context.Context, T) (Request, error)
 
 // RequestConsumeFunc processes the request. After the function returns, the request is no longer accessible,
 // and accessing it is considered undefined behavior.