allow to provide extra options

Author: dhontecillas

config/config.go

@@ -23,13 +23,12 @@ type Exporters struct {
 }
 
 type OTLPExporter struct {
-	Name           string     `json:"name"`
-	Host           string     `json:"host"`
-	Port           int        `json:"port"`
-	UseHTTP        bool       `json:"use_http"`
-	HTTPHeaders    []KeyValue `json:"http_headers"`
-	DisableMetrics bool       `json:"disable_metrics"`
-	DisableTraces  bool       `json:"disable_traces"`
+	Name           string `json:"name"`
+	Host           string `json:"host"`
+	Port           int    `json:"port"`
+	UseHTTP        bool   `json:"use_http"`
+	DisableMetrics bool   `json:"disable_metrics"`
+	DisableTraces  bool   `json:"disable_traces"`
 }
 
 type PrometheusExporter struct {

exporter/otelcollector/otelcollector.go

@@ -43,54 +43,94 @@ func (c *OtelCollector) TraceDefaultReporting() bool {
 	return !c.tracesDisabledByDefault
 }
 
-// Exporter creates an Open Telemetry exporter instance.
-func Exporter(ctx context.Context, cfg config.OTLPExporter) (*OtelCollector, error) {
-	if cfg.Port == 0 {
-		cfg.Port = 4317
-	}
-	if cfg.Host == "" {
-		cfg.Host = "localhost"
-	}
+func httpExporterWithOptions(ctx context.Context, cfg config.OTLPExporter,
+	options []interface{}) (*OtelCollector, error) {
 
-	var exporter sdktrace.SpanExporter
-	var metricExporter sdkmetric.Exporter
-	var err error
-	if cfg.UseHTTP {
-		headers := make(map[string]string, len(cfg.HTTPHeaders))
-		for _, kvh := range cfg.HTTPHeaders {
-			// WARN: we do not clean up / canonicalize the header name
-			headers[kvh.Key] = kvh.Value
+	tOpts := make([]otlptracehttp.Option, 0, len(options)+1)
+	mOpts := make([]otlpmetrichttp.Option, 0, len(options)+1)
+	for _, iopt := range options {
+		if to, ok := iopt.(otlptracehttp.Option); ok {
+			tOpts = append(tOpts, to)
 		}
-		exporter, err = otlptracehttp.New(ctx,
-			otlptracehttp.WithHeaders(headers),
-			otlptracehttp.WithEndpoint(fmt.Sprintf("%s:%d", cfg.Host, cfg.Port)),
-		)
-		if err != nil {
-			return nil, errors.New("cannot create http exporter")
+		if mo, ok := iopt.(otlpmetrichttp.Option); ok {
+			mOpts = append(mOpts, mo)
 		}
+	}
+
+	endpoint := fmt.Sprintf("%s:%d", cfg.Host, cfg.Port)
+	tOpts = append(tOpts, otlptracehttp.WithEndpoint(endpoint))
+	exporter, err := otlptracehttp.New(ctx, tOpts...)
+	if err != nil {
+		return nil, errors.New("cannot create http trace exporter")
+	}
+
+	mOpts = append(mOpts, otlpmetrichttp.WithEndpoint(endpoint))
+	metricExporter, err := otlpmetrichttp.New(ctx, mOpts...)
+	if err != nil {
+		return nil, errors.New("cannot create http metric exporter")
+	}
+
+	return &OtelCollector{
+		exporter:                 exporter,
+		metricExporter:           metricExporter,
+		metricsDisabledByDefault: cfg.DisableMetrics,
+		tracesDisabledByDefault:  cfg.DisableTraces,
+	}, nil
+}
+
+func grpcExporterWithOptions(ctx context.Context, cfg config.OTLPExporter,
+	options []interface{}) (*OtelCollector, error) {
 
-		metricExporter, err = otlpmetrichttp.New(ctx,
-			otlpmetrichttp.WithHeaders(headers),
-			otlpmetrichttp.WithEndpoint(fmt.Sprintf("%s:%d", cfg.Host, cfg.Port)))
-		if err != nil {
-			return nil, errors.New("cannot create http metric exporter")
+	tOpts := make([]otlptracegrpc.Option, 0, len(options)+1)
+	mOpts := make([]otlpmetricgrpc.Option, 0, len(options)+1)
+	for _, iopt := range options {
+		if to, ok := iopt.(otlptracegrpc.Option); ok {
+			tOpts = append(tOpts, to)
 		}
-	} else {
-		// by default, grpc conections has TLS enabled
-		exporter, err = otlptracegrpc.New(ctx,
-			otlptracegrpc.WithInsecure(),
-			otlptracegrpc.WithEndpoint(fmt.Sprintf("%s:%d", cfg.Host, cfg.Port)))
-		if err != nil {
-			return nil, errors.New("cannot create grpc exporter")
+		if mo, ok := iopt.(otlpmetricgrpc.Option); ok {
+			mOpts = append(mOpts, mo)
 		}
-		metricExporter, err = otlpmetricgrpc.New(ctx,
-			otlpmetricgrpc.WithInsecure(),
-			otlpmetricgrpc.WithEndpoint(fmt.Sprintf("%s:%d", cfg.Host, cfg.Port)))
 	}
+
+	endpoint := fmt.Sprintf("%s:%d", cfg.Host, cfg.Port)
+	tOpts = append(tOpts, otlptracegrpc.WithEndpoint(endpoint))
+	exporter, err := otlptracegrpc.New(ctx, tOpts...)
+	if err != nil {
+		return nil, errors.New("cannot create grpc traces exporter")
+	}
+	mOpts = append(mOpts, otlpmetricgrpc.WithEndpoint(endpoint))
+	metricExporter, err := otlpmetricgrpc.New(ctx, mOpts...)
+	if err != nil {
+		return nil, errors.New("cannot create grpc metric exporter")
+	}
+
 	return &OtelCollector{
 		exporter:                 exporter,
 		metricExporter:           metricExporter,
 		metricsDisabledByDefault: cfg.DisableMetrics,
 		tracesDisabledByDefault:  cfg.DisableTraces,
 	}, nil
 }
+
+func ExporterWithOptions(ctx context.Context, cfg config.OTLPExporter, options []interface{}) (*OtelCollector, error) {
+	if cfg.Port == 0 {
+		cfg.Port = 4317
+	}
+	if cfg.Host == "" {
+		cfg.Host = "localhost"
+	}
+
+	if cfg.UseHTTP {
+		return httpExporterWithOptions(ctx, cfg, options)
+	}
+	return grpcExporterWithOptions(ctx, cfg, options)
+}
+
+// Exporter creates an Open Telemetry exporter instance.
+func Exporter(ctx context.Context, cfg config.OTLPExporter) (*OtelCollector, error) {
+	options := make([]interface{}, 0, 2)
+	// by default, grpc conections have TLS enabled:
+	options = append(options, otlptracegrpc.WithInsecure())
+	options = append(options, otlpmetricgrpc.WithInsecure())
+	return ExporterWithOptions(ctx, cfg, options)
+}