From a133a8efefbe34dd45d8d4c8473ebbd75f4bdcc3 Mon Sep 17 00:00:00 2001
From: Dominik Rosiek <58699848+sumo-drosiek@users.noreply.github.com>
Date: Mon, 13 May 2024 10:05:36 +0200
Subject: [PATCH] [exporter/sumologic] change logs behavior (#32939)

**Description:**

  * set OTLP as default format
  * add support for OTLP format
  * do not support metadata attributes
  * do not support source headers

**Link to tracking Issue:** #32315

**Testing:**

* unit tests

**Documentation:**

* inline comments
* readme

---------

Signed-off-by: Dominik Rosiek <drosiek@sumologic.com>
---
 .chloggen/drosiek-exporter-logs.yaml        |  31 +
 exporter/sumologicexporter/README.md        |  43 +-
 exporter/sumologicexporter/compress.go      |  77 --
 exporter/sumologicexporter/compress_test.go | 142 ---
 exporter/sumologicexporter/config.go        |  36 +-
 exporter/sumologicexporter/config_test.go   |  99 +-
 exporter/sumologicexporter/exporter.go      | 113 +--
 exporter/sumologicexporter/exporter_test.go | 275 ++++--
 exporter/sumologicexporter/factory.go       |   2 -
 exporter/sumologicexporter/factory_test.go  |  13 +-
 exporter/sumologicexporter/go.mod           |   2 +-
 exporter/sumologicexporter/sender.go        | 205 +++--
 exporter/sumologicexporter/sender_test.go   | 941 ++++++++++++++------
 13 files changed, 1117 insertions(+), 862 deletions(-)
 create mode 100644 .chloggen/drosiek-exporter-logs.yaml
 delete mode 100644 exporter/sumologicexporter/compress.go
 delete mode 100644 exporter/sumologicexporter/compress_test.go

diff --git a/.chloggen/drosiek-exporter-logs.yaml b/.chloggen/drosiek-exporter-logs.yaml
new file mode 100644
index 000000000000..c0181af0e02d
--- /dev/null
+++ b/.chloggen/drosiek-exporter-logs.yaml
@@ -0,0 +1,31 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: breaking
+
+# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver)
+component: sumologicexporter
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: change logs behavior
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [31479]
+
+# (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: |
+  * set OTLP as default format
+  * add support for OTLP format
+  * do not support metadata attributes
+  * do not support source headers
+
+# If your change doesn't affect end users or the exported elements of any package,
+# you should instead start your pull request title with [chore] or use the "Skip Changelog" label.
+# 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]
diff --git a/exporter/sumologicexporter/README.md b/exporter/sumologicexporter/README.md
index c678df2c3213..39267e26e61e 100644
--- a/exporter/sumologicexporter/README.md
+++ b/exporter/sumologicexporter/README.md
@@ -18,7 +18,7 @@
 
 For some time we have been developing the [new Sumo Logic exporter](https://github.com/SumoLogic/sumologic-otel-collector/tree/main/pkg/exporter/sumologicexporter#sumo-logic-exporter) and now we are in the process of moving it into this repository.
 
-The following options are deprecated for logs and already do not work for metrics:
+The following options are no longer supported:
 
 - `metric_format: {carbon2, graphite}`
 - `metadata_attributes: [<regex>]`
@@ -30,7 +30,7 @@ The following options are deprecated for logs and already do not work for metric
 After the new exporter will be moved to this repository:
 
 - `carbon2` and `graphite` are no longer supported and `prometheus` or `otlp` format should be used
-- all resource level attributes are going to be treated (are treated for metrics) as `metadata_attributes`. You can use [Group by Attributes processor](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/groupbyattrsprocessor) to move attributes from record level to resource level. For example:
+- all resource level attributes are treated as `metadata_attributes` so this option is no longer supported. You can use [Group by Attributes processor](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/groupbyattrsprocessor) to move attributes from record level to resource level. For example:
 
   ```yaml
   # before switch to new collector
@@ -45,7 +45,7 @@ After the new exporter will be moved to this repository:
         - my_attribute
   ```
 
-- Source templates (`source_category`, `source_name` and `source_host`) are going to be removed from the exporter and sources may be set using `_sourceCategory`, `sourceName` or `_sourceHost` resource attributes.  This feature has been already disabled for metrics. We recommend to use [Transform Processor](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/transformprocessor/). For example:
+- Source templates (`source_category`, `source_name` and `source_host`) are no longer supported. We recommend to use [Transform Processor](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/transformprocessor/). For example:
 
   ```yaml
   # before switch to new collector
@@ -88,12 +88,12 @@ exporters:
     # List of regexes for attributes which should be send as metadata
     # default = []
     #
-    # This option is deprecated:
+    # This option is unsupported:
     # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/sumologicexporter#migration-to-new-architecture
     metadata_attributes: [<regex>]
 
-    # format to use when sending logs to Sumo Logic, default = json,
-    log_format: {json, text}
+    # format to use when sending logs to Sumo Logic, default = otlp,
+    log_format: {otlp, json, text}
 
     # format to use when sending metrics to Sumo Logic, default = otlp,
     # NOTE: only `otlp` is supported when used with sumologicextension
@@ -112,7 +112,7 @@ exporters:
     # Please regfer to Source temmplates for formatting explanation:
     # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/sumologicexporter#source-templates
     #
-    # This option is deprecated:
+    # This option is unsupported:
     # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/sumologicexporter#migration-to-new-architecture
     graphite_template: <template>
 
@@ -121,7 +121,7 @@ exporters:
     # Please regfer to Source temmplates for formatting explanation:
     # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/sumologicexporter#source-templates
     #
-    # This option is deprecated:
+    # This option is unsupported:
     # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/sumologicexporter#migration-to-new-architecture
     source_category: <template>
 
@@ -130,7 +130,7 @@ exporters:
     # Please regfer to Source temmplates for formatting explanation:
     # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/sumologicexporter#source-templates
     #
-    # This option is deprecated:
+    # This option is unsupported:
     # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/sumologicexporter#migration-to-new-architecture
     source_name: <template>
 
@@ -139,7 +139,7 @@ exporters:
     # Please regfer to Source temmplates for formatting explanation:
     # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/sumologicexporter#source-templates
     #
-    # This option is deprecated:
+    # This option is unsupported:
     # https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter/sumologicexporter#migration-to-new-architecture
     source_host: <template>
 
@@ -183,25 +183,4 @@ exporters:
 
 ## Source Templates
 
-You can specify a template with an attribute for `source_category`, `source_name`, `source_host` or `graphite_template` using `%{attr_name}`.
-
-For example, when there is an attribute `my_attr`: `my_value`, `metrics/%{my_attr}` would be expanded to `metrics/my_value`.
-
-For `graphite_template`, in addition to above, `%{_metric_}` is going to be replaced with metric name.
-
-## Example Configuration
-
-```yaml
-exporters:
-  sumologic:
-    endpoint: http://localhost:3000
-    compress_encoding: "gzip"
-    max_request_body_size: "1_048_576"  # 1MB
-    log_format: "text"
-    metric_format: "prometheus"
-    source_category: "custom category"
-    source_name: "custom name"
-    source_host: "custom host"
-    metadata_attributes:
-      - k8s.*
-```
+Source Templates are no longer supported. Please follow [Migration to new architecture](#migration-to-new-architecture)
diff --git a/exporter/sumologicexporter/compress.go b/exporter/sumologicexporter/compress.go
deleted file mode 100644
index e18df4bc9286..000000000000
--- a/exporter/sumologicexporter/compress.go
+++ /dev/null
@@ -1,77 +0,0 @@
-// Copyright The OpenTelemetry Authors
-// SPDX-License-Identifier: Apache-2.0
-
-package sumologicexporter // import "github.com/open-telemetry/opentelemetry-collector-contrib/exporter/sumologicexporter"
-
-import (
-	"bytes"
-	"compress/flate"
-	"compress/gzip"
-	"fmt"
-	"io"
-)
-
-type compressor struct {
-	format CompressEncodingType
-	writer encoder
-	buf    bytes.Buffer
-}
-
-type encoder interface {
-	io.WriteCloser
-	Reset(dst io.Writer)
-}
-
-// newCompressor takes encoding format and returns compressor struct and error eventually
-func newCompressor(format CompressEncodingType) (compressor, error) {
-	var (
-		writer encoder
-		err    error
-	)
-
-	switch format {
-	case GZIPCompression:
-		writer = gzip.NewWriter(io.Discard)
-	case DeflateCompression:
-		writer, err = flate.NewWriter(io.Discard, flate.BestSpeed)
-		if err != nil {
-			return compressor{}, err
-		}
-	case NoCompression:
-		writer = nil
-	default:
-		return compressor{}, fmt.Errorf("invalid format: %s", format)
-	}
-
-	return compressor{
-		format: format,
-		writer: writer,
-	}, nil
-}
-
-// compress takes a reader with uncompressed data and returns
-// a reader with the same data compressed using c.writer
-func (c *compressor) compress(data io.Reader) (io.Reader, error) {
-	if c.writer == nil {
-		return data, nil
-	}
-
-	var dataBytes bytes.Buffer
-	if _, err := dataBytes.ReadFrom(data); err != nil {
-		return nil, err
-	}
-
-	// Reset c.buf to start with empty message
-	c.buf.Reset()
-	c.writer.Reset(&c.buf)
-
-	if _, err := c.writer.Write(dataBytes.Bytes()); err != nil {
-		return nil, err
-	}
-
-	if err := c.writer.Close(); err != nil {
-		return nil, err
-	}
-
-	return bytes.NewReader(c.buf.Bytes()), nil
-}
diff --git a/exporter/sumologicexporter/compress_test.go b/exporter/sumologicexporter/compress_test.go
deleted file mode 100644
index 0300e4f7cc5d..000000000000
--- a/exporter/sumologicexporter/compress_test.go
+++ /dev/null
@@ -1,142 +0,0 @@
-// Copyright The OpenTelemetry Authors
-// SPDX-License-Identifier: Apache-2.0
-
-package sumologicexporter
-
-import (
-	"compress/flate"
-	"compress/gzip"
-	"errors"
-	"io"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-type mockedEncrypter struct {
-	writeError error
-	closeError error
-}
-
-func (e mockedEncrypter) Reset(_ io.Writer) {
-}
-
-func (e mockedEncrypter) Write(_ []byte) (n int, err error) {
-	return 0, e.writeError
-}
-
-func (e mockedEncrypter) Close() error {
-	return e.closeError
-}
-
-func getTestCompressor(w error, c error) compressor {
-	return compressor{
-		format: GZIPCompression,
-		writer: mockedEncrypter{
-			writeError: w,
-			closeError: c,
-		},
-	}
-}
-
-type mockedReader struct{}
-
-func (r mockedReader) Read(_ []byte) (n int, err error) {
-	return 0, errors.New("read error")
-}
-
-func TestCompressGzip(t *testing.T) {
-	const message = "This is an example log"
-
-	c, err := newCompressor(GZIPCompression)
-	require.NoError(t, err)
-
-	body := strings.NewReader(message)
-
-	data, err := c.compress(body)
-	require.NoError(t, err)
-
-	assert.Equal(t, message, decodeGzip(t, data))
-}
-
-func TestCompressTwice(t *testing.T) {
-	const (
-		message       = "This is an example log"
-		secondMessage = "This is an another example log"
-	)
-
-	c, err := newCompressor(GZIPCompression)
-	require.NoError(t, err)
-
-	body := strings.NewReader(message)
-
-	data, err := c.compress(body)
-	require.NoError(t, err)
-	assert.Equal(t, message, decodeGzip(t, data))
-
-	body = strings.NewReader(secondMessage)
-	data, err = c.compress(body)
-	require.NoError(t, err)
-	assert.Equal(t, secondMessage, decodeGzip(t, data))
-}
-
-func decodeGzip(t *testing.T, data io.Reader) string {
-	r, err := gzip.NewReader(data)
-	require.NoError(t, err)
-
-	var buf []byte
-	buf, err = io.ReadAll(r)
-	require.NoError(t, err)
-
-	return string(buf)
-}
-
-func TestCompressDeflate(t *testing.T) {
-	const message = "This is an example log"
-
-	c, err := newCompressor(DeflateCompression)
-	require.NoError(t, err)
-
-	body := strings.NewReader(message)
-
-	data, err := c.compress(body)
-	require.NoError(t, err)
-
-	assert.Equal(t, message, decodeDeflate(t, data))
-}
-
-func decodeDeflate(t *testing.T, data io.Reader) string {
-	r := flate.NewReader(data)
-
-	var buf []byte
-	buf, err := io.ReadAll(r)
-	require.NoError(t, err)
-
-	return string(buf)
-}
-
-func TestCompressReadError(t *testing.T) {
-	c := getTestCompressor(nil, nil)
-	r := mockedReader{}
-	_, err := c.compress(r)
-
-	assert.EqualError(t, err, "read error")
-}
-
-func TestCompressWriteError(t *testing.T) {
-	c := getTestCompressor(errors.New("write error"), nil)
-	r := strings.NewReader("test string")
-	_, err := c.compress(r)
-
-	assert.EqualError(t, err, "write error")
-}
-
-func TestCompressCloseError(t *testing.T) {
-	c := getTestCompressor(nil, errors.New("close error"))
-	r := strings.NewReader("test string")
-	_, err := c.compress(r)
-
-	assert.EqualError(t, err, "close error")
-}
diff --git a/exporter/sumologicexporter/config.go b/exporter/sumologicexporter/config.go
index 55d5190b5139..c8746534969c 100644
--- a/exporter/sumologicexporter/config.go
+++ b/exporter/sumologicexporter/config.go
@@ -11,6 +11,7 @@ import (
 
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/config/configauth"
+	"go.opentelemetry.io/collector/config/configcompression"
 	"go.opentelemetry.io/collector/config/confighttp"
 	"go.opentelemetry.io/collector/config/configretry"
 	"go.opentelemetry.io/collector/exporter/exporterhelper"
@@ -26,7 +27,8 @@ type Config struct {
 
 	// Compression encoding format, either empty string, gzip or deflate (default gzip)
 	// Empty string means no compression
-	CompressEncoding CompressEncodingType `mapstructure:"compress_encoding"`
+	// NOTE: CompressEncoding is deprecated and will be removed in an upcoming release
+	CompressEncoding configcompression.Type `mapstructure:"compress_encoding"`
 	// Max HTTP request body size in bytes before compression (if applied).
 	// By default 1MB is recommended.
 	MaxRequestBodySize int `mapstructure:"max_request_body_size"`
@@ -67,7 +69,8 @@ type Config struct {
 // createDefaultClientConfig returns default http client settings
 func createDefaultClientConfig() confighttp.ClientConfig {
 	return confighttp.ClientConfig{
-		Timeout: defaultTimeout,
+		Timeout:     defaultTimeout,
+		Compression: DefaultCompressEncoding,
 		Auth: &configauth.Authentication{
 			AuthenticatorID: component.NewID(sumologicextension.NewFactory().Type()),
 		},
@@ -92,6 +95,8 @@ const (
 	// JSONFormat represents log_format: json
 	JSONFormat LogFormatType = "json"
 	// RemovedGraphiteFormat represents the no longer supported graphite metric format
+	OTLPLogFormat LogFormatType = "otlp"
+	// RemovedGraphiteFormat represents the no longer supported graphite metric format
 	RemovedGraphiteFormat MetricFormatType = "graphite"
 	// RemovedCarbon2Format represents the no longer supported carbon2 metric format
 	RemovedCarbon2Format MetricFormatType = "carbon2"
@@ -99,12 +104,8 @@ const (
 	PrometheusFormat MetricFormatType = "prometheus"
 	// OTLPMetricFormat represents metric_format: otlp
 	OTLPMetricFormat MetricFormatType = "otlp"
-	// GZIPCompression represents compress_encoding: gzip
-	GZIPCompression CompressEncodingType = "gzip"
-	// DeflateCompression represents compress_encoding: deflate
-	DeflateCompression CompressEncodingType = "deflate"
 	// NoCompression represents disabled compression
-	NoCompression CompressEncodingType = ""
+	NoCompression configcompression.Type = ""
 	// MetricsPipeline represents metrics pipeline
 	MetricsPipeline PipelineType = "metrics"
 	// LogsPipeline represents metrics pipeline
@@ -114,11 +115,11 @@ const (
 	// DefaultCompress defines default Compress
 	DefaultCompress bool = true
 	// DefaultCompressEncoding defines default CompressEncoding
-	DefaultCompressEncoding CompressEncodingType = "gzip"
+	DefaultCompressEncoding configcompression.Type = "gzip"
 	// DefaultMaxRequestBodySize defines default MaxRequestBodySize in bytes
 	DefaultMaxRequestBodySize int = 1 * 1024 * 1024
 	// DefaultLogFormat defines default LogFormat
-	DefaultLogFormat LogFormatType = JSONFormat
+	DefaultLogFormat LogFormatType = OTLPLogFormat
 	// DefaultMetricFormat defines default MetricFormat
 	DefaultMetricFormat MetricFormatType = OTLPMetricFormat
 	// DefaultSourceCategory defines default SourceCategory
@@ -129,12 +130,15 @@ const (
 	DefaultSourceHost string = ""
 	// DefaultClient defines default Client
 	DefaultClient string = "otelcol"
+	// DefaultLogKey defines default LogKey value
+	DefaultLogKey string = "log"
 	// DefaultGraphiteTemplate defines default template for Graphite
 	DefaultGraphiteTemplate string = "%{_metric_}"
 )
 
 func (cfg *Config) Validate() error {
 	switch cfg.LogFormat {
+	case OTLPLogFormat:
 	case JSONFormat:
 	case TextFormat:
 	default:
@@ -143,21 +147,23 @@ func (cfg *Config) Validate() error {
 
 	switch cfg.MetricFormat {
 	case RemovedGraphiteFormat:
-		fallthrough
+		return fmt.Errorf("support for the graphite metric format was removed, please use prometheus or otlp instead")
 	case RemovedCarbon2Format:
-		return fmt.Errorf("%s metric format is no longer supported", cfg.MetricFormat)
+		return fmt.Errorf("support for the carbon2 metric format was removed, please use prometheus or otlp instead")
 	case PrometheusFormat:
 	case OTLPMetricFormat:
 	default:
 		return fmt.Errorf("unexpected metric format: %s", cfg.MetricFormat)
 	}
 
-	switch cfg.CompressEncoding {
-	case GZIPCompression:
-	case DeflateCompression:
+	switch cfg.ClientConfig.Compression {
+	case configcompression.TypeGzip:
+	case configcompression.TypeDeflate:
+	case configcompression.TypeZstd:
 	case NoCompression:
+
 	default:
-		return fmt.Errorf("unexpected compression encoding: %s", cfg.CompressEncoding)
+		return fmt.Errorf("invalid compression encoding type: %v", cfg.ClientConfig.Compression)
 	}
 
 	if len(cfg.ClientConfig.Endpoint) == 0 && cfg.ClientConfig.Auth == nil {
diff --git a/exporter/sumologicexporter/config_test.go b/exporter/sumologicexporter/config_test.go
index d0353b4c0c2f..3f335ec7bb42 100644
--- a/exporter/sumologicexporter/config_test.go
+++ b/exporter/sumologicexporter/config_test.go
@@ -4,113 +4,94 @@
 package sumologicexporter
 
 import (
+	"errors"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
+	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/config/confighttp"
-	"go.opentelemetry.io/collector/exporter/exporterhelper"
 )
 
-func TestConfigValidation(t *testing.T) {
+func TestInitExporterInvalidConfiguration(t *testing.T) {
 	testcases := []struct {
-		name        string
-		cfg         *Config
-		expectedErr string
+		name          string
+		cfg           *Config
+		expectedError error
 	}{
 		{
-			name: "invalid log format",
+			name:          "unexpected log format",
+			expectedError: errors.New("unexpected log format: test_format"),
 			cfg: &Config{
-				LogFormat:        "test_format",
-				MetricFormat:     "otlp",
-				CompressEncoding: "gzip",
+				LogFormat:    "test_format",
+				MetricFormat: "otlp",
 				ClientConfig: confighttp.ClientConfig{
 					Timeout:  defaultTimeout,
 					Endpoint: "test_endpoint",
 				},
 			},
-			expectedErr: "unexpected log format: test_format",
 		},
 		{
-			name: "invalid metric format",
+			name:          "unexpected metric format",
+			expectedError: errors.New("unexpected metric format: test_format"),
 			cfg: &Config{
 				LogFormat:    "json",
 				MetricFormat: "test_format",
 				ClientConfig: confighttp.ClientConfig{
-					Timeout:  defaultTimeout,
-					Endpoint: "test_endpoint",
+					Timeout:     defaultTimeout,
+					Endpoint:    "test_endpoint",
+					Compression: "gzip",
 				},
-				CompressEncoding: "gzip",
 			},
-			expectedErr: "unexpected metric format: test_format",
 		},
 		{
-			name: "invalid compress encoding",
+			name:          "unsupported Carbon2 metrics format",
+			expectedError: errors.New("support for the carbon2 metric format was removed, please use prometheus or otlp instead"),
 			cfg: &Config{
-				LogFormat:        "json",
-				MetricFormat:     "otlp",
-				CompressEncoding: "test_format",
-				ClientConfig: confighttp.ClientConfig{
-					Timeout:  defaultTimeout,
-					Endpoint: "test_endpoint",
-				},
-			},
-			expectedErr: "unexpected compression encoding: test_format",
-		},
-		{
-			name:        "no endpoint and no auth extension specified",
-			expectedErr: "no endpoint and no auth extension specified",
-			cfg: &Config{
-				LogFormat:        "json",
-				MetricFormat:     "otlp",
-				CompressEncoding: "gzip",
+				LogFormat:    "json",
+				MetricFormat: "carbon2",
 				ClientConfig: confighttp.ClientConfig{
-					Timeout: defaultTimeout,
+					Timeout:     defaultTimeout,
+					Endpoint:    "test_endpoint",
+					Compression: "gzip",
 				},
 			},
 		},
 		{
-			name: "invalid log format",
+			name:          "unsupported Graphite metrics format",
+			expectedError: errors.New("support for the graphite metric format was removed, please use prometheus or otlp instead"),
 			cfg: &Config{
-				LogFormat:        "json",
-				MetricFormat:     "otlp",
-				CompressEncoding: "gzip",
+				LogFormat:    "json",
+				MetricFormat: "graphite",
 				ClientConfig: confighttp.ClientConfig{
-					Timeout:  defaultTimeout,
-					Endpoint: "test_endpoint",
-				},
-				QueueSettings: exporterhelper.QueueSettings{
-					Enabled:   true,
-					QueueSize: -10,
+					Timeout:     defaultTimeout,
+					Endpoint:    "test_endpoint",
+					Compression: "gzip",
 				},
 			},
-			expectedErr: "queue settings has invalid configuration: queue size must be positive",
 		},
 		{
-			name: "valid config",
+			name:          "no endpoint and no auth extension specified",
+			expectedError: errors.New("no endpoint and no auth extension specified"),
 			cfg: &Config{
-				LogFormat:        "json",
-				MetricFormat:     "otlp",
-				CompressEncoding: "gzip",
+				LogFormat:    "json",
+				MetricFormat: "otlp",
 				ClientConfig: confighttp.ClientConfig{
-					Timeout:  defaultTimeout,
-					Endpoint: "test_endpoint",
+					Timeout:     defaultTimeout,
+					Compression: "gzip",
 				},
 			},
-			expectedErr: "",
 		},
 	}
 
 	for _, tc := range testcases {
+		tc := tc
 		t.Run(tc.name, func(t *testing.T) {
+			err := component.ValidateConfig(tc.cfg)
 
-			err := tc.cfg.Validate()
-
-			if tc.expectedErr == "" {
-				assert.NoError(t, err)
+			if tc.expectedError != nil {
+				assert.EqualError(t, err, tc.expectedError.Error())
 			} else {
-				require.Error(t, err)
-				assert.EqualError(t, err, tc.expectedErr)
+				assert.NoError(t, err)
 			}
 		})
 	}
diff --git a/exporter/sumologicexporter/exporter.go b/exporter/sumologicexporter/exporter.go
index f7aa0bdf63fb..9eca025ecd7c 100644
--- a/exporter/sumologicexporter/exporter.go
+++ b/exporter/sumologicexporter/exporter.go
@@ -14,7 +14,6 @@ import (
 	"sync"
 
 	"go.opentelemetry.io/collector/component"
-	"go.opentelemetry.io/collector/config/configcompression"
 	"go.opentelemetry.io/collector/consumer/consumererror"
 	"go.opentelemetry.io/collector/exporter"
 	"go.opentelemetry.io/collector/exporter/exporterhelper"
@@ -166,7 +165,7 @@ func (se *sumologicexporter) configure(ctx context.Context) error {
 	)
 
 	if se.config.CompressEncoding != NoCompression {
-		se.config.ClientConfig.Compression = configcompression.Type(se.config.CompressEncoding)
+		se.config.ClientConfig.Compression = se.config.CompressEncoding
 	}
 
 	httpSettings := se.config.ClientConfig
@@ -279,18 +278,6 @@ func (se *sumologicexporter) shutdown(context.Context) error {
 // It returns the number of unsent logs and an error which contains a list of dropped records
 // so they can be handled by OTC retry mechanism
 func (se *sumologicexporter) pushLogsData(ctx context.Context, ld plog.Logs) error {
-	var (
-		currentMetadata  fields
-		previousMetadata = newFields(pcommon.NewMap())
-		errs             []error
-		droppedRecords   []plog.LogRecord
-		err              error
-	)
-
-	c, err := newCompressor(se.config.CompressEncoding)
-	if err != nil {
-		return consumererror.NewLogs(fmt.Errorf("failed to initialize compressor: %w", err), ld)
-	}
 	logsURL, metricsURL, tracesURL := se.getDataURLs()
 	sdr := newSender(
 		se.logger,
@@ -298,7 +285,6 @@ func (se *sumologicexporter) pushLogsData(ctx context.Context, ld plog.Logs) err
 		se.getHTTPClient(),
 		se.filter,
 		se.sources,
-		c,
 		se.prometheusFormatter,
 		metricsURL,
 		logsURL,
@@ -306,68 +292,60 @@ func (se *sumologicexporter) pushLogsData(ctx context.Context, ld plog.Logs) err
 		se.id,
 	)
 
+	// Follow different execution path for OTLP format
+	if sdr.config.LogFormat == OTLPLogFormat {
+		if err := sdr.sendOTLPLogs(ctx, ld); err != nil {
+			se.handleUnauthorizedErrors(ctx, err)
+			return consumererror.NewLogs(err, ld)
+		}
+		return nil
+	}
+
+	type droppedResourceRecords struct {
+		resource pcommon.Resource
+		records  []plog.LogRecord
+	}
+	var (
+		errs    []error
+		dropped []droppedResourceRecords
+	)
+
 	// Iterate over ResourceLogs
 	rls := ld.ResourceLogs()
 	for i := 0; i < rls.Len(); i++ {
 		rl := rls.At(i)
 
-		ills := rl.ScopeLogs()
-		// iterate over ScopeLogs
-		for j := 0; j < ills.Len(); j++ {
-			sl := ills.At(j)
-
-			// iterate over Logs
-			logs := sl.LogRecords()
-			for k := 0; k < logs.Len(); k++ {
-				log := logs.At(k)
-
-				currentMetadata = sdr.filter.mergeAndFilterIn(rl.Resource().Attributes(), log.Attributes())
-
-				// If metadata differs from currently buffered, flush the buffer
-				if currentMetadata.string() != previousMetadata.string() && previousMetadata.string() != "" {
-					var dropped []plog.LogRecord
-					dropped, err = sdr.sendLogs(ctx, previousMetadata)
-					if err != nil {
-						errs = append(errs, err)
-						droppedRecords = append(droppedRecords, dropped...)
-					}
-					sdr.cleanLogsBuffer()
-				}
-
-				// assign metadata
-				previousMetadata = currentMetadata
-
-				// add log to the buffer
-				var dropped []plog.LogRecord
-				dropped, err = sdr.batchLog(ctx, log, previousMetadata)
-				if err != nil {
-					droppedRecords = append(droppedRecords, dropped...)
-					errs = append(errs, err)
-				}
-			}
+		currentMetadata := newFields(rl.Resource().Attributes())
+
+		if droppedRecords, err := sdr.sendNonOTLPLogs(ctx, rl, currentMetadata); err != nil {
+			dropped = append(dropped, droppedResourceRecords{
+				resource: rl.Resource(),
+				records:  droppedRecords,
+			})
+			errs = append(errs, err)
 		}
 	}
 
-	// Flush pending logs
-	dropped, err := sdr.sendLogs(ctx, previousMetadata)
-	if err != nil {
-		droppedRecords = append(droppedRecords, dropped...)
-		errs = append(errs, err)
-	}
+	if len(dropped) > 0 {
+		ld = plog.NewLogs()
 
-	if len(droppedRecords) > 0 {
-		// Move all dropped records to Logs
-		droppedLogs := plog.NewLogs()
-		rls = droppedLogs.ResourceLogs()
-		ills := rls.AppendEmpty().ScopeLogs()
-		logs := ills.AppendEmpty().LogRecords()
+		// Copy all dropped records to Logs
+		// NOTE: we only copy resource and log records here.
+		// Scope is not handled properly but it never was.
+		for i := range dropped {
+			rls := ld.ResourceLogs().AppendEmpty()
+			dropped[i].resource.CopyTo(rls.Resource())
 
-		for _, log := range droppedRecords {
-			tgt := logs.AppendEmpty()
-			log.CopyTo(tgt)
+			for j := 0; j < len(dropped[i].records); j++ {
+				dropped[i].records[j].CopyTo(
+					rls.ScopeLogs().AppendEmpty().LogRecords().AppendEmpty(),
+				)
+			}
 		}
 
-		return consumererror.NewLogs(errors.Join(errs...), droppedLogs)
+		errs = deduplicateErrors(errs)
+		se.handleUnauthorizedErrors(ctx, errs...)
+		return consumererror.NewLogs(errors.Join(errs...), ld)
 	}
 
 	return nil
@@ -377,10 +355,6 @@ func (se *sumologicexporter) pushLogsData(ctx context.Context, ld plog.Logs) err
 // it returns number of unsent metrics and error which contains list of dropped records
 // so they can be handle by the OTC retry mechanism
 func (se *sumologicexporter) pushMetricsData(ctx context.Context, md pmetric.Metrics) error {
-	c, err := newCompressor(se.config.CompressEncoding)
-	if err != nil {
-		return consumererror.NewMetrics(fmt.Errorf("failed to initialize compressor: %w", err), md)
-	}
 	logsURL, metricsURL, tracesURL := se.getDataURLs()
 	sdr := newSender(
 		se.logger,
@@ -388,7 +362,6 @@ func (se *sumologicexporter) pushMetricsData(ctx context.Context, md pmetric.Met
 		se.getHTTPClient(),
 		se.filter,
 		se.sources,
-		c,
 		se.prometheusFormatter,
 		metricsURL,
 		logsURL,
diff --git a/exporter/sumologicexporter/exporter_test.go b/exporter/sumologicexporter/exporter_test.go
index e7182eb72fbb..e2bfcc208bdb 100644
--- a/exporter/sumologicexporter/exporter_test.go
+++ b/exporter/sumologicexporter/exporter_test.go
@@ -18,7 +18,6 @@ import (
 	"github.com/stretchr/testify/require"
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/component/componenttest"
-	"go.opentelemetry.io/collector/config/configcompression"
 	"go.opentelemetry.io/collector/config/confighttp"
 	"go.opentelemetry.io/collector/consumer/consumererror"
 	"go.opentelemetry.io/collector/exporter"
@@ -28,6 +27,16 @@ import (
 	"go.uber.org/zap"
 )
 
+func logRecordsToLogs(records []plog.LogRecord) plog.Logs {
+	logs := plog.NewLogs()
+	logsSlice := logs.ResourceLogs().AppendEmpty().ScopeLogs().AppendEmpty().LogRecords()
+	for _, record := range records {
+		record.CopyTo(logsSlice.AppendEmpty())
+	}
+
+	return logs
+}
+
 type exporterTest struct {
 	srv        *httptest.Server
 	exp        *sumologicexporter
@@ -36,24 +45,13 @@ type exporterTest struct {
 
 func createTestConfig() *Config {
 	config := createDefaultConfig().(*Config)
-	config.ClientConfig.Compression = configcompression.Type(NoCompression)
+	config.ClientConfig.Compression = NoCompression
 	config.LogFormat = TextFormat
 	config.MaxRequestBodySize = 20_971_520
 	config.MetricFormat = OTLPMetricFormat
 	return config
 }
 
-func logRecordsToLogs(records []plog.LogRecord) plog.Logs {
-	logs := plog.NewLogs()
-	logsSlice := logs.ResourceLogs().AppendEmpty().ScopeLogs().AppendEmpty().LogRecords()
-	for _, record := range records {
-		tgt := logsSlice.AppendEmpty()
-		record.CopyTo(tgt)
-	}
-
-	return logs
-}
-
 func createExporterCreateSettings() exporter.CreateSettings {
 	return exporter.CreateSettings{
 		TelemetrySettings: component.TelemetrySettings{
@@ -117,152 +115,175 @@ func TestInitExporter(t *testing.T) {
 }
 
 func TestAllSuccess(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareExporterTest(t, createTestConfig(), []func(w http.ResponseWriter, req *http.Request){
 		func(_ http.ResponseWriter, req *http.Request) {
 			body := extractBody(t, req)
 			assert.Equal(t, `Example log`, body)
 			assert.Equal(t, "", req.Header.Get("X-Sumo-Fields"))
 		},
 	})
-	defer func() { test.srv.Close() }()
 
 	logs := logRecordsToLogs(exampleLog())
+	logs.MarkReadOnly()
 
 	err := test.exp.pushLogsData(context.Background(), logs)
 	assert.NoError(t, err)
 }
 
-func TestResourceMerge(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
-		func(_ http.ResponseWriter, req *http.Request) {
-			body := extractBody(t, req)
-			assert.Equal(t, `Example log`, body)
-			assert.Equal(t, "key1=original_value, key2=additional_value", req.Header.Get("X-Sumo-Fields"))
+func TestLogsResourceAttributesSentAsFields(t *testing.T) {
+	testcases := []struct {
+		name       string
+		configFunc func() *Config
+		callbacks  []func(w http.ResponseWriter, req *http.Request)
+		logsFunc   func() plog.Logs
+	}{
+		{
+			name: "text",
+			configFunc: func() *Config {
+				config := createTestConfig()
+				config.LogFormat = TextFormat
+				// config.MetadataAttributes = []string{".*"}
+				return config
+			},
+			callbacks: []func(w http.ResponseWriter, req *http.Request){
+				func(_ http.ResponseWriter, req *http.Request) {
+					// b, err := httputil.DumpRequest(req, true)
+					// assert.NoError(t, err)
+					// fmt.Printf("body:\n%s\n", string(b))
+					body := extractBody(t, req)
+					assert.Equal(t, "Example log\nAnother example log", body)
+					assert.Equal(t, "res_attr1=1, res_attr2=2", req.Header.Get("X-Sumo-Fields"))
+				},
+			},
+			logsFunc: func() plog.Logs {
+				buffer := make([]plog.LogRecord, 2)
+				buffer[0] = plog.NewLogRecord()
+				buffer[0].Body().SetStr("Example log")
+				buffer[0].Attributes().PutStr("key1", "value1")
+				buffer[0].Attributes().PutStr("key2", "value2")
+				buffer[1] = plog.NewLogRecord()
+				buffer[1].Body().SetStr("Another example log")
+				buffer[1].Attributes().PutStr("key1", "value1")
+				buffer[1].Attributes().PutStr("key2", "value2")
+				buffer[1].Attributes().PutStr("key3", "value3")
+
+				logs := logRecordsToLogs(buffer)
+				logs.ResourceLogs().At(0).Resource().Attributes().PutStr("res_attr1", "1")
+				logs.ResourceLogs().At(0).Resource().Attributes().PutStr("res_attr2", "2")
+				logs.MarkReadOnly()
+				return logs
+			},
 		},
-	})
-	defer func() { test.srv.Close() }()
-
-	f, err := newFilter([]string{`key\d`})
-	require.NoError(t, err)
-	test.exp.filter = f
+	}
 
-	logs := logRecordsToLogs(exampleLog())
-	logs.ResourceLogs().At(0).ScopeLogs().At(0).LogRecords().At(0).Attributes().PutStr("key1", "original_value")
-	logs.ResourceLogs().At(0).Resource().Attributes().PutStr("key1", "overwrite_value")
-	logs.ResourceLogs().At(0).Resource().Attributes().PutStr("key2", "additional_value")
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			cfg := tc.configFunc()
+			test := prepareExporterTest(t, cfg, tc.callbacks)
 
-	err = test.exp.pushLogsData(context.Background(), logs)
-	assert.NoError(t, err)
+			logs := tc.logsFunc()
+			assert.NoError(t, test.exp.pushLogsData(context.Background(), logs))
+			assert.EqualValues(t, len(tc.callbacks), atomic.LoadInt32(test.reqCounter))
+		})
+	}
 }
 
 func TestAllFailed(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareExporterTest(t, createTestConfig(), []func(w http.ResponseWriter, req *http.Request){
 		func(w http.ResponseWriter, req *http.Request) {
 			w.WriteHeader(500)
 
 			body := extractBody(t, req)
 			assert.Equal(t, "Example log\nAnother example log", body)
-			assert.Equal(t, "", req.Header.Get("X-Sumo-Fields"))
+			assert.Empty(t, req.Header.Get("X-Sumo-Fields"))
 		},
 	})
-	defer func() { test.srv.Close() }()
 
-	logs := logRecordsToLogs(exampleTwoLogs())
+	logs := plog.NewLogs()
+	logsSlice := logs.ResourceLogs().AppendEmpty()
+	logsRecords1 := logsSlice.ScopeLogs().AppendEmpty().LogRecords()
+	logsRecords1.AppendEmpty().Body().SetStr("Example log")
+
+	logsRecords2 := logsSlice.ScopeLogs().AppendEmpty().LogRecords()
+	logsRecords2.AppendEmpty().Body().SetStr("Another example log")
+
+	logs.MarkReadOnly()
+
+	logsExpected := plog.NewLogs()
+	logsSlice.CopyTo(logsExpected.ResourceLogs().AppendEmpty())
 
 	err := test.exp.pushLogsData(context.Background(), logs)
 	assert.EqualError(t, err, "failed sending data: status: 500 Internal Server Error")
 
 	var partial consumererror.Logs
 	require.True(t, errors.As(err, &partial))
-	assert.Equal(t, logs, partial.Data())
+	assert.Equal(t, logsExpected, partial.Data())
 }
 
 func TestPartiallyFailed(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
-		func(w http.ResponseWriter, req *http.Request) {
-			w.WriteHeader(500)
-
+	test := prepareExporterTest(t, createTestConfig(), []func(w http.ResponseWriter, req *http.Request){
+		func(_ http.ResponseWriter, req *http.Request) {
 			body := extractBody(t, req)
 			assert.Equal(t, "Example log", body)
-			assert.Equal(t, "key1=value1, key2=value2", req.Header.Get("X-Sumo-Fields"))
+			// No resource attributes for those logs hence no fields
+			assert.Empty(t, req.Header.Get("X-Sumo-Fields"))
 		},
-		func(_ http.ResponseWriter, req *http.Request) {
+		func(w http.ResponseWriter, req *http.Request) {
+			w.WriteHeader(500)
+
 			body := extractBody(t, req)
 			assert.Equal(t, "Another example log", body)
-			assert.Equal(t, "key3=value3, key4=value4", req.Header.Get("X-Sumo-Fields"))
+			// No resource attributes for those logs hence no fields
+			assert.Empty(t, req.Header.Get("X-Sumo-Fields"))
 		},
 	})
-	defer func() { test.srv.Close() }()
 
-	f, err := newFilter([]string{`key\d`})
-	require.NoError(t, err)
-	test.exp.filter = f
+	logs := plog.NewLogs()
+	logsSlice1 := logs.ResourceLogs().AppendEmpty()
+	logsRecords1 := logsSlice1.ScopeLogs().AppendEmpty().LogRecords()
+	logsRecords1.AppendEmpty().Body().SetStr("Example log")
+	logsSlice2 := logs.ResourceLogs().AppendEmpty()
+	logsRecords2 := logsSlice2.ScopeLogs().AppendEmpty().LogRecords()
+	logsRecords2.AppendEmpty().Body().SetStr("Another example log")
 
-	records := exampleTwoDifferentLogs()
-	logs := logRecordsToLogs(records)
-	expected := logRecordsToLogs(records[:1])
+	logs.MarkReadOnly()
 
-	err = test.exp.pushLogsData(context.Background(), logs)
+	logsExpected := plog.NewLogs()
+	logsSlice2.CopyTo(logsExpected.ResourceLogs().AppendEmpty())
+
+	err := test.exp.pushLogsData(context.Background(), logs)
 	assert.EqualError(t, err, "failed sending data: status: 500 Internal Server Error")
 
 	var partial consumererror.Logs
 	require.True(t, errors.As(err, &partial))
-	assert.Equal(t, expected, partial.Data())
-}
-
-func TestInvalidSourceFormats(t *testing.T) {
-	_, err := initExporter(&Config{
-		LogFormat:        "json",
-		MetricFormat:     "carbon2",
-		CompressEncoding: "gzip",
-		ClientConfig: confighttp.ClientConfig{
-			Timeout:  defaultTimeout,
-			Endpoint: "test_endpoint",
-		},
-		MetadataAttributes: []string{"[a-z"},
-	}, componenttest.NewNopTelemetrySettings())
-	assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[a-z`")
+	assert.Equal(t, logsExpected, partial.Data())
 }
 
 func TestInvalidHTTPCLient(t *testing.T) {
-	se, err := initExporter(&Config{
-		LogFormat:        "json",
-		MetricFormat:     "carbon2",
-		CompressEncoding: "gzip",
+	exp, err := initExporter(&Config{
+		LogFormat:    "json",
+		MetricFormat: "otlp",
 		ClientConfig: confighttp.ClientConfig{
 			Endpoint: "test_endpoint",
 			CustomRoundTripper: func(_ http.RoundTripper) (http.RoundTripper, error) {
 				return nil, errors.New("roundTripperException")
 			},
 		},
-	}, componenttest.NewNopTelemetrySettings())
-	require.NoError(t, err)
-	require.NotNil(t, se)
+	}, createExporterCreateSettings().TelemetrySettings)
+	assert.NoError(t, err)
 
-	err = se.start(context.Background(), componenttest.NewNopHost())
-	assert.EqualError(t, err, "failed to create HTTP Client: roundTripperException")
+	assert.EqualError(t,
+		exp.start(context.Background(), componenttest.NewNopHost()),
+		"failed to create HTTP Client: roundTripperException",
+	)
 }
 
-func TestPushInvalidCompressor(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
-		func(_ http.ResponseWriter, req *http.Request) {
-			body := extractBody(t, req)
-			assert.Equal(t, `Example log`, body)
-			assert.Equal(t, "", req.Header.Get("X-Sumo-Fields"))
-		},
-	})
-	defer func() { test.srv.Close() }()
-
-	logs := logRecordsToLogs(exampleLog())
-
-	test.exp.config.CompressEncoding = "invalid"
+func TestPushFailedBatch(t *testing.T) {
+	t.Skip()
 
-	err := test.exp.pushLogsData(context.Background(), logs)
-	assert.EqualError(t, err, "failed to initialize compressor: invalid format: invalid")
-}
+	t.Parallel()
 
-func TestPushFailedBatch(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareExporterTest(t, createTestConfig(), []func(w http.ResponseWriter, req *http.Request){
 		func(w http.ResponseWriter, req *http.Request) {
 			w.WriteHeader(500)
 			body := extractBody(t, req)
@@ -284,21 +305,79 @@ func TestPushFailedBatch(t *testing.T) {
 			assert.Equal(t, "", req.Header.Get("X-Sumo-Fields"))
 		},
 	})
-	defer func() { test.srv.Close() }()
 
 	logs := logRecordsToLogs(exampleLog())
 	logs.ResourceLogs().EnsureCapacity(maxBufferSize + 1)
+	logs.MarkReadOnly()
 	log := logs.ResourceLogs().At(0)
+	rLogs := logs.ResourceLogs()
 
 	for i := 0; i < maxBufferSize; i++ {
-		tgt := logs.ResourceLogs().AppendEmpty()
-		log.CopyTo(tgt)
+		log.CopyTo(rLogs.AppendEmpty())
 	}
 
 	err := test.exp.pushLogsData(context.Background(), logs)
 	assert.EqualError(t, err, "failed sending data: status: 500 Internal Server Error")
 }
 
+func TestPushLogs_DontRemoveSourceAttributes(t *testing.T) {
+	createLogs := func() plog.Logs {
+		logs := plog.NewLogs()
+		resourceLogs := logs.ResourceLogs().AppendEmpty()
+		logsSlice := resourceLogs.ScopeLogs().AppendEmpty().LogRecords()
+
+		logRecords := make([]plog.LogRecord, 2)
+		logRecords[0] = plog.NewLogRecord()
+		logRecords[0].Body().SetStr("Example log aaaaaaaaaaaaaaaaaaaaaa 1")
+		logRecords[0].CopyTo(logsSlice.AppendEmpty())
+		logRecords[1] = plog.NewLogRecord()
+		logRecords[1].Body().SetStr("Example log aaaaaaaaaaaaaaaaaaaaaa 2")
+		logRecords[1].CopyTo(logsSlice.AppendEmpty())
+
+		resourceAttrs := resourceLogs.Resource().Attributes()
+		resourceAttrs.PutStr("hostname", "my-host-name")
+		resourceAttrs.PutStr("hosttype", "my-host-type")
+		resourceAttrs.PutStr("_sourceCategory", "my-source-category")
+		resourceAttrs.PutStr("_sourceHost", "my-source-host")
+		resourceAttrs.PutStr("_sourceName", "my-source-name")
+		logs.MarkReadOnly()
+
+		return logs
+	}
+
+	callbacks := []func(w http.ResponseWriter, req *http.Request){
+		func(_ http.ResponseWriter, req *http.Request) {
+			body := extractBody(t, req)
+			assert.Equal(t, "Example log aaaaaaaaaaaaaaaaaaaaaa 1", body)
+			assert.Equal(t, "hostname=my-host-name, hosttype=my-host-type", req.Header.Get("X-Sumo-Fields"))
+			assert.Equal(t, "my-source-category", req.Header.Get("X-Sumo-Category"))
+			assert.Equal(t, "my-source-host", req.Header.Get("X-Sumo-Host"))
+			assert.Equal(t, "my-source-name", req.Header.Get("X-Sumo-Name"))
+			for k, v := range req.Header {
+				t.Logf("request #1 header: %v=%v", k, v)
+			}
+		},
+		func(_ http.ResponseWriter, req *http.Request) {
+			body := extractBody(t, req)
+			assert.Equal(t, "Example log aaaaaaaaaaaaaaaaaaaaaa 2", body)
+			assert.Equal(t, "hostname=my-host-name, hosttype=my-host-type", req.Header.Get("X-Sumo-Fields"))
+			assert.Equal(t, "my-source-category", req.Header.Get("X-Sumo-Category"))
+			assert.Equal(t, "my-source-host", req.Header.Get("X-Sumo-Host"))
+			assert.Equal(t, "my-source-name", req.Header.Get("X-Sumo-Name"))
+			for k, v := range req.Header {
+				t.Logf("request #2 header: %v=%v", k, v)
+			}
+		},
+	}
+
+	config := createTestConfig()
+	config.LogFormat = TextFormat
+	config.MaxRequestBodySize = 32
+
+	test := prepareExporterTest(t, config, callbacks)
+	assert.NoError(t, test.exp.pushLogsData(context.Background(), createLogs()))
+}
+
 func TestAllMetricsSuccess(t *testing.T) {
 	testcases := []struct {
 		name         string
diff --git a/exporter/sumologicexporter/factory.go b/exporter/sumologicexporter/factory.go
index 47ab3195ae1b..e1cad8f3d4d4 100644
--- a/exporter/sumologicexporter/factory.go
+++ b/exporter/sumologicexporter/factory.go
@@ -32,8 +32,6 @@ func createDefaultConfig() component.Config {
 	qs.Enabled = false
 
 	return &Config{
-
-		CompressEncoding:   DefaultCompressEncoding,
 		MaxRequestBodySize: DefaultMaxRequestBodySize,
 		LogFormat:          DefaultLogFormat,
 		MetricFormat:       DefaultMetricFormat,
diff --git a/exporter/sumologicexporter/factory_test.go b/exporter/sumologicexporter/factory_test.go
index c2d8b0e610e8..8902cca7de73 100644
--- a/exporter/sumologicexporter/factory_test.go
+++ b/exporter/sumologicexporter/factory_test.go
@@ -9,7 +9,6 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"go.opentelemetry.io/collector/component"
-	"go.opentelemetry.io/collector/component/componenttest"
 	"go.opentelemetry.io/collector/config/configauth"
 	"go.opentelemetry.io/collector/config/confighttp"
 	"go.opentelemetry.io/collector/config/configretry"
@@ -31,23 +30,21 @@ func TestCreateDefaultConfig(t *testing.T) {
 	qs.Enabled = false
 
 	assert.Equal(t, cfg, &Config{
-		CompressEncoding:   "gzip",
 		MaxRequestBodySize: 1_048_576,
-		LogFormat:          "json",
+		LogFormat:          "otlp",
 		MetricFormat:       "otlp",
-		SourceCategory:     "",
-		SourceName:         "",
-		SourceHost:         "",
 		Client:             "otelcol",
 
 		ClientConfig: confighttp.ClientConfig{
+			Timeout:     5 * time.Second,
+			Compression: "gzip",
 			Auth: &configauth.Authentication{
 				AuthenticatorID: component.NewID(metadata.Type),
 			},
-			Timeout: 5 * time.Second,
 		},
 		BackOffConfig: configretry.NewDefaultBackOffConfig(),
 		QueueSettings: qs,
 	})
-	assert.NoError(t, componenttest.CheckConfigStruct(cfg))
+
+	assert.NoError(t, component.ValidateConfig(cfg))
 }
diff --git a/exporter/sumologicexporter/go.mod b/exporter/sumologicexporter/go.mod
index 2f31b0ed3bd0..fc5b2f0c10d5 100644
--- a/exporter/sumologicexporter/go.mod
+++ b/exporter/sumologicexporter/go.mod
@@ -3,6 +3,7 @@ module github.com/open-telemetry/opentelemetry-collector-contrib/exporter/sumolo
 go 1.21.0
 
 require (
+	github.com/klauspost/compress v1.17.8
 	github.com/open-telemetry/opentelemetry-collector-contrib/extension/sumologicextension v0.100.0
 	github.com/stretchr/testify v1.9.0
 	go.opencensus.io v0.24.0
@@ -40,7 +41,6 @@ require (
 	github.com/google/uuid v1.6.0 // indirect
 	github.com/hashicorp/go-version v1.6.0 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
-	github.com/klauspost/compress v1.17.8 // indirect
 	github.com/knadh/koanf/maps v0.1.1 // indirect
 	github.com/knadh/koanf/providers/confmap v0.1.0 // indirect
 	github.com/knadh/koanf/v2 v2.1.1 // indirect
diff --git a/exporter/sumologicexporter/sender.go b/exporter/sumologicexporter/sender.go
index 9e7e6d132b14..e47ee0ac10bb 100644
--- a/exporter/sumologicexporter/sender.go
+++ b/exporter/sumologicexporter/sender.go
@@ -27,6 +27,7 @@ import (
 
 var (
 	metricsMarshaler = pmetric.ProtoMarshaler{}
+	logsMarshaler    = plog.ProtoMarshaler{}
 )
 
 // metricPair represents information required to send one metric to the Sumo Logic
@@ -110,12 +111,10 @@ func (b *bodyBuilder) toCountingReader() *countingReader {
 
 type sender struct {
 	logger              *zap.Logger
-	logBuffer           []plog.LogRecord
 	config              *Config
 	client              *http.Client
 	filter              filter
 	sources             sourceFormats
-	compressor          compressor
 	prometheusFormatter prometheusFormatter
 	dataURLMetrics      string
 	dataURLLogs         string
@@ -124,17 +123,15 @@ type sender struct {
 }
 
 const (
-	logKey string = "log"
 	// maxBufferSize defines size of the logBuffer (maximum number of plog.LogRecord entries)
 	maxBufferSize int = 1024 * 1024
 
-	headerContentType     string = "Content-Type"
-	headerContentEncoding string = "Content-Encoding"
-	headerClient          string = "X-Sumo-Client"
-	headerHost            string = "X-Sumo-Host"
-	headerName            string = "X-Sumo-Name"
-	headerCategory        string = "X-Sumo-Category"
-	headerFields          string = "X-Sumo-Fields"
+	headerContentType string = "Content-Type"
+	headerClient      string = "X-Sumo-Client"
+	headerHost        string = "X-Sumo-Host"
+	headerName        string = "X-Sumo-Name"
+	headerCategory    string = "X-Sumo-Category"
+	headerFields      string = "X-Sumo-Fields"
 
 	attributeKeySourceHost     = "_sourceHost"
 	attributeKeySourceName     = "_sourceName"
@@ -143,9 +140,6 @@ const (
 	contentTypeLogs       string = "application/x-www-form-urlencoded"
 	contentTypePrometheus string = "application/vnd.sumologic.prometheus"
 	contentTypeOTLP       string = "application/x-protobuf"
-
-	contentEncodingGzip    string = "gzip"
-	contentEncodingDeflate string = "deflate"
 )
 
 func newSender(
@@ -154,7 +148,6 @@ func newSender(
 	cl *http.Client,
 	f filter,
 	s sourceFormats,
-	c compressor,
 	pf prometheusFormatter,
 	metricsURL string,
 	logsURL string,
@@ -167,7 +160,6 @@ func newSender(
 		client:              cl,
 		filter:              f,
 		sources:             s,
-		compressor:          c,
 		prometheusFormatter: pf,
 		dataURLMetrics:      metricsURL,
 		dataURLLogs:         logsURL,
@@ -310,23 +302,22 @@ func (s *sender) handleReceiverResponse(resp *http.Response) error {
 
 func (s *sender) createRequest(ctx context.Context, pipeline PipelineType, data io.Reader) (*http.Request, error) {
 	var url string
-	var err error
 
 	switch pipeline {
 	case MetricsPipeline:
 		url = s.dataURLMetrics
 	case LogsPipeline:
 		url = s.dataURLLogs
-		data, err = s.compressor.compress(data)
 	default:
 		return nil, fmt.Errorf("unknown pipeline type: %s", pipeline)
 	}
 
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, data)
 	if err != nil {
-		return nil, err
+		return req, err
 	}
 
-	return http.NewRequestWithContext(ctx, http.MethodPost, url, data)
+	return req, err
 }
 
 // logToText converts LogRecord to a plain text line, returns it and error eventually
@@ -336,21 +327,51 @@ func (s *sender) logToText(record plog.LogRecord) string {
 
 // logToJSON converts LogRecord to a json line, returns it and error eventually
 func (s *sender) logToJSON(record plog.LogRecord) (string, error) {
-	data := s.filter.filterOut(record.Attributes())
-	record.Body().CopyTo(data.orig.PutEmpty(logKey))
+	recordCopy := plog.NewLogRecord()
+	record.CopyTo(recordCopy)
+
+	// Only append the body when it's not empty to prevent sending 'null' log.
+	if body := recordCopy.Body(); !isEmptyAttributeValue(body) {
+		body.CopyTo(recordCopy.Attributes().PutEmpty(DefaultLogKey))
+	}
+
+	nextLine := new(bytes.Buffer)
+	enc := json.NewEncoder(nextLine)
+	enc.SetEscapeHTML(false)
+	err := enc.Encode(recordCopy.Attributes().AsRaw())
 
-	nextLine, err := json.Marshal(data.orig.AsRaw())
 	if err != nil {
 		return "", err
 	}
 
-	return bytes.NewBuffer(nextLine).String(), nil
+	return strings.TrimSuffix(nextLine.String(), "\n"), nil
 }
 
-// sendLogs sends log records from the logBuffer formatted according
+func isEmptyAttributeValue(att pcommon.Value) bool {
+	switch att.Type() {
+	case pcommon.ValueTypeEmpty:
+		return true
+	case pcommon.ValueTypeStr:
+		return len(att.Str()) == 0
+	case pcommon.ValueTypeSlice:
+		return att.Slice().Len() == 0
+	case pcommon.ValueTypeMap:
+		return att.Map().Len() == 0
+	case pcommon.ValueTypeBytes:
+		return att.Bytes().Len() == 0
+	}
+
+	return false
+}
+
+// sendNonOTLPLogs sends log records from the logBuffer formatted according
 // to configured LogFormat and as the result of execution
 // returns array of records which has not been sent correctly and error
-func (s *sender) sendLogs(ctx context.Context, flds fields) ([]plog.LogRecord, error) {
+func (s *sender) sendNonOTLPLogs(ctx context.Context, rl plog.ResourceLogs, flds fields) ([]plog.LogRecord, error) {
+	if s.config.LogFormat == OTLPLogFormat {
+		return nil, fmt.Errorf("attempting to send OTLP logs as non-OTLP data")
+	}
+
 	var (
 		body           = newBodyBuilder()
 		errs           []error
@@ -358,37 +379,31 @@ func (s *sender) sendLogs(ctx context.Context, flds fields) ([]plog.LogRecord, e
 		currentRecords []plog.LogRecord
 	)
 
-	for _, record := range s.logBuffer {
-		var formattedLine string
-		var err error
-
-		switch s.config.LogFormat {
-		case TextFormat:
-			formattedLine = s.logToText(record)
-		case JSONFormat:
-			formattedLine, err = s.logToJSON(record)
-		default:
-			err = errors.New("unexpected log format")
-		}
+	slgs := rl.ScopeLogs()
+	for i := 0; i < slgs.Len(); i++ {
+		slg := slgs.At(i)
+		for j := 0; j < slg.LogRecords().Len(); j++ {
+			lr := slg.LogRecords().At(j)
+			formattedLine, err := s.formatLogLine(lr)
+			if err != nil {
+				droppedRecords = append(droppedRecords, lr)
+				errs = append(errs, err)
+				continue
+			}
 
-		if err != nil {
-			droppedRecords = append(droppedRecords, record)
-			errs = append(errs, err)
-			continue
-		}
+			sent, err := s.appendAndMaybeSend(ctx, []string{formattedLine}, LogsPipeline, &body, flds)
+			if err != nil {
+				errs = append(errs, err)
+				droppedRecords = append(droppedRecords, currentRecords...)
+			}
 
-		sent, err := s.appendAndMaybeSend(ctx, []string{formattedLine}, LogsPipeline, &body, flds)
-		if err != nil {
-			errs = append(errs, err)
-			droppedRecords = append(droppedRecords, currentRecords...)
-		}
+			// If data was sent and either failed or succeeded, cleanup the currentRecords slice
+			if sent {
+				currentRecords = currentRecords[:0]
+			}
 
-		// If data was sent, cleanup the currentTimeSeries counter
-		if sent {
-			currentRecords = currentRecords[:0]
+			currentRecords = append(currentRecords, lr)
 		}
-
-		currentRecords = append(currentRecords, record)
 	}
 
 	if body.Len() > 0 {
@@ -401,6 +416,32 @@ func (s *sender) sendLogs(ctx context.Context, flds fields) ([]plog.LogRecord, e
 	return droppedRecords, errors.Join(errs...)
 }
 
+func (s *sender) formatLogLine(lr plog.LogRecord) (string, error) {
+	var formattedLine string
+	var err error
+
+	switch s.config.LogFormat {
+	case TextFormat:
+		formattedLine = s.logToText(lr)
+	case JSONFormat:
+		formattedLine, err = s.logToJSON(lr)
+	default:
+		err = errors.New("unexpected log format")
+	}
+
+	return formattedLine, err
+}
+
+// TODO: add support for HTTP limits
+func (s *sender) sendOTLPLogs(ctx context.Context, ld plog.Logs) error {
+	body, err := logsMarshaler.MarshalLogs(ld)
+	if err != nil {
+		return err
+	}
+
+	return s.send(ctx, LogsPipeline, newCountingReader(ld.LogRecordCount()).withBytes(body), fields{})
+}
+
 // sendNonOTLPMetrics sends metrics in right format basing on the s.config.MetricFormat
 func (s *sender) sendNonOTLPMetrics(ctx context.Context, md pmetric.Metrics) (pmetric.Metrics, []error) {
 	if s.config.MetricFormat == OTLPMetricFormat {
@@ -546,43 +587,7 @@ func (s *sender) appendAndMaybeSend(
 	return sent, err
 }
 
-// cleanLogsBuffer zeroes logBuffer
-func (s *sender) cleanLogsBuffer() {
-	s.logBuffer = (s.logBuffer)[:0]
-}
-
-// batchLog adds log to the logBuffer and flushes them if logBuffer is full to avoid overflow
-// returns list of log records which were not sent successfully
-func (s *sender) batchLog(ctx context.Context, log plog.LogRecord, metadata fields) ([]plog.LogRecord, error) {
-	s.logBuffer = append(s.logBuffer, log)
-
-	if s.countLogs() >= maxBufferSize {
-		dropped, err := s.sendLogs(ctx, metadata)
-		s.cleanLogsBuffer()
-		return dropped, err
-	}
-
-	return nil, nil
-}
-
-// countLogs returns number of logs in logBuffer
-func (s *sender) countLogs() int {
-	return len(s.logBuffer)
-}
-
-func (s *sender) addSourcesHeaders(req *http.Request, flds fields) {
-	if s.sources.host.isSet() {
-		req.Header.Add(headerHost, s.sources.host.format(flds))
-	}
-
-	if s.sources.name.isSet() {
-		req.Header.Add(headerName, s.sources.name.format(flds))
-	}
-
-	if s.sources.category.isSet() {
-		req.Header.Add(headerCategory, s.sources.category.format(flds))
-	}
-
+func addSourcesHeaders(req *http.Request, flds fields) {
 	sourceHeaderValues := getSourcesHeaders(flds)
 
 	for headerName, headerValue := range sourceHeaderValues {
@@ -612,8 +617,13 @@ func getSourcesHeaders(flds fields) map[string]string {
 	return sourceHeaderValues
 }
 
-func addLogsHeaders(req *http.Request, _ LogFormatType, flds fields) {
-	req.Header.Add(headerContentType, contentTypeLogs)
+func addLogsHeaders(req *http.Request, lf LogFormatType, flds fields) {
+	switch lf {
+	case OTLPLogFormat:
+		req.Header.Add(headerContentType, contentTypeOTLP)
+	default:
+		req.Header.Add(headerContentType, contentTypeLogs)
+	}
 
 	if fieldsStr := flds.string(); fieldsStr != "" {
 		req.Header.Add(headerFields, fieldsStr)
@@ -634,18 +644,7 @@ func addMetricsHeaders(req *http.Request, mf MetricFormatType) error {
 
 func (s *sender) addRequestHeaders(req *http.Request, pipeline PipelineType, flds fields) error {
 	req.Header.Add(headerClient, s.config.Client)
-	s.addSourcesHeaders(req, flds)
-
-	// Add headers
-	switch s.config.CompressEncoding {
-	case GZIPCompression:
-		req.Header.Set(headerContentEncoding, contentEncodingGzip)
-	case DeflateCompression:
-		req.Header.Set(headerContentEncoding, contentEncodingDeflate)
-	case NoCompression:
-	default:
-		return fmt.Errorf("invalid content encoding: %s", s.config.CompressEncoding)
-	}
+	addSourcesHeaders(req, flds)
 
 	switch pipeline {
 	case LogsPipeline:
diff --git a/exporter/sumologicexporter/sender_test.go b/exporter/sumologicexporter/sender_test.go
index 5f42d2421b44..ceca87dede06 100644
--- a/exporter/sumologicexporter/sender_test.go
+++ b/exporter/sumologicexporter/sender_test.go
@@ -4,8 +4,12 @@
 package sumologicexporter
 
 import (
+	"bufio"
+	"bytes"
+	"compress/gzip"
+	"compress/zlib"
 	"context"
-	"errors"
+	"fmt"
 	"io"
 	"net/http"
 	"net/http/httptest"
@@ -13,25 +17,28 @@ import (
 	"sync/atomic"
 	"testing"
 
+	"github.com/klauspost/compress/zstd"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/component/componenttest"
-	"go.opentelemetry.io/collector/config/confighttp"
+	"go.opentelemetry.io/collector/config/configcompression"
 	"go.opentelemetry.io/collector/consumer/consumererror"
 	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.opentelemetry.io/collector/pdata/plog"
 	"go.opentelemetry.io/collector/pdata/pmetric"
 	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
 )
 
 type senderTest struct {
-	srv *httptest.Server
-	exp *sumologicexporter
-	s   *sender
+	reqCounter *int32
+	srv        *httptest.Server
+	exp        *sumologicexporter
+	s          *sender
 }
 
-func prepareSenderTest(t *testing.T, cb []func(w http.ResponseWriter, req *http.Request)) *senderTest {
+func prepareSenderTest(t *testing.T, compression configcompression.Type, cb []func(w http.ResponseWriter, req *http.Request), cfgOpts ...func(*Config)) *senderTest {
 	var reqCounter int32
 	// generate a test server so we can capture and inspect the request
 	testServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
@@ -46,23 +53,39 @@ func prepareSenderTest(t *testing.T, cb []func(w http.ResponseWriter, req *http.
 	}))
 	t.Cleanup(func() { testServer.Close() })
 
-	cfg := &Config{
-		ClientConfig: confighttp.ClientConfig{
-			Endpoint: testServer.URL,
-			Timeout:  defaultTimeout,
-		},
-		LogFormat:          "text",
-		MetricFormat:       "otlp",
-		Client:             "otelcol",
-		MaxRequestBodySize: 20_971_520,
+	cfg := createDefaultConfig().(*Config)
+	cfg.ClientConfig.Endpoint = testServer.URL
+	switch compression {
+	case configcompression.TypeGzip:
+		cfg.ClientConfig.Compression = configcompression.TypeGzip
+	case configcompression.TypeZstd:
+		cfg.ClientConfig.Compression = configcompression.TypeZstd
+	case NoCompression:
+		cfg.ClientConfig.Compression = NoCompression
+	case configcompression.TypeDeflate:
+		cfg.ClientConfig.Compression = configcompression.TypeDeflate
+	default:
+		cfg.CompressEncoding = configcompression.TypeGzip
 	}
-	exp, err := initExporter(cfg, componenttest.NewNopTelemetrySettings())
+	cfg.ClientConfig.Auth = nil
+	httpSettings := cfg.ClientConfig
+	host := componenttest.NewNopHost()
+	client, err := httpSettings.ToClient(context.Background(), host, component.TelemetrySettings{})
 	require.NoError(t, err)
+	if err != nil {
+		return nil
+	}
+	cfg.LogFormat = TextFormat
+	cfg.MetricFormat = OTLPMetricFormat
+	cfg.MaxRequestBodySize = 20_971_520
+	for _, cfgOpt := range cfgOpts {
+		cfgOpt(cfg)
+	}
 
-	f, err := newFilter([]string{})
+	exp, err := initExporter(cfg, componenttest.NewNopTelemetrySettings())
 	require.NoError(t, err)
 
-	c, err := newCompressor(NoCompression)
+	f, err := newFilter([]string{})
 	require.NoError(t, err)
 
 	pf := newPrometheusFormatter()
@@ -74,21 +97,19 @@ func prepareSenderTest(t *testing.T, cb []func(w http.ResponseWriter, req *http.
 	require.NoError(t, err)
 
 	return &senderTest{
-		srv: testServer,
-		exp: exp,
+		reqCounter: &reqCounter,
+		srv:        testServer,
+		exp:        exp,
 		s: newSender(
 			logger,
 			cfg,
-			&http.Client{
-				Timeout: cfg.ClientConfig.Timeout,
-			},
+			client,
 			f,
 			sourceFormats{
 				host:     getTestSourceFormat("source_host"),
 				category: getTestSourceFormat("source_category"),
 				name:     getTestSourceFormat("source_name"),
 			},
-			c,
 			pf,
 			testServer.URL,
 			testServer.URL,
@@ -127,57 +148,67 @@ func exampleTwoLogs() []plog.LogRecord {
 	return buffer
 }
 
-func exampleTwoDifferentLogs() []plog.LogRecord {
-	buffer := make([]plog.LogRecord, 2)
-	buffer[0] = plog.NewLogRecord()
-	buffer[0].Body().SetStr("Example log")
-	buffer[0].Attributes().PutStr("key1", "value1")
-	buffer[0].Attributes().PutStr("key2", "value2")
-	buffer[1] = plog.NewLogRecord()
-	buffer[1].Body().SetStr("Another example log")
-	buffer[1].Attributes().PutStr("key3", "value3")
-	buffer[1].Attributes().PutStr("key4", "value4")
-
-	return buffer
-}
+func decodeGzip(t *testing.T, data io.Reader) string {
+	r, err := gzip.NewReader(data)
+	require.NoError(t, err)
 
-func exampleMultitypeLogs() []plog.LogRecord {
-	buffer := make([]plog.LogRecord, 2)
+	var buf []byte
+	buf, err = io.ReadAll(r)
+	require.NoError(t, err)
 
-	attVal := pcommon.NewValueMap()
-	attMap := attVal.Map()
-	attMap.PutStr("lk1", "lv1")
-	attMap.PutInt("lk2", 13)
+	return string(buf)
+}
 
-	buffer[0] = plog.NewLogRecord()
-	attVal.CopyTo(buffer[0].Body())
+func decodeZstd(t *testing.T, data io.Reader) string {
+	r, err := zstd.NewReader(data)
+	require.NoError(t, err)
+	var buf []byte
+	buf, err = io.ReadAll(r)
+	require.NoError(t, err)
 
-	buffer[0].Attributes().PutStr("key1", "value1")
-	buffer[0].Attributes().PutStr("key2", "value2")
+	return string(buf)
+}
 
-	buffer[1] = plog.NewLogRecord()
+func decodeZlib(t *testing.T, data io.Reader) string {
+	r, err := zlib.NewReader(data)
+	if err != nil {
+		return ""
+	}
+	var buf []byte
+	buf, err = io.ReadAll(r)
+	require.NoError(t, err)
 
-	attVal = pcommon.NewValueSlice()
-	attArr := attVal.Slice()
-	strVal := pcommon.NewValueEmpty()
-	strVal.SetStr("lv2")
-	intVal := pcommon.NewValueEmpty()
-	intVal.SetInt(13)
+	return string(buf)
+}
 
-	strTgt := attArr.AppendEmpty()
-	strVal.CopyTo(strTgt)
-	intTgt := attArr.AppendEmpty()
-	intVal.CopyTo(intTgt)
+func TestSendLogs(t *testing.T) {
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
+		func(_ http.ResponseWriter, req *http.Request) {
+			body := extractBody(t, req)
+			assert.Equal(t, "Example log\nAnother example log", body)
+			assert.Equal(t, "key1=value, key2=value2", req.Header.Get("X-Sumo-Fields"))
+			assert.Equal(t, "otelcol", req.Header.Get("X-Sumo-Client"))
+			assert.Equal(t, "application/x-www-form-urlencoded", req.Header.Get("Content-Type"))
+		},
+	})
 
-	attVal.CopyTo(buffer[1].Body())
-	buffer[1].Attributes().PutStr("key1", "value1")
-	buffer[1].Attributes().PutStr("key2", "value2")
+	rls := plog.NewResourceLogs()
+	slgs := rls.ScopeLogs()
+	logsRecords1 := slgs.AppendEmpty().LogRecords()
+	logsRecords1.AppendEmpty().Body().SetStr("Example log")
+	logsRecords2 := slgs.AppendEmpty().LogRecords()
+	logsRecords2.AppendEmpty().Body().SetStr("Another example log")
 
-	return buffer
+	_, err := test.s.sendNonOTLPLogs(context.Background(),
+		rls,
+		fieldsFromMap(map[string]string{"key1": "value", "key2": "value2"}),
+	)
+	assert.NoError(t, err)
+	assert.EqualValues(t, 1, *test.reqCounter)
 }
 
-func TestSendLogs(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+func TestSendLogsWithEmptyField(t *testing.T) {
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(_ http.ResponseWriter, req *http.Request) {
 			body := extractBody(t, req)
 			assert.Equal(t, "Example log\nAnother example log", body)
@@ -186,16 +217,24 @@ func TestSendLogs(t *testing.T) {
 			assert.Equal(t, "application/x-www-form-urlencoded", req.Header.Get("Content-Type"))
 		},
 	})
-	defer func() { test.srv.Close() }()
 
-	test.s.logBuffer = exampleTwoLogs()
+	rls := plog.NewResourceLogs()
+	slgs := rls.ScopeLogs()
+	logsRecords1 := slgs.AppendEmpty().LogRecords()
+	logsRecords1.AppendEmpty().Body().SetStr("Example log")
+	logsRecords2 := slgs.AppendEmpty().LogRecords()
+	logsRecords2.AppendEmpty().Body().SetStr("Another example log")
 
-	_, err := test.s.sendLogs(context.Background(), fieldsFromMap(map[string]string{"key1": "value", "key2": "value2"}))
+	_, err := test.s.sendNonOTLPLogs(context.Background(),
+		rls,
+		fieldsFromMap(map[string]string{"key1": "value", "key2": "value2", "service": ""}),
+	)
 	assert.NoError(t, err)
+	assert.EqualValues(t, 1, *test.reqCounter)
 }
 
 func TestSendLogsMultitype(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(_ http.ResponseWriter, req *http.Request) {
 			body := extractBody(t, req)
 			expected := `{"lk1":"lv1","lk2":13}
@@ -206,16 +245,36 @@ func TestSendLogsMultitype(t *testing.T) {
 			assert.Equal(t, "application/x-www-form-urlencoded", req.Header.Get("Content-Type"))
 		},
 	})
-	defer func() { test.srv.Close() }()
 
-	test.s.logBuffer = exampleMultitypeLogs()
+	rls := plog.NewResourceLogs()
+	slgs := rls.ScopeLogs()
+	logsRecords := slgs.AppendEmpty().LogRecords()
+	attVal := pcommon.NewValueMap()
+	attMap := attVal.Map()
+	attMap.PutStr("lk1", "lv1")
+	attMap.PutInt("lk2", 13)
+	logRecord := logsRecords.AppendEmpty()
+	attVal.CopyTo(logRecord.Body())
 
-	_, err := test.s.sendLogs(context.Background(), fieldsFromMap(map[string]string{"key1": "value", "key2": "value2"}))
+	attVal = pcommon.NewValueSlice()
+	attArr := attVal.Slice()
+	strVal := pcommon.NewValueStr("lv2")
+	intVal := pcommon.NewValueInt(13)
+	strVal.CopyTo(attArr.AppendEmpty())
+	intVal.CopyTo(attArr.AppendEmpty())
+	attVal.CopyTo(logsRecords.AppendEmpty().Body())
+
+	_, err := test.s.sendNonOTLPLogs(context.Background(),
+		rls,
+		fieldsFromMap(map[string]string{"key1": "value", "key2": "value2"}),
+	)
 	assert.NoError(t, err)
+
+	assert.EqualValues(t, 1, *test.reqCounter)
 }
 
 func TestSendLogsSplit(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(_ http.ResponseWriter, req *http.Request) {
 			body := extractBody(t, req)
 			assert.Equal(t, "Example log", body)
@@ -225,17 +284,34 @@ func TestSendLogsSplit(t *testing.T) {
 			assert.Equal(t, "Another example log", body)
 		},
 	})
-	defer func() { test.srv.Close() }()
 	test.s.config.MaxRequestBodySize = 10
-	test.s.logBuffer = exampleTwoLogs()
 
-	_, err := test.s.sendLogs(context.Background(), newFields(pcommon.NewMap()))
+	rls := plog.NewResourceLogs()
+	slgs := rls.ScopeLogs()
+	logsRecords1 := slgs.AppendEmpty().LogRecords()
+	logsRecords1.AppendEmpty().Body().SetStr("Example log")
+	logsRecords2 := slgs.AppendEmpty().LogRecords()
+	logsRecords2.AppendEmpty().Body().SetStr("Another example log")
+
+	_, err := test.s.sendNonOTLPLogs(context.Background(),
+		rls,
+		fields{},
+	)
 	assert.NoError(t, err)
+
+	assert.EqualValues(t, 2, *test.reqCounter)
 }
+
 func TestSendLogsSplitFailedOne(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(w http.ResponseWriter, req *http.Request) {
 			w.WriteHeader(500)
+			_, err := fmt.Fprintf(
+				w,
+				`{"id":"1TIRY-KGIVX-TPQRJ","errors":[{"code":"internal.error","message":"Internal server error."}]}`,
+			)
+
+			require.NoError(t, err)
 
 			body := extractBody(t, req)
 			assert.Equal(t, "Example log", body)
@@ -245,18 +321,28 @@ func TestSendLogsSplitFailedOne(t *testing.T) {
 			assert.Equal(t, "Another example log", body)
 		},
 	})
-	defer func() { test.srv.Close() }()
 	test.s.config.MaxRequestBodySize = 10
 	test.s.config.LogFormat = TextFormat
-	test.s.logBuffer = exampleTwoLogs()
 
-	dropped, err := test.s.sendLogs(context.Background(), newFields(pcommon.NewMap()))
-	assert.EqualError(t, err, "failed sending data: status: 500 Internal Server Error")
-	assert.Equal(t, test.s.logBuffer[0:1], dropped)
+	rls := plog.NewResourceLogs()
+	slgs := rls.ScopeLogs()
+	logsRecords1 := slgs.AppendEmpty().LogRecords()
+	logsRecords1.AppendEmpty().Body().SetStr("Example log")
+	logsRecords2 := slgs.AppendEmpty().LogRecords()
+	logsRecords2.AppendEmpty().Body().SetStr("Another example log")
+
+	dropped, err := test.s.sendNonOTLPLogs(context.Background(),
+		rls,
+		fields{},
+	)
+	assert.EqualError(t, err, "failed sending data: status: 500 Internal Server Error, id: 1TIRY-KGIVX-TPQRJ, errors: [{Code:internal.error Message:Internal server error.}]")
+	assert.Len(t, dropped, 1)
+
+	assert.EqualValues(t, 2, *test.reqCounter)
 }
 
 func TestSendLogsSplitFailedAll(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(w http.ResponseWriter, req *http.Request) {
 			w.WriteHeader(500)
 
@@ -270,258 +356,591 @@ func TestSendLogsSplitFailedAll(t *testing.T) {
 			assert.Equal(t, "Another example log", body)
 		},
 	})
-	defer func() { test.srv.Close() }()
 	test.s.config.MaxRequestBodySize = 10
 	test.s.config.LogFormat = TextFormat
-	test.s.logBuffer = exampleTwoLogs()
 
-	dropped, err := test.s.sendLogs(context.Background(), newFields(pcommon.NewMap()))
+	rls := plog.NewResourceLogs()
+	slgs := rls.ScopeLogs()
+	logsRecords1 := slgs.AppendEmpty().LogRecords()
+	logsRecords1.AppendEmpty().Body().SetStr("Example log")
+	logsRecords2 := slgs.AppendEmpty().LogRecords()
+	logsRecords2.AppendEmpty().Body().SetStr("Another example log")
+
+	dropped, err := test.s.sendNonOTLPLogs(context.Background(), rls, fields{})
 	assert.EqualError(
 		t,
 		err,
 		"failed sending data: status: 500 Internal Server Error\nfailed sending data: status: 404 Not Found",
 	)
-	assert.Equal(t, test.s.logBuffer[0:2], dropped)
+	assert.Len(t, dropped, 2)
+
+	assert.EqualValues(t, 2, *test.reqCounter)
+}
+
+func TestSendLogsJsonConfig(t *testing.T) {
+	twoLogsFunc := func() plog.ResourceLogs {
+		rls := plog.NewResourceLogs()
+		slgs := rls.ScopeLogs().AppendEmpty()
+		log := slgs.LogRecords().AppendEmpty()
+
+		log.Body().SetStr("Example log")
+		log.Attributes().PutStr("key1", "value1")
+		log.Attributes().PutStr("key2", "value2")
+
+		log = slgs.LogRecords().AppendEmpty()
+		log.Body().SetStr("Another example log")
+		log.Attributes().PutStr("key1", "value1")
+		log.Attributes().PutStr("key2", "value2")
+
+		return rls
+	}
+
+	twoComplexBodyLogsFunc := func() plog.ResourceLogs {
+		rls := plog.NewResourceLogs()
+		slgs := rls.ScopeLogs().AppendEmpty()
+		log := slgs.LogRecords().AppendEmpty()
+
+		body := pcommon.NewValueMap().Map()
+		body.PutStr("a", "b")
+		body.PutBool("c", false)
+		body.PutInt("d", 20)
+		body.PutDouble("e", 20.5)
+
+		f := pcommon.NewValueSlice()
+		f.Slice().EnsureCapacity(4)
+		f.Slice().AppendEmpty().SetStr("p")
+		f.Slice().AppendEmpty().SetBool(true)
+		f.Slice().AppendEmpty().SetInt(13)
+		f.Slice().AppendEmpty().SetDouble(19.3)
+		f.Slice().CopyTo(body.PutEmptySlice("f"))
+
+		g := pcommon.NewValueMap()
+		g.Map().PutStr("h", "i")
+		g.Map().PutBool("j", false)
+		g.Map().PutInt("k", 12)
+		g.Map().PutDouble("l", 11.1)
+
+		g.Map().CopyTo(body.PutEmptyMap("g"))
+
+		log.Attributes().PutStr("m", "n")
+
+		pcommon.NewValueMap().CopyTo(log.Body())
+		body.CopyTo(log.Body().Map())
+
+		return rls
+	}
+
+	testcases := []struct {
+		name       string
+		configOpts []func(*Config)
+		bodyRegex  string
+		logsFunc   func() plog.ResourceLogs
+	}{
+		{
+			name: "default config",
+			bodyRegex: `{"key1":"value1","key2":"value2","log":"Example log"}` +
+				`\n` +
+				`{"key1":"value1","key2":"value2","log":"Another example log"}`,
+			logsFunc: twoLogsFunc,
+		},
+		{
+			name:      "empty body",
+			bodyRegex: `{"key1":"value1","key2":"value2"}`,
+
+			logsFunc: func() plog.ResourceLogs {
+				rls := plog.NewResourceLogs()
+				slgs := rls.ScopeLogs().AppendEmpty()
+				log := slgs.LogRecords().AppendEmpty()
+
+				log.Attributes().PutStr("key1", "value1")
+				log.Attributes().PutStr("key2", "value2")
+
+				return rls
+			},
+		},
+		{
+			name: "complex body",
+			bodyRegex: `{"log":{"a":"b","c":false,"d":20,"e":20.5,"f":\["p",true,13,19.3\],` +
+				`"g":{"h":"i","j":false,"k":12,"l":11.1}},"m":"n"}`,
+			logsFunc: twoComplexBodyLogsFunc,
+		},
+	}
+
+	for _, tc := range testcases {
+		t.Run(tc.name, func(t *testing.T) {
+			test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
+				func(_ http.ResponseWriter, req *http.Request) {
+					body := extractBody(t, req)
+					assert.Regexp(t, tc.bodyRegex, body)
+				},
+			}, tc.configOpts...)
+
+			test.s.config.LogFormat = JSONFormat
+
+			_, err := test.s.sendNonOTLPLogs(context.Background(),
+				tc.logsFunc(),
+				fields{},
+			)
+			assert.NoError(t, err)
+
+			assert.EqualValues(t, 1, *test.reqCounter)
+		})
+	}
 }
 
 func TestSendLogsJson(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(_ http.ResponseWriter, req *http.Request) {
 			body := extractBody(t, req)
-			expected := `{"key1":"value1","key2":"value2","log":"Example log"}
-{"key1":"value1","key2":"value2","log":"Another example log"}`
-			assert.Equal(t, expected, body)
+			var regex string
+			regex += `{"key1":"value1","key2":"value2","log":"Example log"}`
+			regex += `\n`
+			regex += `{"key1":"value1","key2":"value2","log":"Another example log"}`
+			assert.Regexp(t, regex, body)
+
+			assert.Equal(t, "key=value", req.Header.Get("X-Sumo-Fields"))
+			assert.Equal(t, "otelcol", req.Header.Get("X-Sumo-Client"))
+			assert.Equal(t, "application/x-www-form-urlencoded", req.Header.Get("Content-Type"))
+		},
+	})
+	test.s.config.LogFormat = JSONFormat
+
+	rls := plog.NewResourceLogs()
+	slgs := rls.ScopeLogs().AppendEmpty()
+	log := slgs.LogRecords().AppendEmpty()
+
+	log.Body().SetStr("Example log")
+	log.Attributes().PutStr("key1", "value1")
+	log.Attributes().PutStr("key2", "value2")
+
+	log = slgs.LogRecords().AppendEmpty()
+	log.Body().SetStr("Another example log")
+	log.Attributes().PutStr("key1", "value1")
+	log.Attributes().PutStr("key2", "value2")
+
+	_, err := test.s.sendNonOTLPLogs(context.Background(),
+		rls,
+		fieldsFromMap(map[string]string{"key": "value"}),
+	)
+	assert.NoError(t, err)
+
+	assert.EqualValues(t, 1, *test.reqCounter)
+}
+
+func TestSendLogsJsonHTLM(t *testing.T) {
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
+		func(_ http.ResponseWriter, req *http.Request) {
+			body := extractBody(t, req)
+			var regex string
+			regex += `{"key1":"value1","key2":"value2","log":"Example log"}`
+			regex += `\n`
+			regex += `{"key1":"value1","key2":"value2","log":"<p>Another example log</p>"}`
+			assert.Regexp(t, regex, body)
+
 			assert.Equal(t, "key=value", req.Header.Get("X-Sumo-Fields"))
 			assert.Equal(t, "otelcol", req.Header.Get("X-Sumo-Client"))
 			assert.Equal(t, "application/x-www-form-urlencoded", req.Header.Get("Content-Type"))
 		},
 	})
-	defer func() { test.srv.Close() }()
 	test.s.config.LogFormat = JSONFormat
-	test.s.logBuffer = exampleTwoLogs()
 
-	_, err := test.s.sendLogs(context.Background(), fieldsFromMap(map[string]string{"key": "value"}))
+	rls := plog.NewResourceLogs()
+	slgs := rls.ScopeLogs().AppendEmpty()
+	log := slgs.LogRecords().AppendEmpty()
+
+	log.Body().SetStr("Example log")
+	log.Attributes().PutStr("key1", "value1")
+	log.Attributes().PutStr("key2", "value2")
+
+	log = slgs.LogRecords().AppendEmpty()
+	log.Body().SetStr("<p>Another example log</p>")
+	log.Attributes().PutStr("key1", "value1")
+	log.Attributes().PutStr("key2", "value2")
+
+	_, err := test.s.sendNonOTLPLogs(context.Background(),
+		rls,
+		fieldsFromMap(map[string]string{"key": "value"}),
+	)
 	assert.NoError(t, err)
+
+	assert.EqualValues(t, 1, *test.reqCounter)
 }
 
 func TestSendLogsJsonMultitype(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(_ http.ResponseWriter, req *http.Request) {
 			body := extractBody(t, req)
-			expected := `{"key1":"value1","key2":"value2","log":{"lk1":"lv1","lk2":13}}
-{"key1":"value1","key2":"value2","log":["lv2",13]}`
-			assert.Equal(t, expected, body)
+			var regex string
+			regex += `{"key1":"value1","key2":"value2","log":{"lk1":"lv1","lk2":13}}`
+			regex += `\n`
+			regex += `{"key1":"value1","key2":"value2","log":\["lv2",13\]}`
+			assert.Regexp(t, regex, body)
+
 			assert.Equal(t, "key=value", req.Header.Get("X-Sumo-Fields"))
 			assert.Equal(t, "otelcol", req.Header.Get("X-Sumo-Client"))
 			assert.Equal(t, "application/x-www-form-urlencoded", req.Header.Get("Content-Type"))
 		},
 	})
-	defer func() { test.srv.Close() }()
 	test.s.config.LogFormat = JSONFormat
-	test.s.logBuffer = exampleMultitypeLogs()
 
-	_, err := test.s.sendLogs(context.Background(), fieldsFromMap(map[string]string{"key": "value"}))
+	rls := plog.NewResourceLogs()
+	slgs := rls.ScopeLogs().AppendEmpty()
+
+	attVal := pcommon.NewValueMap()
+	attMap := attVal.Map()
+	attMap.PutStr("lk1", "lv1")
+	attMap.PutInt("lk2", 13)
+
+	log := slgs.LogRecords().AppendEmpty()
+	attVal.CopyTo(log.Body())
+
+	log.Attributes().PutStr("key1", "value1")
+	log.Attributes().PutStr("key2", "value2")
+
+	log = slgs.LogRecords().AppendEmpty()
+
+	attVal = pcommon.NewValueSlice()
+	attArr := attVal.Slice()
+	strVal := pcommon.NewValueStr("lv2")
+	intVal := pcommon.NewValueInt(13)
+
+	strVal.CopyTo(attArr.AppendEmpty())
+	intVal.CopyTo(attArr.AppendEmpty())
+
+	attVal.CopyTo(log.Body())
+	log.Attributes().PutStr("key1", "value1")
+	log.Attributes().PutStr("key2", "value2")
+
+	_, err := test.s.sendNonOTLPLogs(context.Background(),
+		rls,
+		fieldsFromMap(map[string]string{"key": "value"}),
+	)
 	assert.NoError(t, err)
+
+	assert.EqualValues(t, 1, *test.reqCounter)
 }
 
 func TestSendLogsJsonSplit(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(_ http.ResponseWriter, req *http.Request) {
 			body := extractBody(t, req)
-			assert.Equal(t, `{"key1":"value1","key2":"value2","log":"Example log"}`, body)
+			var regex string
+			regex += `{"key1":"value1","key2":"value2","log":"Example log"}`
+			assert.Regexp(t, regex, body)
 		},
 		func(_ http.ResponseWriter, req *http.Request) {
 			body := extractBody(t, req)
-			assert.Equal(t, `{"key1":"value1","key2":"value2","log":"Another example log"}`, body)
+			var regex string
+			regex += `{"key1":"value1","key2":"value2","log":"Another example log"}`
+			assert.Regexp(t, regex, body)
 		},
 	})
-	defer func() { test.srv.Close() }()
 	test.s.config.LogFormat = JSONFormat
 	test.s.config.MaxRequestBodySize = 10
-	test.s.logBuffer = exampleTwoLogs()
 
-	_, err := test.s.sendLogs(context.Background(), newFields(pcommon.NewMap()))
+	rls := plog.NewResourceLogs()
+	slgs := rls.ScopeLogs().AppendEmpty()
+	log := slgs.LogRecords().AppendEmpty()
+
+	log.Body().SetStr("Example log")
+	log.Attributes().PutStr("key1", "value1")
+	log.Attributes().PutStr("key2", "value2")
+
+	log = slgs.LogRecords().AppendEmpty()
+	log.Body().SetStr("Another example log")
+	log.Attributes().PutStr("key1", "value1")
+	log.Attributes().PutStr("key2", "value2")
+
+	_, err := test.s.sendNonOTLPLogs(context.Background(),
+		rls,
+		fieldsFromMap(map[string]string{"key": "value"}),
+	)
 	assert.NoError(t, err)
+
+	assert.EqualValues(t, 2, *test.reqCounter)
 }
 
 func TestSendLogsJsonSplitFailedOne(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(w http.ResponseWriter, req *http.Request) {
 			w.WriteHeader(500)
 
 			body := extractBody(t, req)
-			assert.Equal(t, `{"key1":"value1","key2":"value2","log":"Example log"}`, body)
+
+			var regex string
+			regex += `{"key1":"value1","key2":"value2","log":"Example log"}`
+			assert.Regexp(t, regex, body)
 		},
 		func(_ http.ResponseWriter, req *http.Request) {
 			body := extractBody(t, req)
-			assert.Equal(t, `{"key1":"value1","key2":"value2","log":"Another example log"}`, body)
+
+			var regex string
+			regex += `{"key1":"value1","key2":"value2","log":"Another example log"}`
+			assert.Regexp(t, regex, body)
 		},
 	})
-	defer func() { test.srv.Close() }()
 	test.s.config.LogFormat = JSONFormat
 	test.s.config.MaxRequestBodySize = 10
-	test.s.logBuffer = exampleTwoLogs()
 
-	dropped, err := test.s.sendLogs(context.Background(), newFields(pcommon.NewMap()))
+	rls := plog.NewResourceLogs()
+	slgs := rls.ScopeLogs().AppendEmpty()
+	log := slgs.LogRecords().AppendEmpty()
+
+	log.Body().SetStr("Example log")
+	log.Attributes().PutStr("key1", "value1")
+	log.Attributes().PutStr("key2", "value2")
+
+	log = slgs.LogRecords().AppendEmpty()
+	log.Body().SetStr("Another example log")
+	log.Attributes().PutStr("key1", "value1")
+	log.Attributes().PutStr("key2", "value2")
+
+	dropped, err := test.s.sendNonOTLPLogs(context.Background(),
+		rls,
+		fieldsFromMap(map[string]string{"key": "value"}),
+	)
 	assert.EqualError(t, err, "failed sending data: status: 500 Internal Server Error")
-	assert.Equal(t, test.s.logBuffer[0:1], dropped)
+	assert.Len(t, dropped, 1)
+
+	assert.EqualValues(t, 2, *test.reqCounter)
 }
 
 func TestSendLogsJsonSplitFailedAll(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(w http.ResponseWriter, req *http.Request) {
 			w.WriteHeader(500)
 
 			body := extractBody(t, req)
-			assert.Equal(t, `{"key1":"value1","key2":"value2","log":"Example log"}`, body)
+
+			var regex string
+			regex += `{"key1":"value1","key2":"value2","log":"Example log"}`
+			assert.Regexp(t, regex, body)
 		},
 		func(w http.ResponseWriter, req *http.Request) {
 			w.WriteHeader(404)
 
 			body := extractBody(t, req)
-			assert.Equal(t, `{"key1":"value1","key2":"value2","log":"Another example log"}`, body)
+
+			var regex string
+			regex += `{"key1":"value1","key2":"value2","log":"Another example log"}`
+			assert.Regexp(t, regex, body)
 		},
 	})
-	defer func() { test.srv.Close() }()
 	test.s.config.LogFormat = JSONFormat
 	test.s.config.MaxRequestBodySize = 10
-	test.s.logBuffer = exampleTwoLogs()
 
-	dropped, err := test.s.sendLogs(context.Background(), newFields(pcommon.NewMap()))
+	rls := plog.NewResourceLogs()
+	slgs := rls.ScopeLogs().AppendEmpty()
+	log := slgs.LogRecords().AppendEmpty()
+
+	log.Body().SetStr("Example log")
+	log.Attributes().PutStr("key1", "value1")
+	log.Attributes().PutStr("key2", "value2")
+
+	log = slgs.LogRecords().AppendEmpty()
+	log.Body().SetStr("Another example log")
+	log.Attributes().PutStr("key1", "value1")
+	log.Attributes().PutStr("key2", "value2")
+
+	dropped, err := test.s.sendNonOTLPLogs(context.Background(),
+		rls,
+		fields{},
+	)
+
 	assert.EqualError(
 		t,
 		err,
 		"failed sending data: status: 500 Internal Server Error\nfailed sending data: status: 404 Not Found",
 	)
-	assert.Equal(t, test.s.logBuffer[0:2], dropped)
+	assert.Len(t, dropped, 2)
+
+	assert.EqualValues(t, 2, *test.reqCounter)
 }
 
 func TestSendLogsUnexpectedFormat(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(_ http.ResponseWriter, _ *http.Request) {
 		},
 	})
-	defer func() { test.srv.Close() }()
 	test.s.config.LogFormat = "dummy"
-	logs := exampleTwoLogs()
-	test.s.logBuffer = logs
 
-	dropped, err := test.s.sendLogs(context.Background(), newFields(pcommon.NewMap()))
+	rls := plog.NewResourceLogs()
+	slgs := rls.ScopeLogs().AppendEmpty()
+	log := slgs.LogRecords().AppendEmpty()
+	log.Body().SetStr("Example log")
+
+	dropped, err := test.s.sendNonOTLPLogs(context.Background(),
+		rls,
+		fields{},
+	)
 	assert.Error(t, err)
-	assert.Equal(t, logs, dropped)
+	assert.Len(t, dropped, 1)
+	assert.Equal(t, []plog.LogRecord{log}, dropped)
 }
 
-func TestOverrideSourceName(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+func TestSendLogsOTLP(t *testing.T) {
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(_ http.ResponseWriter, req *http.Request) {
-			assert.Equal(t, "Test source name/test_name", req.Header.Get("X-Sumo-Name"))
-		},
-	})
-	defer func() { test.srv.Close() }()
-
-	test.s.sources.name = getTestSourceFormat("Test source name/%{key1}")
-	test.s.logBuffer = exampleLog()
-
-	_, err := test.s.sendLogs(context.Background(), fieldsFromMap(map[string]string{"key1": "test_name"}))
-	assert.NoError(t, err)
-}
+			body := extractBody(t, req)
+			//nolint:lll
+			assert.Equal(t, "\n\x84\x01\n\x00\x12;\n\x00\x127*\r\n\vExample log2\x10\n\x04key1\x12\b\n\x06value12\x10\n\x04key2\x12\b\n\x06value2J\x00R\x00\x12C\n\x00\x12?*\x15\n\x13Another example log2\x10\n\x04key1\x12\b\n\x06value12\x10\n\x04key2\x12\b\n\x06value2J\x00R\x00", body)
 
-func TestOverrideSourceCategory(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
-		func(_ http.ResponseWriter, req *http.Request) {
-			assert.Equal(t, "Test source category/test_name", req.Header.Get("X-Sumo-Category"))
+			assert.Equal(t, "otelcol", req.Header.Get("X-Sumo-Client"))
+			assert.Equal(t, "application/x-protobuf", req.Header.Get("Content-Type"))
+
+			assert.Empty(t, req.Header.Get("X-Sumo-Fields"),
+				"We should not get X-Sumo-Fields header when sending data with OTLP",
+			)
+			assert.Empty(t, req.Header.Get("X-Sumo-Category"),
+				"We should not get X-Sumo-Category header when sending data with OTLP",
+			)
+			assert.Empty(t, req.Header.Get("X-Sumo-Name"),
+				"We should not get X-Sumo-Name header when sending data with OTLP",
+			)
+			assert.Empty(t, req.Header.Get("X-Sumo-Host"),
+				"We should not get X-Sumo-Host header when sending data with OTLP",
+			)
 		},
 	})
-	defer func() { test.srv.Close() }()
 
-	test.s.sources.category = getTestSourceFormat("Test source category/%{key1}")
-	test.s.logBuffer = exampleLog()
+	test.s.config.LogFormat = "otlp"
 
-	_, err := test.s.sendLogs(context.Background(), fieldsFromMap(map[string]string{"key1": "test_name"}))
-	assert.NoError(t, err)
-}
+	l := plog.NewLogs()
+	ls := l.ResourceLogs().AppendEmpty()
 
-func TestOverrideSourceHost(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
-		func(_ http.ResponseWriter, req *http.Request) {
-			assert.Equal(t, "Test source host/test_name", req.Header.Get("X-Sumo-Host"))
-		},
-	})
-	defer func() { test.srv.Close() }()
+	logRecords := exampleTwoLogs()
+	for i := 0; i < len(logRecords); i++ {
+		logRecords[i].MoveTo(ls.ScopeLogs().AppendEmpty().LogRecords().AppendEmpty())
+	}
 
-	test.s.sources.host = getTestSourceFormat("Test source host/%{key1}")
-	test.s.logBuffer = exampleLog()
+	l.MarkReadOnly()
 
-	_, err := test.s.sendLogs(context.Background(), fieldsFromMap(map[string]string{"key1": "test_name"}))
-	assert.NoError(t, err)
+	assert.NoError(t, test.s.sendOTLPLogs(context.Background(), l))
+	assert.EqualValues(t, 1, *test.reqCounter)
 }
 
-func TestLogsBuffer(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){})
-	defer func() { test.srv.Close() }()
-
-	assert.Equal(t, test.s.countLogs(), 0)
-	logs := exampleTwoLogs()
-
-	droppedLogs, err := test.s.batchLog(context.Background(), logs[0], newFields(pcommon.NewMap()))
-	require.NoError(t, err)
-	assert.Nil(t, droppedLogs)
-	assert.Equal(t, 1, test.s.countLogs())
-	assert.Equal(t, []plog.LogRecord{logs[0]}, test.s.logBuffer)
-
-	droppedLogs, err = test.s.batchLog(context.Background(), logs[1], newFields(pcommon.NewMap()))
-	require.NoError(t, err)
-	assert.Nil(t, droppedLogs)
-	assert.Equal(t, 2, test.s.countLogs())
-	assert.Equal(t, logs, test.s.logBuffer)
-
-	test.s.cleanLogsBuffer()
-	assert.Equal(t, 0, test.s.countLogs())
-	assert.Equal(t, []plog.LogRecord{}, test.s.logBuffer)
+func TestLogsHandlesReceiverResponses(t *testing.T) {
+	t.Run("json with too many fields logs a warning", func(t *testing.T) {
+		test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
+			func(w http.ResponseWriter, _ *http.Request) {
+				fmt.Fprintf(w, `{
+					"status" : 200,
+					"id" : "YBLR1-S2T29-MVXEJ",
+					"code" : "bad.http.header.fields",
+					"message" : "X-Sumo-Fields Warning: 14 key-value pairs are dropped as they are exceeding maximum key-value pair number limit 30."
+				  }`)
+			},
+		}, func(c *Config) {
+			c.LogFormat = JSONFormat
+		})
+
+		rls := plog.NewResourceLogs()
+		rls.ScopeLogs().AppendEmpty().LogRecords().AppendEmpty().Body().SetStr("Example log")
+
+		var buffer bytes.Buffer
+		writer := bufio.NewWriter(&buffer)
+		test.s.logger = zap.New(
+			zapcore.NewCore(
+				zapcore.NewConsoleEncoder(zap.NewDevelopmentEncoderConfig()),
+				zapcore.AddSync(writer),
+				zapcore.DebugLevel,
+			),
+		)
+
+		_, err := test.s.sendNonOTLPLogs(context.Background(),
+			rls,
+			fieldsFromMap(
+				map[string]string{
+					"cluster":         "abcaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+					"code":            "4222222222222222222222222222222222222222222222222222222222222222222222222222222222222",
+					"component":       "apiserver",
+					"endpoint":        "httpsaaaaaaaaaaaaaaaaaaa",
+					"a":               "a",
+					"b":               "b",
+					"c":               "c",
+					"d":               "d",
+					"e":               "e",
+					"f":               "f",
+					"g":               "g",
+					"q":               "q",
+					"w":               "w",
+					"r":               "r",
+					"t":               "t",
+					"y":               "y",
+					"1":               "1",
+					"2":               "2",
+					"3":               "3",
+					"4":               "4",
+					"5":               "5",
+					"6":               "6",
+					"7":               "7",
+					"8":               "8",
+					"9":               "9",
+					"10":              "10",
+					"11":              "11",
+					"12":              "12",
+					"13":              "13",
+					"14":              "14",
+					"15":              "15",
+					"16":              "16",
+					"17":              "17",
+					"18":              "18",
+					"19":              "19",
+					"20":              "20",
+					"21":              "21",
+					"22":              "22",
+					"23":              "23",
+					"24":              "24",
+					"25":              "25",
+					"26":              "26",
+					"27":              "27",
+					"28":              "28",
+					"29":              "29",
+					"_sourceName":     "test_source_name",
+					"_sourceHost":     "test_source_host",
+					"_sourceCategory": "test_source_category",
+				}),
+		)
+		assert.NoError(t, writer.Flush())
+		assert.NoError(t, err)
+		assert.EqualValues(t, 1, *test.reqCounter)
+
+		assert.Contains(t,
+			buffer.String(),
+			`There was an issue sending data	{`+
+				`"status": "200 OK", `+
+				`"id": "YBLR1-S2T29-MVXEJ", `+
+				`"code": "bad.http.header.fields", `+
+				`"message": "X-Sumo-Fields Warning: 14 key-value pairs are dropped as they are exceeding maximum key-value pair number limit 30."`,
+		)
+	})
 }
 
 func TestInvalidEndpoint(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){})
-	defer func() { test.srv.Close() }()
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){})
 
 	test.s.dataURLLogs = ":"
-	test.s.logBuffer = exampleLog()
 
-	_, err := test.s.sendLogs(context.Background(), newFields(pcommon.NewMap()))
+	rls := plog.NewResourceLogs()
+	rls.ScopeLogs().AppendEmpty().LogRecords().AppendEmpty().Body().SetStr("Example log")
+
+	_, err := test.s.sendNonOTLPLogs(context.Background(), rls, fields{})
 	assert.EqualError(t, err, `parse ":": missing protocol scheme`)
 }
 
 func TestInvalidPostRequest(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){})
-	defer func() { test.srv.Close() }()
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){})
 
 	test.s.dataURLLogs = ""
-	test.s.logBuffer = exampleLog()
+	rls := plog.NewResourceLogs()
+	rls.ScopeLogs().AppendEmpty().LogRecords().AppendEmpty().Body().SetStr("Example log")
 
-	_, err := test.s.sendLogs(context.Background(), newFields(pcommon.NewMap()))
+	_, err := test.s.sendNonOTLPLogs(context.Background(), rls, fields{})
 	assert.EqualError(t, err, `Post "": unsupported protocol scheme ""`)
 }
 
-func TestLogsBufferOverflow(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){})
-	defer func() { test.srv.Close() }()
-
-	test.s.dataURLLogs = ":"
-	log := exampleLog()
-	flds := newFields(pcommon.NewMap())
-
-	for test.s.countLogs() < maxBufferSize-1 {
-		_, err := test.s.batchLog(context.Background(), log[0], flds)
-		require.NoError(t, err)
-	}
-
-	_, err := test.s.batchLog(context.Background(), log[0], flds)
-	assert.EqualError(t, err, `parse ":": missing protocol scheme`)
-	assert.Equal(t, 0, test.s.countLogs())
-}
-
 func TestInvalidMetricFormat(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){})
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){})
 	defer func() { test.srv.Close() }()
 
 	test.s.config.MetricFormat = "invalid"
@@ -531,7 +950,7 @@ func TestInvalidMetricFormat(t *testing.T) {
 }
 
 func TestInvalidPipeline(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){})
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){})
 	defer func() { test.srv.Close() }()
 
 	err := test.s.send(context.Background(), "invalidPipeline", newCountingReader(0).withString(""), newFields(pcommon.NewMap()))
@@ -539,79 +958,91 @@ func TestInvalidPipeline(t *testing.T) {
 }
 
 func TestSendCompressGzip(t *testing.T) {
-	test := prepareSenderTest(t, []func(res http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, configcompression.TypeGzip, []func(res http.ResponseWriter, req *http.Request){
 		func(res http.ResponseWriter, req *http.Request) {
 			res.WriteHeader(200)
-			_, err := res.Write([]byte(""))
-			require.NoError(t, err)
+			if _, err := res.Write([]byte("")); err != nil {
+				res.WriteHeader(http.StatusInternalServerError)
+				assert.FailNow(t, "err: %v", err)
+				return
+			}
 			body := decodeGzip(t, req.Body)
 			assert.Equal(t, "gzip", req.Header.Get("Content-Encoding"))
 			assert.Equal(t, "Some example log", body)
 		},
 	})
-	defer func() { test.srv.Close() }()
-
-	test.s.config.CompressEncoding = "gzip"
-
-	c, err := newCompressor("gzip")
-	require.NoError(t, err)
 
-	test.s.compressor = c
 	reader := newCountingReader(0).withString("Some example log")
 
-	err = test.s.send(context.Background(), LogsPipeline, reader, newFields(pcommon.NewMap()))
+	err := test.s.send(context.Background(), LogsPipeline, reader, fields{})
 	require.NoError(t, err)
 }
 
-func TestSendCompressDeflate(t *testing.T) {
-	test := prepareSenderTest(t, []func(res http.ResponseWriter, req *http.Request){
+func TestSendCompressGzipDeprecated(t *testing.T) {
+	test := prepareSenderTest(t, "default", []func(res http.ResponseWriter, req *http.Request){
 		func(res http.ResponseWriter, req *http.Request) {
 			res.WriteHeader(200)
-			_, err := res.Write([]byte(""))
-			require.NoError(t, err)
-			body := decodeDeflate(t, req.Body)
-			assert.Equal(t, "deflate", req.Header.Get("Content-Encoding"))
+			if _, err := res.Write([]byte("")); err != nil {
+				res.WriteHeader(http.StatusInternalServerError)
+				assert.FailNow(t, "err: %v", err)
+				return
+			}
+			body := decodeGzip(t, req.Body)
+			assert.Equal(t, "gzip", req.Header.Get("Content-Encoding"))
 			assert.Equal(t, "Some example log", body)
 		},
 	})
-	defer func() { test.srv.Close() }()
-
-	test.s.config.CompressEncoding = "deflate"
 
-	c, err := newCompressor("deflate")
-	require.NoError(t, err)
-
-	test.s.compressor = c
 	reader := newCountingReader(0).withString("Some example log")
 
-	err = test.s.send(context.Background(), LogsPipeline, reader, newFields(pcommon.NewMap()))
+	err := test.s.send(context.Background(), LogsPipeline, reader, fields{})
 	require.NoError(t, err)
 }
 
-func TestCompressionError(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){})
-	defer func() { test.srv.Close() }()
+func TestSendCompressZstd(t *testing.T) {
+	test := prepareSenderTest(t, configcompression.TypeZstd, []func(res http.ResponseWriter, req *http.Request){
+		func(res http.ResponseWriter, req *http.Request) {
+			res.WriteHeader(200)
+			if _, err := res.Write([]byte("")); err != nil {
+				res.WriteHeader(http.StatusInternalServerError)
+				assert.FailNow(t, "err: %v", err)
+				return
+			}
+			body := decodeZstd(t, req.Body)
+			assert.Equal(t, "zstd", req.Header.Get("Content-Encoding"))
+			assert.Equal(t, "Some example log", body)
+		},
+	})
 
-	test.s.compressor = getTestCompressor(errors.New("read error"), nil)
 	reader := newCountingReader(0).withString("Some example log")
 
-	err := test.s.send(context.Background(), LogsPipeline, reader, newFields(pcommon.NewMap()))
-	assert.EqualError(t, err, "read error")
+	err := test.s.send(context.Background(), LogsPipeline, reader, fields{})
+	require.NoError(t, err)
 }
 
-func TestInvalidContentEncoding(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){})
-	defer func() { test.srv.Close() }()
+func TestSendCompressDeflate(t *testing.T) {
+	test := prepareSenderTest(t, configcompression.TypeDeflate, []func(res http.ResponseWriter, req *http.Request){
+		func(res http.ResponseWriter, req *http.Request) {
+			res.WriteHeader(200)
+			if _, err := res.Write([]byte("")); err != nil {
+				res.WriteHeader(http.StatusInternalServerError)
+				assert.FailNow(t, "err: %v", err)
+				return
+			}
+			body := decodeZlib(t, req.Body)
+			assert.Equal(t, "deflate", req.Header.Get("Content-Encoding"))
+			assert.Equal(t, "Some example log", body)
+		},
+	})
 
-	test.s.config.CompressEncoding = "test"
 	reader := newCountingReader(0).withString("Some example log")
 
-	err := test.s.send(context.Background(), LogsPipeline, reader, newFields(pcommon.NewMap()))
-	assert.EqualError(t, err, "invalid content encoding: test")
+	err := test.s.send(context.Background(), LogsPipeline, reader, fields{})
+	require.NoError(t, err)
 }
 
 func TestSendMetrics(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(_ http.ResponseWriter, req *http.Request) {
 			body := extractBody(t, req)
 			expected := `` +
@@ -639,7 +1070,7 @@ func TestSendMetrics(t *testing.T) {
 }
 
 func TestSendMetricsSplit(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(_ http.ResponseWriter, req *http.Request) {
 			body := extractBody(t, req)
 			expected := `` +
@@ -667,7 +1098,7 @@ func TestSendMetricsSplit(t *testing.T) {
 }
 
 func TestSendOTLPHistogram(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(_ http.ResponseWriter, req *http.Request) {
 			unmarshaler := pmetric.ProtoUnmarshaler{}
 			body, err := io.ReadAll(req.Body)
@@ -698,7 +1129,7 @@ func TestSendOTLPHistogram(t *testing.T) {
 }
 
 func TestSendMetricsSplitBySource(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(_ http.ResponseWriter, req *http.Request) {
 			body := extractBody(t, req)
 			expected := `test.metric.data{test="test_value",test2="second_value",_sourceHost="value1"} 14500 1605534165000`
@@ -736,7 +1167,7 @@ func TestSendMetricsSplitBySource(t *testing.T) {
 }
 
 func TestSendMetricsSplitFailedOne(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(w http.ResponseWriter, req *http.Request) {
 			w.WriteHeader(500)
 
@@ -777,7 +1208,7 @@ func TestSendMetricsSplitFailedOne(t *testing.T) {
 }
 
 func TestSendMetricsSplitFailedAll(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(w http.ResponseWriter, req *http.Request) {
 			w.WriteHeader(500)
 
@@ -831,7 +1262,7 @@ func TestSendMetricsSplitFailedAll(t *testing.T) {
 
 func TestSendMetricsUnexpectedFormat(t *testing.T) {
 	// Expect no requestes
-	test := prepareSenderTest(t, nil)
+	test := prepareSenderTest(t, NoCompression, nil)
 	test.s.config.MetricFormat = "invalid"
 
 	metricSum, attrs := exampleIntMetric()
@@ -846,7 +1277,7 @@ func TestSendMetricsUnexpectedFormat(t *testing.T) {
 }
 
 func TestBadRequestCausesPermanentError(t *testing.T) {
-	test := prepareSenderTest(t, []func(w http.ResponseWriter, req *http.Request){
+	test := prepareSenderTest(t, NoCompression, []func(w http.ResponseWriter, req *http.Request){
 		func(res http.ResponseWriter, _ *http.Request) {
 			res.WriteHeader(400)
 		},