get.porter.sh/porter@v1.3.0/pkg/portercontext/telemetry_test.go (about)

     1  package portercontext
     2  
     3  import (
     4  	"testing"
     5  
     6  	"get.porter.sh/porter/tests"
     7  	"github.com/stretchr/testify/assert"
     8  	"github.com/stretchr/testify/require"
     9  	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
    10  	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
    11  )
    12  
    13  func TestContext_createTraceClient(t *testing.T) {
    14  	t.Run("disabled", func(t *testing.T) {
    15  		c := NewTestContext(t)
    16  		cfg := LogConfiguration{
    17  			TelemetryEnabled: false,
    18  		}
    19  		client, err := c.createTraceClient(cfg)
    20  		require.NoError(t, err)
    21  		assert.Nil(t, client, "telemetry should be disabled")
    22  	})
    23  
    24  	t.Run("grpc", func(t *testing.T) {
    25  		c := NewTestContext(t)
    26  		c.UseFilesystem()
    27  		cfg := LogConfiguration{
    28  			TelemetryEnabled:     true,
    29  			TelemetryEndpoint:    "192.168.0.1:13789",
    30  			TelemetryProtocol:    "grpc",
    31  			TelemetryInsecure:    true,
    32  			TelemetryCertificate: "testdata/test-ca.pem",
    33  			TelemetryCompression: "gzip",
    34  			TelemetryTimeout:     "3s",
    35  		}
    36  		client, err := c.createTraceClient(cfg)
    37  		require.NoError(t, err)
    38  		require.NotNil(t, client, "expected a client to be returned")
    39  		assert.IsType(t, otlptracegrpc.NewClient(), client, "expected a grpc client")
    40  	})
    41  
    42  	t.Run("grpc, invalid cert", func(t *testing.T) {
    43  		c := NewTestContext(t)
    44  		c.UseFilesystem()
    45  		cfg := LogConfiguration{
    46  			TelemetryEnabled:     true,
    47  			TelemetryProtocol:    "grpc",
    48  			TelemetryCertificate: "missingcert.pem",
    49  		}
    50  		_, err := c.createTraceClient(cfg)
    51  		tests.RequireErrorContains(t, err, "invalid telemetry certificate")
    52  	})
    53  
    54  	t.Run("grpc, invalid timeout", func(t *testing.T) {
    55  		c := NewTestContext(t)
    56  		c.UseFilesystem()
    57  		cfg := LogConfiguration{
    58  			TelemetryEnabled:  true,
    59  			TelemetryProtocol: "grpc",
    60  			TelemetryTimeout:  "300",
    61  		}
    62  		_, err := c.createTraceClient(cfg)
    63  		tests.RequireErrorContains(t, err, "invalid telemetry timeout")
    64  	})
    65  
    66  	t.Run("grpc, invalid compression defaults to none", func(t *testing.T) {
    67  		c := NewTestContext(t)
    68  		c.UseFilesystem()
    69  		cfg := LogConfiguration{
    70  			TelemetryEnabled:     true,
    71  			TelemetryProtocol:    "grpc",
    72  			TelemetryCompression: "oops",
    73  		}
    74  		_, err := c.createTraceClient(cfg)
    75  		require.NoError(t, err)
    76  	})
    77  
    78  	t.Run("http", func(t *testing.T) {
    79  		c := NewTestContext(t)
    80  		c.UseFilesystem()
    81  		cfg := LogConfiguration{
    82  			TelemetryEnabled:     true,
    83  			TelemetryEndpoint:    "192.168.0.1:13789",
    84  			TelemetryProtocol:    "http/protobuf",
    85  			TelemetryInsecure:    true,
    86  			TelemetryCertificate: "testdata/test-ca.pem",
    87  			TelemetryCompression: "gzip",
    88  			TelemetryTimeout:     "3s",
    89  		}
    90  		client, err := c.createTraceClient(cfg)
    91  		require.NoError(t, err)
    92  		require.NotNil(t, client, "expected a client to be returned")
    93  		assert.IsType(t, otlptracehttp.NewClient(), client, "expected a http client")
    94  	})
    95  
    96  	t.Run("http, invalid cert", func(t *testing.T) {
    97  		c := NewTestContext(t)
    98  		c.UseFilesystem()
    99  		cfg := LogConfiguration{
   100  			TelemetryEnabled:     true,
   101  			TelemetryProtocol:    "http/protobuf",
   102  			TelemetryCertificate: "missingcert.pem",
   103  		}
   104  		_, err := c.createTraceClient(cfg)
   105  		tests.RequireErrorContains(t, err, "invalid telemetry certificate")
   106  	})
   107  
   108  	t.Run("grpc, invalid timeout", func(t *testing.T) {
   109  		c := NewTestContext(t)
   110  		c.UseFilesystem()
   111  		cfg := LogConfiguration{
   112  			TelemetryEnabled:  true,
   113  			TelemetryProtocol: "http/protobuf",
   114  			TelemetryTimeout:  "300",
   115  		}
   116  		_, err := c.createTraceClient(cfg)
   117  		tests.RequireErrorContains(t, err, "invalid telemetry timeout")
   118  	})
   119  
   120  	t.Run("http, invalid compression defaults to none", func(t *testing.T) {
   121  		c := NewTestContext(t)
   122  		c.UseFilesystem()
   123  		cfg := LogConfiguration{
   124  			TelemetryEnabled:     true,
   125  			TelemetryProtocol:    "http/protobuf",
   126  			TelemetryCompression: "oops",
   127  		}
   128  		_, err := c.createTraceClient(cfg)
   129  		require.NoError(t, err)
   130  	})
   131  
   132  	t.Run("invalid protocol", func(t *testing.T) {
   133  		c := NewTestContext(t)
   134  		cfg := LogConfiguration{
   135  			TelemetryEnabled:  true,
   136  			TelemetryProtocol: "oops",
   137  		}
   138  		_, err := c.createTraceClient(cfg)
   139  		tests.RequireErrorContains(t, err, "invalid OTEL_EXPORTER_OTLP_PROTOCOL value")
   140  	})
   141  }