feat(compression): Add the option of configuring compression levels

.chloggen/configure-compression-levels.yaml

@@ -0,0 +1,25 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: 'enhancement'
+
+# The name of the component, or a single word describing the area of concern, (e.g. otlpreceiver)
+component: confighttp
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Added support for configuring compression levels.
+
+# One or more tracking issues or pull requests related to the change
+issues: [10467]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:
+
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: [user, api]

config/configcompression/compressiontype.go

@@ -3,20 +3,31 @@
 
 package configcompression // import "go.opentelemetry.io/collector/config/configcompression"
 
-import "fmt"
+import (
+	"fmt"
+
+	"github.com/klauspost/compress/zlib"
+)
 
 // Type represents a compression method
 type Type string
+type Level int
+
+type TypeWithLevel struct {
+	Type  Type  `mapstructure:"type"`
+	Level Level `mapstructure:"level"`
+}
 
 const (
-	TypeGzip    Type = "gzip"
-	TypeZlib    Type = "zlib"
-	TypeDeflate Type = "deflate"
-	TypeSnappy  Type = "snappy"
-	TypeZstd    Type = "zstd"
-	TypeLz4     Type = "lz4"
-	typeNone    Type = "none"
-	typeEmpty   Type = ""
+	TypeGzip    Type  = "gzip"
+	TypeZlib    Type  = "zlib"
+	TypeDeflate Type  = "deflate"
+	TypeSnappy  Type  = "snappy"
+	TypeZstd    Type  = "zstd"
+	TypeLz4     Type  = "lz4"
+	typeNone    Type  = "none"
+	typeEmpty   Type  = ""
+	LevelNone   Level = 0
 )
 
 // IsCompressed returns false if CompressionType is nil, none, or empty.
@@ -25,7 +36,7 @@
 	return *ct != typeEmpty && *ct != typeNone
 }
 
-func (ct *Type) UnmarshalText(in []byte) error {
+func (ct *TypeWithLevel) UnmarshalText(in []byte) error {
 	typ := Type(in)
 	if typ == TypeGzip ||
 		typ == TypeZlib ||
@@ -35,8 +46,33 @@
 		typ == TypeLz4 ||
 		typ == typeNone ||
 		typ == typeEmpty {
-		*ct = typ
+		*&ct.Type = typ
 		return nil
 	}
 	return fmt.Errorf("unsupported compression type %q", typ)
 }
+
+func (ct *TypeWithLevel) Validate() error {
+	if (ct.Type == TypeGzip && isValidLevel(int(ct.Level))) ||
+		(ct.Type == TypeZlib && isValidLevel(int(ct.Level))) ||
+		(ct.Type == TypeDeflate && isValidLevel(int(ct.Level))) ||
+		ct.Type == TypeSnappy ||
+		ct.Type == TypeLz4 ||
+		ct.Type == TypeZstd ||
+		ct.Type == typeNone ||
+		ct.Type == typeEmpty {
+		return nil
+	}
+
+	return fmt.Errorf("unsupported compression type and level %s - %d", ct.Type, ct.Level)
+}
+
+// Checks the validity of zlib/gzip/flate compression levels
+func isValidLevel(level int) bool {
+	return level == zlib.DefaultCompression ||
+		level == int(LevelNone) ||
+		level == zlib.HuffmanOnly ||
+		level == zlib.NoCompression ||
+		level == zlib.BestSpeed ||
+		(level >= zlib.BestSpeed && level <= zlib.BestCompression)
+}

config/configcompression/compressiontype_test.go

@@ -71,15 +71,15 @@ func TestUnmarshalText(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			temp := typeNone
+			var temp TypeWithLevel
 			err := temp.UnmarshalText(tt.compressionName)
 			if tt.shouldError {
 				assert.Error(t, err)
 				return
 			}
 			require.NoError(t, err)
 			ct := Type(tt.compressionName)
-			assert.Equal(t, temp, ct)
+			assert.Equal(t, temp.Type, ct)
 			assert.Equal(t, tt.isCompressed, ct.IsCompressed())
 		})
 	}

config/configcompression/go.mod

@@ -3,6 +3,7 @@ module go.opentelemetry.io/collector/config/configcompression
 go 1.22.0
 
 require (
+	github.com/klauspost/compress v1.17.9
 	github.com/stretchr/testify v1.10.0
 	go.uber.org/goleak v1.3.0
 )

config/confighttp/README.md

@@ -26,6 +26,29 @@ README](../configtls/README.md).
 - `compression`: Compression type to use among `gzip`, `zstd`, `snappy`, `zlib`, `deflate`, and `lz4`.
   - look at the documentation for the server-side of the communication.
   - `none` will be treated as uncompressed, and any other inputs will cause an error.
+  - Compression levels can now be configured as part of the compression type like below. Not specifying any compression level will result in the default.
+    - `gzip`
+      - NoCompression: `gzip/0`
+      - BestSpeed: `gzip/1`
+      - BestCompression: `gzip/9`
+      - DefaultCompression: `gzip`
+    - `zlib`
+      - NoCompression: `zlib/0`
+      - BestSpeed: `zlib/1`
+      - BestCompression: `zlib/9`
+      - DefaultCompression: `zlib`
+    - `deflate`
+      - NoCompression: `deflate/0`
+      - BestSpeed: `deflate/1`
+      - BestCompression: `deflate/9`
+      - DefaultCompression: `deflate`
+    - `zstd`
+      - SpeedFastest: `zstd/1`
+      - SpeedDefault: `zstd/3`
+      - SpeedBetterCompression: `zstd/6`
+      - SpeedBestCompression: `zstd/11`
+    - `snappy`
+      No compression levels supported yet
 - [`max_idle_conns`](https://golang.org/pkg/net/http/#Transport)
 - [`max_idle_conns_per_host`](https://golang.org/pkg/net/http/#Transport)
 - [`max_conns_per_host`](https://golang.org/pkg/net/http/#Transport)

config/confighttp/compression.go

@@ -22,7 +22,7 @@ import (
 
 type compressRoundTripper struct {
 	rt              http.RoundTripper
-	compressionType configcompression.Type
+	compressionType configcompression.TypeWithLevel
 	compressor      *compressor
 }
 
@@ -76,7 +76,7 @@ var availableDecoders = map[string]func(body io.ReadCloser) (io.ReadCloser, erro
 	},
 }
 
-func newCompressRoundTripper(rt http.RoundTripper, compressionType configcompression.Type) (*compressRoundTripper, error) {
+func newCompressRoundTripper(rt http.RoundTripper, compressionType configcompression.TypeWithLevel) (*compressRoundTripper, error) {
 	encoder, err := newCompressor(compressionType)
 	if err != nil {
 		return nil, err
@@ -112,7 +112,7 @@ func (r *compressRoundTripper) RoundTrip(req *http.Request) (*http.Response, err
 
 	// Clone the headers and add the encoding header.
 	cReq.Header = req.Header.Clone()
-	cReq.Header.Add(headerContentEncoding, string(r.compressionType))
+	cReq.Header.Add(headerContentEncoding, string(r.compressionType.Type))
 
 	return r.rt.RoundTrip(cReq)
 }