fix: move compression.go into confighttp.go

CHANGELOG.md

@@ -12,6 +12,8 @@
 ## 💡 Enhancements 💡
 
 - Remove expand cases that cannot happen with config.Map (#4649)
+- Move `compression.go` into `confighttp.go` to internalize functions in `compression.go` file. (#4651)
+  - create `configcompression` package to manage compression methods in `confighttp` and `configgrpc`
 
 ## v0.42.0 Beta
 

config/configcompression/compressionType.go

@@ -0,0 +1,49 @@
+// 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 configcompression // import "go.opentelemetry.io/collector/config/configcompression"
+
+import "fmt"
+
+type CompressionType string
+
+const (
+	Gzip    CompressionType = "gzip"
+	Zlib    CompressionType = "zlib"
+	Deflate CompressionType = "deflate"
+	Snappy  CompressionType = "snappy"
+	Zstd    CompressionType = "zstd"
+	None    CompressionType = "none"
+	Empty   CompressionType = ""
+)
+
+func IsCompressed(compressionType CompressionType) bool {
+	return compressionType != Empty && compressionType != None
+}
+
+func (ct *CompressionType) UnmarshalText(in []byte) error {
+	switch typ := CompressionType(in); typ {
+	case Gzip,
+		Zlib,
+		Deflate,
+		Snappy,
+		Zstd,
+		None,
+		Empty:
+		*ct = typ
+		return nil
+	default:
+		return fmt.Errorf("unsupported compression type %q", typ)
+	}
+}

config/configcompression/compressionType_test.go

@@ -0,0 +1,83 @@
+// 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 configcompression
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestUnmarshalText(t *testing.T) {
+	tests := []struct {
+		name            string
+		compressionName []byte
+		shouldError     bool
+	}{
+		{
+			name:            "ValidGzip",
+			compressionName: []byte("gzip"),
+			shouldError:     false,
+		},
+		{
+			name:            "ValidZlib",
+			compressionName: []byte("zlib"),
+			shouldError:     false,
+		},
+		{
+			name:            "ValidDeflate",
+			compressionName: []byte("deflate"),
+			shouldError:     false,
+		},
+		{
+			name:            "ValidSnappy",
+			compressionName: []byte("snappy"),
+			shouldError:     false,
+		},
+		{
+			name:            "ValidZstd",
+			compressionName: []byte("zstd"),
+			shouldError:     false,
+		},
+		{
+			name:            "ValidEmpty",
+			compressionName: []byte(""),
+			shouldError:     false,
+		},
+		{
+			name:            "ValidNone",
+			compressionName: []byte("none"),
+			shouldError:     false,
+		},
+		{
+			name:            "Invalid",
+			compressionName: []byte("ggip"),
+			shouldError:     true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			temp := None
+			err := temp.UnmarshalText(tt.compressionName)
+			if tt.shouldError {
+				assert.Error(t, err)
+				return
+			}
+			require.NoError(t, err)
+			assert.Equal(t, temp, CompressionType(tt.compressionName))
+		})
+	}
+}

config/configgrpc/configgrpc.go

@@ -39,6 +39,7 @@ import (
 	"go.opentelemetry.io/collector/client"
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/config/configauth"
+	"go.opentelemetry.io/collector/config/configcompression"
 	"go.opentelemetry.io/collector/config/confignet"
 	"go.opentelemetry.io/collector/config/configtls"
 	"go.opentelemetry.io/collector/internal/middleware"
@@ -66,7 +67,7 @@ type GRPCClientSettings struct {
 	Endpoint string `mapstructure:"endpoint"`
 
 	// The compression key for supported compression types within collector.
-	Compression middleware.CompressionType `mapstructure:"compression"`
+	Compression configcompression.CompressionType `mapstructure:"compression"`
 
 	// TLSSetting struct exposes TLS client configuration.
 	TLSSetting configtls.TLSClientSetting `mapstructure:"tls,omitempty"`
@@ -177,7 +178,7 @@ func (gcs *GRPCClientSettings) isSchemeHTTPS() bool {
 // ToDialOptions maps configgrpc.GRPCClientSettings to a slice of dial options for gRPC.
 func (gcs *GRPCClientSettings) ToDialOptions(host component.Host, settings component.TelemetrySettings) ([]grpc.DialOption, error) {
 	var opts []grpc.DialOption
-	if gcs.Compression != middleware.CompressionEmpty && gcs.Compression != middleware.CompressionNone {
+	if configcompression.IsCompressed(gcs.Compression) {
 		cp, err := getGRPCCompressionName(gcs.Compression)
 		if err != nil {
 			return nil, err
@@ -357,13 +358,13 @@ func (gss *GRPCServerSettings) ToServerOption(host component.Host, settings comp
 }
 
 // getGRPCCompressionName returns compression name registered in grpc.
-func getGRPCCompressionName(compressionType middleware.CompressionType) (string, error) {
+func getGRPCCompressionName(compressionType configcompression.CompressionType) (string, error) {
 	switch compressionType {
-	case middleware.CompressionGzip:
+	case configcompression.Gzip:
 		return gzip.Name, nil
-	case middleware.CompressionSnappy:
+	case configcompression.Snappy:
 		return snappy.Name, nil
-	case middleware.CompressionZstd:
+	case configcompression.Zstd:
 		return zstd.Name, nil
 	default:
 		return "", fmt.Errorf("unsupported compression type %q", compressionType)

config/configgrpc/configgrpc_test.go

@@ -36,9 +36,9 @@ import (
 	"go.opentelemetry.io/collector/component/componenttest"
 	"go.opentelemetry.io/collector/config"
 	"go.opentelemetry.io/collector/config/configauth"
+	"go.opentelemetry.io/collector/config/configcompression"
 	"go.opentelemetry.io/collector/config/confignet"
 	"go.opentelemetry.io/collector/config/configtls"
-	"go.opentelemetry.io/collector/internal/middleware"
 	"go.opentelemetry.io/collector/model/otlpgrpc"
 	"go.opentelemetry.io/collector/obsreport/obsreporttest"
 )
@@ -75,7 +75,7 @@ func TestAllGrpcClientSettings(t *testing.T) {
 					"test": "test",
 				},
 				Endpoint:    "localhost:1234",
-				Compression: middleware.CompressionGzip,
+				Compression: configcompression.Gzip,
 				TLSSetting: configtls.TLSClientSetting{
 					Insecure: false,
 				},
@@ -103,7 +103,7 @@ func TestAllGrpcClientSettings(t *testing.T) {
 					"test": "test",
 				},
 				Endpoint:    "localhost:1234",
-				Compression: middleware.CompressionSnappy,
+				Compression: configcompression.Snappy,
 				TLSSetting: configtls.TLSClientSetting{
 					Insecure: false,
 				},
@@ -131,7 +131,7 @@ func TestAllGrpcClientSettings(t *testing.T) {
 					"test": "test",
 				},
 				Endpoint:    "localhost:1234",
-				Compression: middleware.CompressionZstd,
+				Compression: configcompression.Zstd,
 				TLSSetting: configtls.TLSClientSetting{
 					Insecure: false,
 				},

internal/middleware/compression.go → config/confighttp/compression.go

@@ -1,52 +1,42 @@
-// Copyright The OpenTelemetry Authors
+// 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
+//      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 middleware // import "go.opentelemetry.io/collector/internal/middleware"
+// This file contains helper functions regarding compression/decompression for confighttp.
+
+package confighttp
 
 import (
 	"bytes"
 	"compress/gzip"
 	"compress/zlib"
-	"fmt"
 	"io"
 	"net/http"
 
 	"github.com/golang/snappy"
 	"github.com/klauspost/compress/zstd"
-)
 
-type CompressionType string
-
-const (
-	headerContentEncoding                 = "Content-Encoding"
-	CompressionGzip       CompressionType = "gzip"
-	CompressionZlib       CompressionType = "zlib"
-	CompressionDeflate    CompressionType = "deflate"
-	CompressionSnappy     CompressionType = "snappy"
-	CompressionZstd       CompressionType = "zstd"
-	CompressionNone       CompressionType = "none"
-	CompressionEmpty      CompressionType = ""
+	"go.opentelemetry.io/collector/config/configcompression"
 )
 
-type CompressRoundTripper struct {
+type compressRoundTripper struct {
 	RoundTripper    http.RoundTripper
-	compressionType CompressionType
+	compressionType configcompression.CompressionType
 	writer          func(*bytes.Buffer) (io.WriteCloser, error)
 }
 
-func NewCompressRoundTripper(rt http.RoundTripper, compressionType CompressionType) *CompressRoundTripper {
-	return &CompressRoundTripper{
+func newCompressRoundTripper(rt http.RoundTripper, compressionType configcompression.CompressionType) *compressRoundTripper {
+	return &compressRoundTripper{
 		RoundTripper:    rt,
 		compressionType: compressionType,
 		writer:          writerFactory(compressionType),
@@ -55,29 +45,29 @@ func NewCompressRoundTripper(rt http.RoundTripper, compressionType CompressionTy
 
 // writerFactory defines writer field in CompressRoundTripper.
 // The validity of input is already checked when NewCompressRoundTripper was called in confighttp,
-func writerFactory(compressionType CompressionType) func(*bytes.Buffer) (io.WriteCloser, error) {
+func writerFactory(compressionType configcompression.CompressionType) func(*bytes.Buffer) (io.WriteCloser, error) {
 	switch compressionType {
-	case CompressionGzip:
+	case configcompression.Gzip:
 		return func(buf *bytes.Buffer) (io.WriteCloser, error) {
 			return gzip.NewWriter(buf), nil
 		}
-	case CompressionSnappy:
+	case configcompression.Snappy:
 		return func(buf *bytes.Buffer) (io.WriteCloser, error) {
 			return snappy.NewBufferedWriter(buf), nil
 		}
-	case CompressionZstd:
+	case configcompression.Zstd:
 		return func(buf *bytes.Buffer) (io.WriteCloser, error) {
 			return zstd.NewWriter(buf)
 		}
-	case CompressionZlib, CompressionDeflate:
+	case configcompression.Zlib, configcompression.Deflate:
 		return func(buf *bytes.Buffer) (io.WriteCloser, error) {
 			return zlib.NewWriter(buf), nil
 		}
 	}
 	return nil
 }
 
-func (r *CompressRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
+func (r *compressRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
 	if req.Header.Get(headerContentEncoding) != "" {
 		// If the header already specifies a content encoding then skip compression
 		// since we don't want to compress it again. This is a safeguard that normally
@@ -121,29 +111,25 @@ func (r *CompressRoundTripper) RoundTrip(req *http.Request) (*http.Response, err
 	return r.RoundTripper.RoundTrip(cReq)
 }
 
-func (r *CompressRoundTripper) CompressionType() CompressionType {
-	return r.compressionType
-}
-
-type ErrorHandler func(w http.ResponseWriter, r *http.Request, errorMsg string, statusCode int)
+type errorHandler func(w http.ResponseWriter, r *http.Request, errorMsg string, statusCode int)
 
 type decompressor struct {
-	errorHandler ErrorHandler
+	errorHandler
 }
 
-type DecompressorOption func(d *decompressor)
+type decompressorOption func(d *decompressor)
 
-func WithErrorHandler(e ErrorHandler) DecompressorOption {
+func withErrorHandlerForDecompressor(e errorHandler) decompressorOption {
 	return func(d *decompressor) {
 		d.errorHandler = e
 	}
 }
 
-// HTTPContentDecompressor is a middleware that offloads the task of handling compressed
-// HTTP requests by identifying the compression format in the "Content-Encoding" header and re-writing
+// httpContentDecompressor offloads the task of handling compressed HTTP requests
+// by identifying the compression format in the "Content-Encoding" header and re-writing
 // request body so that the handlers further in the chain can work on decompressed data.
 // It supports gzip and deflate/zlib compression.
-func HTTPContentDecompressor(h http.Handler, opts ...DecompressorOption) http.Handler {
+func httpContentDecompressor(h http.Handler, opts ...decompressorOption) http.Handler {
 	d := &decompressor{}
 	for _, o := range opts {
 		o(d)
@@ -197,19 +183,3 @@ func newBodyReader(r *http.Request) (io.ReadCloser, error) {
 func defaultErrorHandler(w http.ResponseWriter, _ *http.Request, errMsg string, statusCode int) {
 	http.Error(w, errMsg, statusCode)
 }
-
-func (ct *CompressionType) UnmarshalText(in []byte) error {
-	switch typ := CompressionType(in); typ {
-	case CompressionGzip,
-		CompressionZlib,
-		CompressionDeflate,
-		CompressionSnappy,
-		CompressionZstd,
-		CompressionNone,
-		CompressionEmpty:
-		*ct = typ
-		return nil
-	default:
-		return fmt.Errorf("unsupported compression type %q", typ)
-	}
-}