diff --git a/CHANGELOG.md b/CHANGELOG.md
index a850b99..eb7caec 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+- [#xxx]() Every event has a unique id set, so it can be filtered in logs. 
+           The `kafkaIngester`, `tailer` and `envoyAccessLogServer` modules
+           has new config option `eventIdMetadataKey` to use value of this metadata key as the unique identifier.
+           (Mostly should be used with a trace id for example).
+
+### Changed
+- _Internal:_ Event structs `Raw` and `Slo` has been abstracted into interfaces.
+
 ## [v6.9.0] 2021-07-14
 ### Added
 - [#60](https://github.com/seznam/slo-exporter/pull/60) New module eventMetadataRenamer
diff --git a/docs/modules/envoy_access_log_server.md b/docs/modules/envoy_access_log_server.md
index 2fb1659..98168d0 100644
--- a/docs/modules/envoy_access_log_server.md
+++ b/docs/modules/envoy_access_log_server.md
@@ -131,4 +131,6 @@ Please note that some of the keys may not be present	|
 address: ":18090"
 # gracefulShutdownTimeout for the GRPC server. Please note also the existence of 'maximumGracefulShutdownDuration' global config option which is effectively an upper boundary of here-specified timeout value.
 gracefulShutdownTimeout: "5s"
+# eventIdMetadataKey it's value will be used as a unique id for the generated event if present.
+eventIdMetadataKey: <string>
 ```
diff --git a/docs/modules/kafka_ingester.md b/docs/modules/kafka_ingester.md
index b08e4c1..f876198 100644
--- a/docs/modules/kafka_ingester.md
+++ b/docs/modules/kafka_ingester.md
@@ -28,6 +28,8 @@ retentionTime: <duration>
 # fallbackStartOffset determines from whence the consumer group should begin consuming when it finds a partition without a committed offset.
 # Default: FirstOffset
 fallbackStartOffset: <LastOffset|FirstOffset>
+# eventIdMetadataKey it's value will be used as a unique id for the generated event if present.
+eventIdMetadataKey: <string>
 ```
 
 
diff --git a/docs/modules/tailer.md b/docs/modules/tailer.md
index facf6e0..b3b498e 100644
--- a/docs/modules/tailer.md
+++ b/docs/modules/tailer.md
@@ -35,5 +35,7 @@ positionPersistenceInterval: "2s"
 loglineParseRegexp: '^(?P<ip>[A-Fa-f0-9.:]{4,50}) \S+ \S+ \[(?P<time>.*?)\] "(?P<request>.*?)" (?P<statusCode>\d+) \d+ "(?P<referer>.*?)" uag="(?P<userAgent>[^"]+)" "[^"]+" ua="[^"]+" rt="(?P<requestDuration>\d+(\.\d+)??)".+ignore-slo="(?P<ignoreSloHeader>[^"]*)" slo-domain="(?P<sloDomain>[^"]*)" slo-app="(?P<sloApp>[^"]*)" slo-class="(?P<sloClass>[^"]*)" slo-endpoint="(?P<sloEndpoint>[^"]*)" slo-result="(?P<sloResult>[^"]*)"'    # emptyGroupRE defines RE used to decide whether some of the RE match groups specified in loglineParseRegexp is empty and this its assigned variable should be kept unitialized
 # Value, that will be treated as empty value.
 emptyGroupRE: '^-$'
+# eventIdMetadataKey it's value will be used as a unique id for the generated event if present.
+eventIdMetadataKey: <string>
 ```
 
diff --git a/go.mod b/go.mod
index 00a3ab2..cf9e846 100644
--- a/go.mod
+++ b/go.mod
@@ -7,6 +7,7 @@ require (
 	github.com/go-kit/kit v0.10.0
 	github.com/go-test/deep v1.0.6
 	github.com/golang/protobuf v1.4.2
+	github.com/google/uuid v1.3.0 // indirect
 	github.com/gorilla/mux v1.7.4
 	github.com/grafana/loki v1.5.0
 	github.com/grpc-ecosystem/go-grpc-prometheus v1.2.1-0.20191002090509-6af20e3a5340
diff --git a/go.sum b/go.sum
index 6f3c5ce..7c456a9 100644
--- a/go.sum
+++ b/go.sum
@@ -350,6 +350,8 @@ github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm4
 github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/googleapis/gax-go v2.0.2+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
 github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
 github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
diff --git a/pkg/dynamic_classifier/dynamic_classifier.go b/pkg/dynamic_classifier/dynamic_classifier.go
index 6c1aae8..6d2f696 100644
--- a/pkg/dynamic_classifier/dynamic_classifier.go
+++ b/pkg/dynamic_classifier/dynamic_classifier.go
@@ -60,8 +60,8 @@ type DynamicClassifier struct {
 	unclassifiedEventMetadataKeys []string
 	eventsMetric                  *prometheus.CounterVec
 	observer                      pipeline.EventProcessingDurationObserver
-	inputChannel                  chan *event.Raw
-	outputChannel                 chan *event.Raw
+	inputChannel                  chan event.Raw
+	outputChannel                 chan event.Raw
 	logger                        logrus.FieldLogger
 	done                          bool
 }
@@ -102,11 +102,11 @@ func (dc *DynamicClassifier) Stop() {
 	return
 }
 
-func (dc *DynamicClassifier) SetInputChannel(channel chan *event.Raw) {
+func (dc *DynamicClassifier) SetInputChannel(channel chan event.Raw) {
 	dc.inputChannel = channel
 }
 
-func (dc *DynamicClassifier) OutputChannel() chan *event.Raw {
+func (dc *DynamicClassifier) OutputChannel() chan event.Raw {
 	return dc.outputChannel
 }
 
@@ -129,8 +129,8 @@ func New(conf classifierConfig, logger logrus.FieldLogger) (*DynamicClassifier,
 		exactMatches:                  newMemoryExactMatcher(logger),
 		regexpMatches:                 newRegexpMatcher(logger),
 		unclassifiedEventMetadataKeys: conf.UnclassifiedEventMetadataKeys,
-		inputChannel:                  make(chan *event.Raw),
-		outputChannel:                 make(chan *event.Raw),
+		inputChannel:                  make(chan event.Raw),
+		outputChannel:                 make(chan event.Raw),
 		done:                          false,
 		logger:                        logger,
 	}
@@ -235,7 +235,7 @@ func (dc *DynamicClassifier) loadMatchesFromCSV(matcher matcher, path string) er
 		sloApp := line[1]
 		sloClass := line[2]
 		sloEndpoint := line[3]
-		classification := &event.SloClassification{
+		classification := event.SloClassification{
 			Domain: sloDomain,
 			App:    sloApp,
 			Class:  sloClass,
@@ -251,14 +251,14 @@ func (dc *DynamicClassifier) loadMatchesFromCSV(matcher matcher, path string) er
 }
 
 // Classify classifies endpoint by updating its Classification field
-func (dc *DynamicClassifier) Classify(newEvent *event.Raw) (bool, error) {
+func (dc *DynamicClassifier) Classify(newEvent event.Raw) (bool, error) {
 	var (
 		classificationErrors error
-		classification       *event.SloClassification
+		classification       event.SloClassification
 		classifiedBy         matcherType
 	)
 	if newEvent.IsClassified() {
-		if err := dc.exactMatches.set(newEvent.EventKey(), newEvent.SloClassification); err != nil {
+		if err := dc.exactMatches.set(newEvent.EventKey(), newEvent.SloClassification()); err != nil {
 			return true, fmt.Errorf("failed to set the exact matcher: %w", err)
 		}
 		return true, nil
@@ -272,20 +272,20 @@ func (dc *DynamicClassifier) Classify(newEvent *event.Raw) (bool, error) {
 			dc.logger.Errorf("error while classifying event: %+v", err)
 			classificationErrors = multierror.Append(classificationErrors, err)
 		}
-		if classification != nil {
+		if classification.IsClassified() {
 			classifiedBy = classifier.getType()
 			break
 		}
 	}
 
-	if classification == nil {
-		dc.reportEvent(unclassifiedEventLabel, string(classifiedBy), newEvent.Metadata)
+	if !classification.IsClassified() {
+		dc.reportEvent(unclassifiedEventLabel, string(classifiedBy), newEvent.Metadata())
 		return false, classificationErrors
 	}
 
 	dc.logger.Debugf("event '%s' matched by %s matcher", newEvent.EventKey(), classifiedBy)
-	newEvent.UpdateSLOClassification(classification)
-	dc.reportEvent(classifiedEventLabel, string(classifiedBy), newEvent.Metadata)
+	newEvent.SetSLOClassification(classification)
+	dc.reportEvent(classifiedEventLabel, string(classifiedBy), newEvent.Metadata())
 
 	// Those matched by regex we want to write to the exact matcher so it is cached
 	if classifiedBy == regexpMatcherType {
@@ -311,7 +311,7 @@ func (dc *DynamicClassifier) DumpCSV(w io.Writer, matcherType string) error {
 	return matcher.dumpCSV(w)
 }
 
-func (dc *DynamicClassifier) classifyByMatch(matcher matcher, event *event.Raw) (*event.SloClassification, error) {
+func (dc *DynamicClassifier) classifyByMatch(matcher matcher, event event.Raw) (event.SloClassification, error) {
 	return matcher.get(event.EventKey())
 }
 
diff --git a/pkg/dynamic_classifier/dynamic_classifier_test.go b/pkg/dynamic_classifier/dynamic_classifier_test.go
index b81a1e9..0da990d 100644
--- a/pkg/dynamic_classifier/dynamic_classifier_test.go
+++ b/pkg/dynamic_classifier/dynamic_classifier_test.go
@@ -4,9 +4,10 @@ package dynamic_classifier
 //revive:enable:var-naming
 
 import (
+	"github.com/seznam/slo-exporter/pkg/event"
+	"github.com/seznam/slo-exporter/pkg/stringmap"
 	"github.com/sirupsen/logrus"
 	"github.com/stretchr/testify/assert"
-	"github.com/seznam/slo-exporter/pkg/event"
 	"path/filepath"
 	"reflect"
 	"regexp"
@@ -68,17 +69,15 @@ func TestClassificationByExactMatches(t *testing.T) {
 
 	data := []struct {
 		endpoint               string
-		expectedClassification *event.SloClassification
+		expectedClassification event.SloClassification
 		expectedOk             bool
 	}{
 		{"GET:/testing-endpoint", newSloClassification("test-domain", "test-app", "test-class"), true},
-		{"non-classified-endpoint", nil, false},
+		{"non-classified-endpoint", event.SloClassification{}, false},
 	}
 
 	for _, ec := range data {
-		newEvent := &event.Raw{
-			SloClassification: ec.expectedClassification,
-		}
+		newEvent := event.NewRaw("", 1, stringmap.StringMap{}, &ec.expectedClassification)
 		newEvent.SetEventKey(ec.endpoint)
 
 		ok, err := classifier.Classify(newEvent)
@@ -87,8 +86,8 @@ func TestClassificationByExactMatches(t *testing.T) {
 		}
 
 		assert.Equal(t, ec.expectedOk, ok)
-		if !reflect.DeepEqual(ec.expectedClassification, newEvent.SloClassification) {
-			t.Errorf("Classification does not match %+v != %+v", ec.expectedClassification, newEvent.SloClassification)
+		if !reflect.DeepEqual(ec.expectedClassification, newEvent.SloClassification()) {
+			t.Errorf("Classification does not match %+v != %+v", ec.expectedClassification, newEvent.SloClassification())
 		}
 	}
 }
@@ -101,18 +100,16 @@ func TestClassificationByRegexpMatches(t *testing.T) {
 
 	data := []struct {
 		endpoint               string
-		expectedClassification *event.SloClassification
+		expectedClassification event.SloClassification
 		expectedOk             bool
 	}{
 		{"/api/test/asdf", newSloClassification("test-domain", "test-app", "test-class"), true},
 		{"/api/asdf", newSloClassification("test-domain", "test-app", "test-class-all"), true},
-		{"non-classified-endpoint", nil, false},
+		{"non-classified-endpoint", event.SloClassification{}, false},
 	}
 
 	for _, ec := range data {
-		newEvent := &event.Raw{
-			SloClassification: ec.expectedClassification,
-		}
+		newEvent := event.NewRaw("", 1, stringmap.StringMap{}, &ec.expectedClassification)
 		newEvent.SetEventKey(ec.endpoint)
 
 		ok, err := classifier.Classify(newEvent)
@@ -121,21 +118,19 @@ func TestClassificationByRegexpMatches(t *testing.T) {
 		}
 
 		assert.Equal(t, ec.expectedOk, ok)
-		if !reflect.DeepEqual(ec.expectedClassification, newEvent.SloClassification) {
-			t.Errorf("Classification does not match %+v != %+v", ec.expectedClassification, newEvent.SloClassification)
+		if !reflect.DeepEqual(ec.expectedClassification, newEvent.SloClassification()) {
+			t.Errorf("Classification does not match %+v != %+v", ec.expectedClassification, newEvent.SloClassification())
 		}
 	}
 }
 
 func Test_DynamicClassifier_Classify_UpdatesEmptyCache(t *testing.T) {
 	eventKey := "GET:/testing-endpoint"
-	classifiedEvent := &event.Raw{
-		SloClassification: &event.SloClassification{
-			Domain: "domain",
-			App:    "app",
-			Class:  "class",
-		},
-	}
+	classifiedEvent := event.NewRaw("", 1, stringmap.StringMap{}, &event.SloClassification{
+		Domain: "domain",
+		App:    "app",
+		Class:  "class",
+	})
 	classifiedEvent.SetEventKey(eventKey)
 
 	// test that classified event updates an empty exact matches cache
@@ -148,21 +143,19 @@ func Test_DynamicClassifier_Classify_UpdatesEmptyCache(t *testing.T) {
 	if err != nil {
 		t.Fatalf("error while getting the tested event key from exact Matches classifier: %v", err)
 	}
-	if !reflect.DeepEqual(classifiedEvent.SloClassification, classification) {
-		t.Errorf("event classification '%+v' did not propagate to classifier exact matches cache: %+v", classifiedEvent.SloClassification, classification)
+	if !reflect.DeepEqual(classifiedEvent.SloClassification(), classification) {
+		t.Errorf("event classification '%+v' did not propagate to classifier exact matches cache: %+v", classifiedEvent.SloClassification(), classification)
 	}
 }
 
 // test that classified event updates dynamic classifier cache as initialized from golden file
 func Test_DynamicClassifier_Classify_OverridesCacheFromConfig(t *testing.T) {
 	eventKey := "GET:/testing-endpoint"
-	classifiedEvent := &event.Raw{
-		SloClassification: &event.SloClassification{
-			Domain: "domain",
-			App:    "app",
-			Class:  "class",
-		},
-	}
+	classifiedEvent := event.NewRaw("", 1, stringmap.StringMap{}, &event.SloClassification{
+		Domain: "domain",
+		App:    "app",
+		Class:  "class",
+	})
 	classifiedEvent.SetEventKey(eventKey)
 
 	classifier := newClassifier(t, classifierConfig{RegexpMatchesCsvFiles: goldenFile(t)})
@@ -179,8 +172,8 @@ func Test_DynamicClassifier_Classify_OverridesCacheFromConfig(t *testing.T) {
 	if err != nil {
 		t.Fatalf("error while getting the tested event key from exact Matches classifier: %v", err)
 	}
-	if !reflect.DeepEqual(classifiedEvent.SloClassification, classification) {
-		t.Errorf("classifier cache '%+v' for event_key '%s' was not updated with classification from the classified event '%+v'.", classifiedEvent.SloClassification, eventKey, classification)
+	if !reflect.DeepEqual(classifiedEvent.SloClassification(), classification) {
+		t.Errorf("classifier cache '%+v' for event_key '%s' was not updated with classification from the classified event '%+v'.", classifiedEvent.SloClassification(), eventKey, classification)
 	}
 }
 
@@ -191,13 +184,11 @@ func Test_DynamicClassifier_Classify_OverridesCacheFromPreviousClassifiedEvent(t
 
 	classifier := newClassifier(t, classifierConfig{})
 	for _, eventClass := range eventClasses {
-		classifiedEvent := &event.Raw{
-			SloClassification: &event.SloClassification{
-				Domain: "domain",
-				App:    "app",
-				Class:  eventClass,
-			},
-		}
+		classifiedEvent := event.NewRaw("", 1, stringmap.StringMap{}, &event.SloClassification{
+			Domain: "domain",
+			App:    "app",
+			Class:  eventClass,
+		})
 		classifiedEvent.SetEventKey(eventKey)
 
 		ok, err := classifier.Classify(classifiedEvent)
@@ -208,8 +199,8 @@ func Test_DynamicClassifier_Classify_OverridesCacheFromPreviousClassifiedEvent(t
 		if err != nil {
 			t.Fatalf("error while getting the tested event key from exact Matches classifier: %v", err)
 		}
-		if !reflect.DeepEqual(classifiedEvent.SloClassification, classification) {
-			t.Errorf("classifier cache '%+v' for event_key '%s' was not updated with classification from the classified event '%+v'.", classifiedEvent.SloClassification, eventKey, classification)
+		if !reflect.DeepEqual(classifiedEvent.SloClassification(), classification) {
+			t.Errorf("classifier cache '%+v' for event_key '%s' was not updated with classification from the classified event '%+v'.", classifiedEvent.SloClassification(), eventKey, classification)
 		}
 	}
 }
diff --git a/pkg/dynamic_classifier/matcher.go b/pkg/dynamic_classifier/matcher.go
index d31332a..1a0f793 100644
--- a/pkg/dynamic_classifier/matcher.go
+++ b/pkg/dynamic_classifier/matcher.go
@@ -12,7 +12,7 @@ type matcherType string
 
 type matcher interface {
 	getType() matcherType
-	set(key string, classification *event.SloClassification) error
-	get(key string) (*event.SloClassification, error)
+	set(key string, classification event.SloClassification) error
+	get(key string) (event.SloClassification, error)
 	dumpCSV(w io.Writer) error
 }
diff --git a/pkg/dynamic_classifier/matcher_test.go b/pkg/dynamic_classifier/matcher_test.go
index 3d50900..a8b701e 100644
--- a/pkg/dynamic_classifier/matcher_test.go
+++ b/pkg/dynamic_classifier/matcher_test.go
@@ -6,8 +6,8 @@ package dynamic_classifier
 import (
 	"bytes"
 	"fmt"
-	"github.com/sirupsen/logrus"
 	"github.com/seznam/slo-exporter/pkg/event"
+	"github.com/sirupsen/logrus"
 	"io/ioutil"
 	"path/filepath"
 	"reflect"
@@ -17,8 +17,8 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-func newSloClassification(domain string, app string, class string) *event.SloClassification {
-	return &event.SloClassification{
+func newSloClassification(domain string, app string, class string) event.SloClassification {
+	return event.SloClassification{
 		Domain: domain,
 		App:    app,
 		Class:  class,
@@ -30,15 +30,15 @@ func TestMatcher(t *testing.T) {
 	cases := []struct {
 		matcher     matcher
 		key         string
-		value       *event.SloClassification
+		value       event.SloClassification
 		wantedKey   string
-		wantedValue *event.SloClassification
+		wantedValue event.SloClassification
 		setErr      string
 		getErr      string
 	}{
 		{newMemoryExactMatcher(logger), "test", newSloClassification("test-domain", "test-app", "test-class"), "test", newSloClassification("test-domain", "test-app", "test-class"), "", ""},
 		{newMemoryExactMatcher(logger), "", newSloClassification("test-domain", "test-app", "test-class"), "", newSloClassification("test-domain", "test-app", "test-class"), "", ""},
-		{newMemoryExactMatcher(logger), "test", newSloClassification("test-domain", "test-app", "test-class"), "aaa", nil, "", ""},
+		{newMemoryExactMatcher(logger), "test", newSloClassification("test-domain", "test-app", "test-class"), "aaa", event.SloClassification{}, "", ""},
 		{newRegexpMatcher(logger), ".*", newSloClassification("test-domain", "test-app", "test-class"), "aaa", newSloClassification("test-domain", "test-app", "test-class"), "", ""},
 		{newRegexpMatcher(logger), ".*****", newSloClassification("test-domain", "test-app", "test-class"), "aaa", newSloClassification("test-domain", "test-app", "test-class"), "failed to create new regexp endpoint classification: error parsing regexp: invalid nested repetition operator: `**`", ""},
 	}
diff --git a/pkg/dynamic_classifier/memory_exact_matcher.go b/pkg/dynamic_classifier/memory_exact_matcher.go
index a39f3c3..77ecbf7 100644
--- a/pkg/dynamic_classifier/memory_exact_matcher.go
+++ b/pkg/dynamic_classifier/memory_exact_matcher.go
@@ -6,8 +6,8 @@ package dynamic_classifier
 import (
 	"encoding/csv"
 	"fmt"
-	"github.com/sirupsen/logrus"
 	"github.com/seznam/slo-exporter/pkg/event"
+	"github.com/sirupsen/logrus"
 	"io"
 	"sync"
 
@@ -17,7 +17,7 @@ import (
 const exactMatcherType = "exact"
 
 type memoryExactMatcher struct {
-	exactMatches  map[string]*event.SloClassification
+	exactMatches  map[string]event.SloClassification
 	matchersCount prometheus.Counter
 	mtx           sync.RWMutex
 	logger        logrus.FieldLogger
@@ -25,7 +25,7 @@ type memoryExactMatcher struct {
 
 // newMemoryExactMatcher returns instance of memoryCache
 func newMemoryExactMatcher(logger logrus.FieldLogger) *memoryExactMatcher {
-	exactMatches := map[string]*event.SloClassification{}
+	exactMatches := map[string]event.SloClassification{}
 	return &memoryExactMatcher{
 		exactMatches: exactMatches,
 		mtx:          sync.RWMutex{},
@@ -34,7 +34,7 @@ func newMemoryExactMatcher(logger logrus.FieldLogger) *memoryExactMatcher {
 }
 
 // set sets endpoint classification in cache
-func (c *memoryExactMatcher) set(key string, classification *event.SloClassification) error {
+func (c *memoryExactMatcher) set(key string, classification event.SloClassification) error {
 	timer := prometheus.NewTimer(matcherOperationDurationSeconds.WithLabelValues("set", exactMatcherType))
 	defer timer.ObserveDuration()
 	c.mtx.Lock()
@@ -45,7 +45,7 @@ func (c *memoryExactMatcher) set(key string, classification *event.SloClassifica
 }
 
 // get gets endpoint classification from cache
-func (c *memoryExactMatcher) get(key string) (*event.SloClassification, error) {
+func (c *memoryExactMatcher) get(key string) (event.SloClassification, error) {
 	timer := prometheus.NewTimer(matcherOperationDurationSeconds.WithLabelValues("get", exactMatcherType))
 	defer timer.ObserveDuration()
 	c.mtx.RLock()
diff --git a/pkg/dynamic_classifier/regexp_matcher.go b/pkg/dynamic_classifier/regexp_matcher.go
index 8767f1c..eaa520a 100644
--- a/pkg/dynamic_classifier/regexp_matcher.go
+++ b/pkg/dynamic_classifier/regexp_matcher.go
@@ -6,8 +6,8 @@ package dynamic_classifier
 import (
 	"encoding/csv"
 	"fmt"
-	"github.com/sirupsen/logrus"
 	"github.com/seznam/slo-exporter/pkg/event"
+	"github.com/sirupsen/logrus"
 	"io"
 	"regexp"
 	"sync"
@@ -20,7 +20,7 @@ const regexpMatcherType = "regexp"
 // regexpSloClassification encapsulates combination of regexp and endpoint classification
 type regexpSloClassification struct {
 	regexpCompiled *regexp.Regexp
-	classification *event.SloClassification
+	classification event.SloClassification
 }
 
 // regexpMatcher is list of endpoint classifications
@@ -39,7 +39,7 @@ func newRegexpMatcher(logger logrus.FieldLogger) *regexpMatcher {
 }
 
 // newRegexSloClassification returns new instance of regexpSloClassification
-func newRegexSloClassification(regexpString string, classification *event.SloClassification) (*regexpSloClassification, error) {
+func newRegexSloClassification(regexpString string, classification event.SloClassification) (*regexpSloClassification, error) {
 	compiledMatcher, err := regexp.Compile(regexpString)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create new regexp endpoint classification: %w", err)
@@ -52,7 +52,7 @@ func newRegexSloClassification(regexpString string, classification *event.SloCla
 }
 
 // set adds new endpoint classification regexp to list
-func (rm *regexpMatcher) set(regexpString string, classification *event.SloClassification) error {
+func (rm *regexpMatcher) set(regexpString string, classification event.SloClassification) error {
 	timer := prometheus.NewTimer(matcherOperationDurationSeconds.WithLabelValues("set", regexpMatcherType))
 	defer timer.ObserveDuration()
 	rm.mtx.Lock()
@@ -67,13 +67,13 @@ func (rm *regexpMatcher) set(regexpString string, classification *event.SloClass
 }
 
 // get gets through all regexes and returns first endpoint classification which matches it
-func (rm *regexpMatcher) get(key string) (*event.SloClassification, error) {
+func (rm *regexpMatcher) get(key string) (event.SloClassification, error) {
 	timer := prometheus.NewTimer(matcherOperationDurationSeconds.WithLabelValues("get", regexpMatcherType))
 	defer timer.ObserveDuration()
 	rm.mtx.RLock()
 	defer rm.mtx.RUnlock()
 
-	var classification *event.SloClassification = nil
+	var classification event.SloClassification
 	for _, r := range rm.matchers {
 		// go next if no match
 		if !r.regexpCompiled.MatchString(key) {
@@ -81,7 +81,7 @@ func (rm *regexpMatcher) get(key string) (*event.SloClassification, error) {
 		}
 
 		// if already classified, but matches next regex
-		if classification != nil {
+		if classification.IsClassified() {
 			rm.logger.Warnf("key '%s' is matched by another regexp: '%s'\n", key, r.regexpCompiled.String())
 			continue
 		}
diff --git a/pkg/envoy_access_log_server/access_log_server.go b/pkg/envoy_access_log_server/access_log_server.go
index 4b14df2..96e9dd6 100644
--- a/pkg/envoy_access_log_server/access_log_server.go
+++ b/pkg/envoy_access_log_server/access_log_server.go
@@ -28,16 +28,18 @@ var (
 type accessLogServerConfig struct {
 	Address                 string
 	GracefulShutdownTimeout time.Duration
+	EventIdMetadataKey      string
 }
 
 type AccessLogServer struct {
-	outputChannel           chan *event.Raw
+	outputChannel           chan event.Raw
 	logger                  logrus.FieldLogger
 	done                    bool
 	server                  *grpc.Server
 	service_v3              *AccessLogServiceV3
 	address                 string
 	gracefulShutdownTimeout time.Duration
+	eventIdMetadataKey      string
 }
 
 func init() {
@@ -61,10 +63,11 @@ func NewFromViper(viperConfig *viper.Viper, logger logrus.FieldLogger) (*AccessL
 // New returns an instance of AccessLogServer
 func New(config accessLogServerConfig, logger logrus.FieldLogger) (*AccessLogServer, error) {
 	als := AccessLogServer{
-		outputChannel:           make(chan *event.Raw),
+		outputChannel:           make(chan event.Raw),
 		logger:                  logger,
 		address:                 config.Address,
 		gracefulShutdownTimeout: config.GracefulShutdownTimeout,
+		eventIdMetadataKey:      config.EventIdMetadataKey,
 	}
 	return &als, nil
 }
@@ -79,8 +82,9 @@ func (als *AccessLogServer) Run() {
 	)
 
 	als.service_v3 = &AccessLogServiceV3{
-		outChan: als.outputChannel,
-		logger:  als.logger.WithField("EnvoyApiVersion", "3"),
+		outChan:            als.outputChannel,
+		logger:             als.logger.WithField("EnvoyApiVersion", "3"),
+		eventIdMetadataKey: als.eventIdMetadataKey,
 	}
 	als.service_v3.Register(als.server)
 
@@ -130,6 +134,6 @@ func (als *AccessLogServer) RegisterMetrics(_ prometheus.Registerer, wrappedRegi
 	return nil
 }
 
-func (als *AccessLogServer) OutputChannel() chan *event.Raw {
+func (als *AccessLogServer) OutputChannel() chan event.Raw {
 	return als.outputChannel
 }
diff --git a/pkg/envoy_access_log_server/service_v3.go b/pkg/envoy_access_log_server/service_v3.go
index 59ce3ec..3f97b46 100644
--- a/pkg/envoy_access_log_server/service_v3.go
+++ b/pkg/envoy_access_log_server/service_v3.go
@@ -17,9 +17,10 @@ import (
 )
 
 type AccessLogServiceV3 struct {
-	outChan chan *event.Raw
+	outChan chan event.Raw
 	logger  logrus.FieldLogger
 	envoy_service_accesslog_v3.UnimplementedAccessLogServiceServer
+	eventIdMetadataKey string
 }
 
 type envoyV3AccessLogEntryCommonProperties envoy_data_accesslog_v3.AccessLogCommon
@@ -218,20 +219,16 @@ func (service_v3 *AccessLogServiceV3) emitEvents(msg *envoy_service_accesslog_v3
 	if logs := msg.GetHttpLogs(); logs != nil {
 		for _, l := range logs.LogEntry {
 			logEntriesTotal.WithLabelValues("HTTP", "v3").Inc()
-			e := &event.Raw{
-				Metadata: envoyV3HttpAccessLogEntry(*l).StringMap(service_v3.logger),
-				Quantity: 1,
-			}
+			metadata := envoyV3HttpAccessLogEntry(*l).StringMap(service_v3.logger)
+			e := event.NewRaw(metadata.Get(service_v3.eventIdMetadataKey, ""), 1, metadata, nil)
 			service_v3.logger.Debug(e)
 			service_v3.outChan <- e
 		}
 	} else if logs := msg.GetTcpLogs(); logs != nil {
 		for _, l := range logs.LogEntry {
 			logEntriesTotal.WithLabelValues("TCP", "v3").Inc()
-			e := &event.Raw{
-				Metadata: envoyV3TcpAccessLogEntry(*l).StringMap(service_v3.logger),
-				Quantity: 1,
-			}
+			metadata := envoyV3TcpAccessLogEntry(*l).StringMap(service_v3.logger)
+			e := event.NewRaw(metadata.Get(service_v3.eventIdMetadataKey, ""), 1, metadata, nil)
 			service_v3.logger.Debug(e)
 			service_v3.outChan <- e
 		}
diff --git a/pkg/event/interfaces.go b/pkg/event/interfaces.go
new file mode 100644
index 0000000..bfb1378
--- /dev/null
+++ b/pkg/event/interfaces.go
@@ -0,0 +1,51 @@
+package event
+
+import (
+	"fmt"
+	"github.com/seznam/slo-exporter/pkg/stringmap"
+)
+
+type WithEventKey interface {
+	EventKey() string
+	SetEventKey(k string)
+}
+
+type Classifiable interface {
+	IsClassified() bool
+	SloClassification() SloClassification
+	SetSLOClassification(classification SloClassification)
+}
+
+type WithMetadata interface {
+	SetMetadata(stringMap stringmap.StringMap)
+	Metadata() stringmap.StringMap
+}
+
+type WithQuantity interface {
+	Quantity() float64
+	SetQuantity(float642 float64)
+}
+
+type WithId interface {
+	Id() string
+	SetId(string)
+}
+
+type Raw interface {
+	fmt.Stringer
+	Classifiable
+	WithMetadata
+	WithEventKey
+	WithQuantity
+	WithId
+}
+
+type Slo interface {
+	fmt.Stringer
+	Classifiable
+	WithMetadata
+	WithEventKey
+	WithQuantity
+	Result() Result
+	Copy() Slo
+}
diff --git a/pkg/event/raw.go b/pkg/event/raw.go
index 7d9f539..469e16f 100644
--- a/pkg/event/raw.go
+++ b/pkg/event/raw.go
@@ -2,60 +2,89 @@ package event
 
 import (
 	"fmt"
+	"github.com/google/uuid"
 	"github.com/seznam/slo-exporter/pkg/stringmap"
 )
 
-// Raw represents single event as received by an EventsProcessor instance
-type Raw struct {
-	Metadata          stringmap.StringMap
-	SloClassification *SloClassification
-	Quantity          float64
-}
-
 const (
 	eventKeyMetadataKey = "__eventKey"
 )
 
-func (r *Raw) EventKey() string {
-	return r.Metadata[eventKeyMetadataKey]
+func NewRaw(id string, quantity float64, metadata stringmap.StringMap, classification *SloClassification) Raw {
+	if id == "" {
+		id = uuid.New().String()
+	}
+	if classification == nil {
+		classification = &SloClassification{}
+	}
+	if metadata == nil {
+		metadata = stringmap.StringMap{}
+	}
+	return &raw{
+		id:                id,
+		metadata:          metadata,
+		sloClassification: *classification,
+		quantity:          quantity,
+	}
+}
+
+// raw represents single event as received by an EventsProcessor instance
+type raw struct {
+	id                string
+	metadata          stringmap.StringMap
+	sloClassification SloClassification
+	quantity          float64
 }
 
-func (r *Raw) SetEventKey(k string) {
-	if r.Metadata == nil {
-		r.Metadata = make(stringmap.StringMap)
-	}
-	r.Metadata[eventKeyMetadataKey] = k
+func (r raw) Quantity() float64 {
+	return r.quantity
 }
 
-// UpdateSLOClassification updates SloClassification field
-func (r *Raw) UpdateSLOClassification(classification *SloClassification) {
-	r.SloClassification = classification
+func (r *raw) SetQuantity(newQuantity float64) {
+	r.quantity = newQuantity
 }
 
-// IsClassified check if all SloClassification fields are set
-func (r *Raw) IsClassified() bool {
-	if r.SloClassification != nil &&
-		r.SloClassification.Domain != "" &&
-		r.SloClassification.App != "" &&
-		r.SloClassification.Class != "" {
+func (r raw) Id() string {
+	return r.id
+}
 
-		return true
-	}
-	return false
+func (r *raw) SetId(newId string) {
+	r.id = newId
 }
 
-func (r Raw) GetSloMetadata() stringmap.StringMap {
-	if r.SloClassification == nil {
-		return nil
+func (r raw) EventKey() string {
+	return r.metadata[eventKeyMetadataKey]
+}
+
+func (r *raw) SetEventKey(k string) {
+	if r.metadata == nil {
+		r.metadata = make(stringmap.StringMap)
 	}
-	metadata := r.SloClassification.GetMetadata()
-	return metadata
+	r.metadata[eventKeyMetadataKey] = k
+}
+
+func (r raw) Metadata() stringmap.StringMap {
+	return r.metadata
+}
+
+func (r *raw) SetMetadata(metadata stringmap.StringMap) {
+	r.metadata = metadata
+}
+
+// IsClassified check if all SloClassification fields are set
+func (r raw) IsClassified() bool {
+	return r.sloClassification.IsClassified()
+}
+
+func (r raw) SloClassification() SloClassification {
+	return r.sloClassification
 }
 
-func (r Raw) GetSloClassification() *SloClassification {
-	return r.SloClassification
+// SetSLOClassification updates SloClassification field
+func (r *raw) SetSLOClassification(classification SloClassification) {
+	r.sloClassification = classification
 }
 
-func (r Raw) String() string {
-	return fmt.Sprintf("key: %s, metadata: %s, classification: %s", r.EventKey(), r.Metadata, r.GetSloMetadata())
+func (r raw) String() string {
+	return fmt.Sprintf("id:%s, key: %s, metadata: %s, classification: %s", r.Id(), r.EventKey(), r.Metadata(), r.SloClassification())
 }
diff --git a/pkg/event/slo.go b/pkg/event/slo.go
index 28247cb..db5af71 100644
--- a/pkg/event/slo.go
+++ b/pkg/event/slo.go
@@ -20,34 +20,79 @@ var (
 	PossibleResults = []Result{Success, Fail}
 )
 
-type Slo struct {
+func NewSlo(eventKey string, quantity float64, result Result, classification SloClassification, metadata stringmap.StringMap) Slo {
+	if metadata == nil {
+		metadata = stringmap.StringMap{}
+	}
+	return &slo{
+		key:            eventKey,
+		result:         result,
+		classification: classification,
+		metadata:       metadata,
+		quantity:       quantity,
+	}
+}
+
+type slo struct {
 	// same value as in source event Raw.EventKey()
-	Key    string
-	Result Result
+	key    string
+	result Result
+
+	classification SloClassification
+
+	metadata stringmap.StringMap
+	quantity float64
+}
+
+func (s slo) Quantity() float64 {
+	return s.quantity
+}
+
+func (s *slo) SetQuantity(newQuantity float64) {
+	s.quantity = newQuantity
+}
 
-	Domain string
-	Class  string
-	App    string
+func (s *slo) SetMetadata(newMetadata stringmap.StringMap) {
+	s.metadata = newMetadata
+}
+
+func (s slo) Metadata() stringmap.StringMap {
+	return s.metadata
+}
+
+func (s slo) SloClassification() SloClassification {
+	return s.classification
+}
+
+func (s *slo) SetSLOClassification(classification SloClassification) {
+	s.classification = classification
+}
+
+func (s slo) EventKey() string {
+	return s.key
+}
+
+func (s *slo) SetEventKey(newKey string) {
+	s.key = newKey
+}
 
-	Metadata stringmap.StringMap
-	Quantity float64
+func (s slo) Result() Result {
+	return s.result
 }
 
-func (s *Slo) IsClassified() bool {
-	return s.Domain != "" && s.Class != "" && s.App != ""
+func (s slo) IsClassified() bool {
+	return s.classification.IsClassified()
 }
 
-func (s *Slo) String() string {
-	return fmt.Sprintf("SLO event %q of domain: %q, class: %q, app: %q with metadata: %+v", s.Key, s.Domain, s.Class, s.App, s.Metadata)
+func (s slo) String() string {
+	return fmt.Sprintf("Slo event %s of %s with metadata: %s", s.EventKey(), s.SloClassification(), s.Metadata())
 }
 
-func (s Slo) Copy() Slo {
-	return Slo{
-		Key:      s.Key,
-		Result:   s.Result,
-		Domain:   s.Domain,
-		Class:    s.Class,
-		App:      s.App,
-		Metadata: s.Metadata.Copy(),
+func (s slo) Copy() Slo {
+	return &slo{
+		key:            s.EventKey(),
+		result:         s.Result(),
+		classification: s.SloClassification(),
+		metadata:       s.Metadata().Copy(),
 	}
 }
diff --git a/pkg/event/slo_classification.go b/pkg/event/slo_classification.go
index 0c26212..9b8342e 100644
--- a/pkg/event/slo_classification.go
+++ b/pkg/event/slo_classification.go
@@ -25,6 +25,10 @@ func (sc *SloClassification) Matches(other SloClassification) bool {
 	return true
 }
 
+func (sc SloClassification) IsClassified() bool {
+	return sc.Domain != "" && sc.Class != "" && sc.App != ""
+}
+
 func (sc *SloClassification) GetMetadata() stringmap.StringMap {
 	return stringmap.StringMap{
 		"slo_domain": sc.Domain,
diff --git a/pkg/event/test_utils.go b/pkg/event/test_utils.go
new file mode 100644
index 0000000..389bc6f
--- /dev/null
+++ b/pkg/event/test_utils.go
@@ -0,0 +1,15 @@
+package event
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func AssertRawEventsEqual(t *testing.T, e1, e2 Raw, checkIds bool) {
+	if !checkIds && (e1 != nil && e2 != nil) {
+		e1.SetId("")
+		e2.SetId("")
+	}
+	assert.Equal(t, e1, e2)
+}
+
diff --git a/pkg/event_key_generator/event_key_generator.go b/pkg/event_key_generator/event_key_generator.go
index 2fc6867..90a7afa 100644
--- a/pkg/event_key_generator/event_key_generator.go
+++ b/pkg/event_key_generator/event_key_generator.go
@@ -3,11 +3,11 @@ package event_key_generator
 import (
 	"fmt"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/sirupsen/logrus"
-	"github.com/spf13/viper"
 	"github.com/seznam/slo-exporter/pkg/event"
 	"github.com/seznam/slo-exporter/pkg/pipeline"
 	"github.com/seznam/slo-exporter/pkg/stringmap"
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/viper"
 	"time"
 )
 
@@ -30,8 +30,8 @@ type EventKeyGenerator struct {
 	metadataKeys        []string
 	observer            pipeline.EventProcessingDurationObserver
 	logger              logrus.FieldLogger
-	inputChannel        chan *event.Raw
-	outputChannel       chan *event.Raw
+	inputChannel        chan event.Raw
+	outputChannel       chan event.Raw
 	done                bool
 }
 
@@ -51,11 +51,11 @@ func (e *EventKeyGenerator) Stop() {
 	return
 }
 
-func (e *EventKeyGenerator) SetInputChannel(channel chan *event.Raw) {
+func (e *EventKeyGenerator) SetInputChannel(channel chan event.Raw) {
 	e.inputChannel = channel
 }
 
-func (e *EventKeyGenerator) OutputChannel() chan *event.Raw {
+func (e *EventKeyGenerator) OutputChannel() chan event.Raw {
 	return e.outputChannel
 }
 
@@ -74,8 +74,8 @@ func NewFromConfig(config eventKeyGeneratorConfig, logger logrus.FieldLogger) (*
 		separator:           config.FiledSeparator,
 		overrideExistingKey: config.OverrideExistingEventKey,
 		metadataKeys:        config.MetadataKeys,
-		outputChannel:       make(chan *event.Raw),
-		inputChannel:        make(chan *event.Raw),
+		outputChannel:       make(chan event.Raw),
+		inputChannel:        make(chan event.Raw),
 		done:                false,
 		logger:              logger,
 	}
@@ -119,7 +119,7 @@ func (e *EventKeyGenerator) Run() {
 		for newEvent := range e.inputChannel {
 			start := time.Now()
 			if newEvent.EventKey() == "" || e.overrideExistingKey {
-				newKey := e.generateEventKey(newEvent.Metadata)
+				newKey := e.generateEventKey(newEvent.Metadata())
 				newEvent.SetEventKey(newKey)
 				processedEventsTotal.WithLabelValues("generated-event-key").Inc()
 				e.logger.WithField("event", newEvent).WithField("event-key", newKey).Debug("generated new event key for event")
diff --git a/pkg/event_metadata_renamer/renamer.go b/pkg/event_metadata_renamer/renamer.go
index 63246cf..d0b8d63 100644
--- a/pkg/event_metadata_renamer/renamer.go
+++ b/pkg/event_metadata_renamer/renamer.go
@@ -33,15 +33,16 @@ func NewFromViper(viperConfig *viper.Viper, logger logrus.FieldLogger) (*eventMe
 	return NewFromConfig(config, logger)
 }
 
-// New returns requestNormalizer which allows to add Key to RequestEvent
+// NewFromConfig returns requestNormalizer which allows to add Key to RequestEvent
 func NewFromConfig(config []renamerConfig, logger logrus.FieldLogger) (*eventMetadataRenamerManager, error) {
 	relabelManager := eventMetadataRenamerManager{
 		renamerConfig: config,
-		outputChannel: make(chan *event.Raw),
+		outputChannel: make(chan event.Raw),
 		logger:        logger,
 	}
 	return &relabelManager, nil
 }
+
 type renamerConfig struct {
 	Source, Destination string
 }
@@ -49,8 +50,8 @@ type renamerConfig struct {
 type eventMetadataRenamerManager struct {
 	renamerConfig []renamerConfig
 	observer      pipeline.EventProcessingDurationObserver
-	inputChannel  chan *event.Raw
-	outputChannel chan *event.Raw
+	inputChannel  chan event.Raw
+	outputChannel chan event.Raw
 	done          bool
 	logger        logrus.FieldLogger
 }
@@ -67,11 +68,11 @@ func (r *eventMetadataRenamerManager) RegisterMetrics(_ prometheus.Registerer, w
 	return wrappedRegistry.Register(renamingCollisionsTotal)
 }
 
-func (r *eventMetadataRenamerManager) SetInputChannel(channel chan *event.Raw) {
+func (r *eventMetadataRenamerManager) SetInputChannel(channel chan event.Raw) {
 	r.inputChannel = channel
 }
 
-func (r *eventMetadataRenamerManager) OutputChannel() chan *event.Raw {
+func (r *eventMetadataRenamerManager) OutputChannel() chan event.Raw {
 	return r.outputChannel
 }
 
@@ -90,18 +91,18 @@ func (r *eventMetadataRenamerManager) observeDuration(start time.Time) {
 }
 
 // renameEventMetadata applies the relabel configs on the event metadata.
-func (r *eventMetadataRenamerManager) renameEventMetadata(e *event.Raw) *event.Raw {
+func (r *eventMetadataRenamerManager) renameEventMetadata(e event.Raw) event.Raw {
 	for _, renameConfig := range r.renamerConfig {
-		if _, ok := e.Metadata[renameConfig.Source]; !ok {
+		if _, ok := e.Metadata()[renameConfig.Source]; !ok {
 			continue
 		}
-		if _, ok := e.Metadata[renameConfig.Destination]; ok {
-			r.logger.Warnf("refusing to override metadata's %s:%s with %s:%s", renameConfig.Destination, e.Metadata[renameConfig.Destination], renameConfig.Source, e.Metadata[renameConfig.Source])
+		if _, ok := e.Metadata()[renameConfig.Destination]; ok {
+			r.logger.Warnf("refusing to override metadata's %s:%s with %s:%s", renameConfig.Destination, e.Metadata()[renameConfig.Destination], renameConfig.Source, e.Metadata()[renameConfig.Source])
 			renamingCollisionsTotal.WithLabelValues(renameConfig.Source, renameConfig.Destination).Inc()
 			continue
 		}
-		e.Metadata[renameConfig.Destination] = e.Metadata[renameConfig.Source]
-		delete(e.Metadata, renameConfig.Source)
+		e.Metadata().Set(renameConfig.Destination, e.Metadata().Get(renameConfig.Source, ""))
+		delete(e.Metadata(), renameConfig.Source)
 	}
 	return e
 }
diff --git a/pkg/event_metadata_renamer/renamer_test.go b/pkg/event_metadata_renamer/renamer_test.go
index cd4e4ef..c680a9c 100644
--- a/pkg/event_metadata_renamer/renamer_test.go
+++ b/pkg/event_metadata_renamer/renamer_test.go
@@ -12,30 +12,30 @@ import (
 
 type testCase struct {
 	name        string
-	inputEvent  *event.Raw
-	outputEvent *event.Raw
+	inputEvent  event.Raw
+	outputEvent event.Raw
 }
 
 var testCases = []testCase{
 	{
 		name:        "event with empty metadata",
-		inputEvent:  &event.Raw{Metadata: map[string]string{}},
-		outputEvent: &event.Raw{Metadata: map[string]string{}},
+		inputEvent:  event.NewRaw("xxx", 1, map[string]string{}, nil),
+		outputEvent: event.NewRaw("xxx", 1, map[string]string{}, nil),
 	},
 	{
 		name:        "attempt to rename key which is not present in the event's metadata",
-		inputEvent:  &event.Raw{Metadata: map[string]string{"sourceX": "bar"}},
-		outputEvent: &event.Raw{Metadata: map[string]string{"sourceX": "bar"}},
+		inputEvent:  event.NewRaw("xxx", 1, map[string]string{"sourceX": "bar"}, nil),
+		outputEvent: event.NewRaw("xxx", 1, map[string]string{"sourceX": "bar"}, nil),
 	},
 	{
 		name:        "Destination metadata key already exist (collision)",
-		inputEvent:  &event.Raw{Metadata: map[string]string{"destination": "destinationCollisionNotOverriden"}},
-		outputEvent:  &event.Raw{Metadata: map[string]string{"destination": "destinationCollisionNotOverriden"}},
+		inputEvent:  event.NewRaw("xxx", 1, map[string]string{"destination": "destinationCollisionNotOverriden"}, nil),
+		outputEvent: event.NewRaw("xxx", 1, map[string]string{"destination": "destinationCollisionNotOverriden"}, nil),
 	},
 	{
 		name:        "valid rename of metadata key",
-		inputEvent:  &event.Raw{Metadata: map[string]string{"source": "bar", "other": "xxx"}},
-		outputEvent: &event.Raw{Metadata: map[string]string{"destination": "bar", "other": "xxx"}},
+		inputEvent:  event.NewRaw("xxx", 1, map[string]string{"source": "bar", "other": "xxx"}, nil),
+		outputEvent: event.NewRaw("xxx", 1, map[string]string{"destination": "bar", "other": "xxx"}, nil),
 	},
 }
 
diff --git a/pkg/kafka_ingester/kafka_ingester.go b/pkg/kafka_ingester/kafka_ingester.go
index 5b6fa58..0bcc2d5 100644
--- a/pkg/kafka_ingester/kafka_ingester.go
+++ b/pkg/kafka_ingester/kafka_ingester.go
@@ -55,9 +55,10 @@ var (
 )
 
 type IngestedEventV1 struct {
+	Id                string                         `json:"id"`
 	Metadata          stringmap.StringMap            `json:"metadata"`
 	SloClassification *IngestedEventV1Classification `json:"slo_classification"`
-	Quantity          *float64                       `json:"quantity"`
+	Quantity          float64                        `json:"quantity"`
 }
 
 type IngestedEventV1Classification struct {
@@ -81,7 +82,7 @@ type kafkaIngesterConfig struct {
 type KafkaIngester struct {
 	kafkaReader     *kafka.Reader
 	observer        pipeline.EventProcessingDurationObserver
-	outputChannel   chan *event.Raw
+	outputChannel   chan event.Raw
 	shutdownChannel chan struct{}
 	logger          logrus.FieldLogger
 	done            bool
@@ -135,7 +136,7 @@ func New(config kafkaIngesterConfig, logger logrus.FieldLogger) (*KafkaIngester,
 	}).Set(1)
 
 	return &KafkaIngester{
-		outputChannel:   make(chan *event.Raw),
+		outputChannel:   make(chan event.Raw),
 		shutdownChannel: make(chan struct{}),
 		done:            false,
 		logger:          logger,
@@ -167,7 +168,7 @@ func (k *KafkaIngester) Done() bool {
 	return k.done
 }
 
-func (k *KafkaIngester) OutputChannel() chan *event.Raw {
+func (k *KafkaIngester) OutputChannel() chan event.Raw {
 	return k.outputChannel
 }
 
@@ -229,7 +230,7 @@ func getSchemaVersionFromHeaders(headers []kafka.Header) (schemaVer string, foun
 	return
 }
 
-func processMessage(m kafka.Message) (*event.Raw, error) {
+func processMessage(m kafka.Message) (event.Raw, error) {
 	schemaVer, ok := getSchemaVersionFromHeaders(m.Headers)
 	if !ok {
 		schemaVer = defaultSchemaVer
@@ -242,19 +243,12 @@ func processMessage(m kafka.Message) (*event.Raw, error) {
 	}
 }
 
-func processEventV1(m kafka.Message) (*event.Raw, error) {
-	ingestedEvent := IngestedEventV1{}
+func processEventV1(m kafka.Message) (event.Raw, error) {
+	ingestedEvent := IngestedEventV1{Quantity: 1}
 	err := json.Unmarshal(m.Value, &ingestedEvent)
 	if err != nil {
 		return nil, err
 	}
-	var quantity float64
-	if ingestedEvent.Quantity == nil {
-		// Quantity not specified in the ingested data, default to 1
-		quantity = 1
-	} else {
-		quantity = *ingestedEvent.Quantity
-	}
 	var classification *event.SloClassification
 	if ingestedEvent.SloClassification != nil {
 		classification = &event.SloClassification{
@@ -263,12 +257,7 @@ func processEventV1(m kafka.Message) (*event.Raw, error) {
 			Class:  ingestedEvent.SloClassification.Class,
 		}
 	}
-	outputEvent := event.Raw{
-		Metadata:          ingestedEvent.Metadata,
-		Quantity:          quantity,
-		SloClassification: classification,
-	}
-	return &outputEvent, nil
+	return event.NewRaw(ingestedEvent.Id, ingestedEvent.Quantity, ingestedEvent.Metadata, classification), nil
 }
 
 func (k *KafkaIngester) Stop() {
diff --git a/pkg/kafka_ingester/kafka_ingester_test.go b/pkg/kafka_ingester/kafka_ingester_test.go
index 571c73c..5a08eb7 100644
--- a/pkg/kafka_ingester/kafka_ingester_test.go
+++ b/pkg/kafka_ingester/kafka_ingester_test.go
@@ -11,11 +11,14 @@ import (
 	"github.com/seznam/slo-exporter/pkg/stringmap"
 )
 
+const defaultEventId = "xxx"
+
 func Test_processMessage(t *testing.T) {
 	tests := []struct {
 		Name         string
 		KafkaMessage kafka.Message
-		OutputEvent  *event.Raw
+		CheckIds     bool
+		OutputEvent  event.Raw
 		ErrExpected  bool
 	}{
 		{
@@ -24,7 +27,19 @@ func Test_processMessage(t *testing.T) {
 				Topic: "topic",
 				Value: []byte(`{}`),
 			},
-			OutputEvent: &event.Raw{Quantity: 1},
+			CheckIds:    false,
+			OutputEvent: event.NewRaw(defaultEventId, 1, stringmap.StringMap{}, nil),
+		},
+		{
+			Name: "Id set",
+			KafkaMessage: kafka.Message{
+				Topic: "topic",
+				Value: []byte(`{
+					"id": "foo"
+				}`)},
+			CheckIds:    true,
+			OutputEvent: event.NewRaw("foo", 1, stringmap.StringMap{}, nil),
+			ErrExpected: false,
 		},
 		{
 			Name: "Event without classification",
@@ -35,7 +50,8 @@ func Test_processMessage(t *testing.T) {
 					"metadata": {"foo": "bar"}
 				}`),
 			},
-			OutputEvent: &event.Raw{Quantity: 1, Metadata: stringmap.StringMap{"foo": "bar"}},
+			CheckIds:    false,
+			OutputEvent: event.NewRaw(defaultEventId, 1, stringmap.StringMap{"foo": "bar"}, nil),
 		},
 		{
 			Name: "Event with classification",
@@ -47,11 +63,8 @@ func Test_processMessage(t *testing.T) {
 					"slo_classification": {"app": "fooApp", "class": "fooClass", "domain": "fooDomain"}
 				}`),
 			},
-			OutputEvent: &event.Raw{
-				Quantity:          1,
-				Metadata:          stringmap.StringMap{"foo": "bar"},
-				SloClassification: &event.SloClassification{App: "fooApp", Class: "fooClass", Domain: "fooDomain"},
-			},
+			CheckIds:    false,
+			OutputEvent: event.NewRaw(defaultEventId, 1, stringmap.StringMap{"foo": "bar"}, &event.SloClassification{App: "fooApp", Class: "fooClass", Domain: "fooDomain"}),
 		},
 		{
 			Name: "Kafka message containing only unknown fields",
@@ -59,7 +72,8 @@ func Test_processMessage(t *testing.T) {
 				Topic: "topic",
 				Value: []byte(`{"unknown_field": 1111}`),
 			},
-			OutputEvent: &event.Raw{Quantity: 1},
+			CheckIds:    false,
+			OutputEvent: event.NewRaw(defaultEventId, 1, stringmap.StringMap{}, nil),
 		},
 		{
 			Name: "Valid event data accompanied with unknown fields",
@@ -71,11 +85,8 @@ func Test_processMessage(t *testing.T) {
 					"slo_classification": {"app": "fooApp", "class": "fooClass", "domain": "fooDomain"},
 					"unknown_fields": "foo"
 				}`)},
-			OutputEvent: &event.Raw{
-				Quantity:          1,
-				Metadata:          stringmap.StringMap{"foo": "bar"},
-				SloClassification: &event.SloClassification{App: "fooApp", Class: "fooClass", Domain: "fooDomain"},
-			},
+			CheckIds:    false,
+			OutputEvent: event.NewRaw(defaultEventId, 1, stringmap.StringMap{"foo": "bar"}, &event.SloClassification{App: "fooApp", Class: "fooClass", Domain: "fooDomain"}),
 		},
 		{
 			Name: "Valid event data, explicit schema version",
@@ -87,11 +98,8 @@ func Test_processMessage(t *testing.T) {
 					"metadata": {"foo": "bar"},
 					"slo_classification": {"app": "fooApp", "class": "fooClass", "domain": "fooDomain"}
 				}`)},
-			OutputEvent: &event.Raw{
-				Quantity:          1,
-				Metadata:          stringmap.StringMap{"foo": "bar"},
-				SloClassification: &event.SloClassification{App: "fooApp", Class: "fooClass", Domain: "fooDomain"},
-			},
+			CheckIds:    false,
+			OutputEvent: event.NewRaw(defaultEventId, 1, stringmap.StringMap{"foo": "bar"}, &event.SloClassification{App: "fooApp", Class: "fooClass", Domain: "fooDomain"}),
 		},
 		{
 			Name: "Valid event data, unknown schema version",
@@ -103,6 +111,7 @@ func Test_processMessage(t *testing.T) {
 					"metadata": {"foo": "bar"},
 					"slo_classification": {"app": "fooApp", "class": "fooClass", "domain": "fooDomain"}
 				}`)},
+			CheckIds:    false,
 			OutputEvent: nil,
 			ErrExpected: true,
 		},
@@ -114,6 +123,7 @@ func Test_processMessage(t *testing.T) {
 				Value: []byte(`{
 					"quantity": "1",
 				}`)},
+			CheckIds:    false,
 			OutputEvent: nil,
 			ErrExpected: true,
 		},
@@ -123,13 +133,14 @@ func Test_processMessage(t *testing.T) {
 				Headers: []kafka.Header{{schemaVersionMessageHeader, []byte("unknown")}},
 				Topic:   "topic",
 				Value:   []byte(`[{}]`)},
+			CheckIds:    false,
 			OutputEvent: nil,
 			ErrExpected: true,
 		},
 	}
 	for _, test := range tests {
 		t.Run(test.Name, func(t *testing.T) {
-			event, err := processMessage(test.KafkaMessage)
+			e, err := processMessage(test.KafkaMessage)
 			if err != nil {
 				if !test.ErrExpected {
 					t.Errorf("Unexpected error while processing kafka message: %w", err)
@@ -138,7 +149,7 @@ func Test_processMessage(t *testing.T) {
 			if test.ErrExpected && err == nil {
 				t.Errorf("Event processing was expected to result in error, but none occurred")
 			}
-			assert.Equal(t, test.OutputEvent, event)
+			event.AssertRawEventsEqual(t, test.OutputEvent, e, test.CheckIds)
 		})
 	}
 }
diff --git a/pkg/metadata_classifier/metadata_cassifier.go b/pkg/metadata_classifier/metadata_cassifier.go
index 5c770fa..5f2cc26 100644
--- a/pkg/metadata_classifier/metadata_cassifier.go
+++ b/pkg/metadata_classifier/metadata_cassifier.go
@@ -3,10 +3,10 @@ package metadata_classifier
 import (
 	"fmt"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/sirupsen/logrus"
-	"github.com/spf13/viper"
 	"github.com/seznam/slo-exporter/pkg/event"
 	"github.com/seznam/slo-exporter/pkg/pipeline"
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/viper"
 	"time"
 )
 
@@ -31,8 +31,8 @@ type metadataClassifier struct {
 	appKey                 string
 	observer               pipeline.EventProcessingDurationObserver
 	logger                 logrus.FieldLogger
-	inputChannel           chan *event.Raw
-	outputChannel          chan *event.Raw
+	inputChannel           chan event.Raw
+	outputChannel          chan event.Raw
 	done                   bool
 }
 
@@ -52,11 +52,11 @@ func (e *metadataClassifier) Stop() {
 	return
 }
 
-func (e *metadataClassifier) SetInputChannel(channel chan *event.Raw) {
+func (e *metadataClassifier) SetInputChannel(channel chan event.Raw) {
 	e.inputChannel = channel
 }
 
-func (e *metadataClassifier) OutputChannel() chan *event.Raw {
+func (e *metadataClassifier) OutputChannel() chan event.Raw {
 	return e.outputChannel
 }
 
@@ -75,8 +75,8 @@ func NewFromConfig(config metadataClassifierConfig, logger logrus.FieldLogger) (
 		domainKey:              config.SloDomainMetadataKey,
 		classKey:               config.SloClassMetadataKey,
 		appKey:                 config.SloAppMetadataKey,
-		outputChannel:          make(chan *event.Raw),
-		inputChannel:           make(chan *event.Raw),
+		outputChannel:          make(chan event.Raw),
+		inputChannel:           make(chan event.Raw),
 		done:                   false,
 		logger:                 logger,
 	}
@@ -93,22 +93,21 @@ func (e *metadataClassifier) observeDuration(start time.Time) {
 	}
 }
 
-func (e *metadataClassifier) generateSloClassification(toBeClassified *event.Raw) event.SloClassification {
+func (e *metadataClassifier) generateSloClassification(toBeClassified event.Raw) event.SloClassification {
 	newClassification := event.SloClassification{}
-	if toBeClassified.SloClassification != nil {
-		newClassification.Domain = toBeClassified.SloClassification.Domain
-		newClassification.Class = toBeClassified.SloClassification.Class
-		newClassification.App = toBeClassified.SloClassification.App
+	if toBeClassified.IsClassified() {
+		classification := toBeClassified.SloClassification()
+		newClassification = classification.Copy()
 	}
-	metadataDomain, ok := toBeClassified.Metadata[e.domainKey]
+	metadataDomain, ok := toBeClassified.Metadata()[e.domainKey]
 	if ok && (e.overrideExistingValues || newClassification.Domain == "") {
 		newClassification.Domain = metadataDomain
 	}
-	metadataClass, ok := toBeClassified.Metadata[e.classKey]
+	metadataClass, ok := toBeClassified.Metadata()[e.classKey]
 	if ok && (e.overrideExistingValues || newClassification.Class == "") {
 		newClassification.Class = metadataClass
 	}
-	metadataApp, ok := toBeClassified.Metadata[e.appKey]
+	metadataApp, ok := toBeClassified.Metadata()[e.appKey]
 	if ok && (e.overrideExistingValues || newClassification.App == "") {
 		newClassification.App = metadataApp
 	}
@@ -127,7 +126,7 @@ func (e *metadataClassifier) Run() {
 				processedEventsTotal.WithLabelValues("skipped").Inc()
 			} else {
 				newClassification := e.generateSloClassification(newEvent)
-				newEvent.SloClassification = &newClassification
+				newEvent.SetSLOClassification(newClassification)
 				processedEventsTotal.WithLabelValues("generated-slo-classification").Inc()
 				e.logger.WithField("event", newEvent).WithField("slo-classification", newClassification).Debug("classified new event")
 			}
diff --git a/pkg/metadata_classifier/metadata_cassifier_test.go b/pkg/metadata_classifier/metadata_cassifier_test.go
index 4bbb275..ec5b55e 100644
--- a/pkg/metadata_classifier/metadata_cassifier_test.go
+++ b/pkg/metadata_classifier/metadata_cassifier_test.go
@@ -1,10 +1,10 @@
 package metadata_classifier
 
 import (
-	"github.com/sirupsen/logrus"
-	"github.com/stretchr/testify/assert"
 	"github.com/seznam/slo-exporter/pkg/event"
 	"github.com/seznam/slo-exporter/pkg/stringmap"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
 	"testing"
 )
 
@@ -16,38 +16,26 @@ func TestMetadataClassifier_generateSloClassification(t *testing.T) {
 		result event.SloClassification
 	}{
 		{
-			name: "non classified event with expected metadata is classified as expected",
-			event: event.Raw{
-				Metadata:          stringmap.StringMap{"domain": "domain", "class": "class", "app": "app"},
-				SloClassification: &event.SloClassification{Domain: "", Class: "", App: ""},
-			},
+			name:   "non classified event with expected metadata is classified as expected",
+			event:  event.NewRaw("", 1, stringmap.StringMap{"domain": "domain", "class": "class", "app": "app"}, &event.SloClassification{Domain: "", Class: "", App: ""}),
 			config: metadataClassifierConfig{SloDomainMetadataKey: "domain", SloClassMetadataKey: "class", SloAppMetadataKey: "app", OverrideExistingValues: true},
 			result: event.SloClassification{Domain: "domain", Class: "class", App: "app"},
 		},
 		{
-			name: "with overwrite enabled, metadata classification has precedence over former event classification",
-			event: event.Raw{
-				Metadata:          stringmap.StringMap{"domain": "domain", "class": "class", "app": "app"},
-				SloClassification: &event.SloClassification{Domain: "xxx", Class: "xxx", App: "xxx"},
-			},
+			name:   "with overwrite enabled, metadata classification has precedence over former event classification",
+			event:  event.NewRaw("", 1, stringmap.StringMap{"domain": "domain", "class": "class", "app": "app"}, &event.SloClassification{Domain: "xxx", Class: "xxx", App: "xxx"}),
 			config: metadataClassifierConfig{SloDomainMetadataKey: "domain", SloClassMetadataKey: "class", SloAppMetadataKey: "app", OverrideExistingValues: true},
 			result: event.SloClassification{Domain: "domain", Class: "class", App: "app"},
 		},
 		{
-			name: "with overwrite disabled, former event classification has precedence over metadata classification",
-			event: event.Raw{
-				Metadata:          stringmap.StringMap{"domain": "domain", "class": "class", "app": "app"},
-				SloClassification: &event.SloClassification{Domain: "xxx", Class: "xxx", App: "xxx"},
-			},
+			name:   "with overwrite disabled, former event classification has precedence over metadata classification",
+			event:  event.NewRaw("", 1, stringmap.StringMap{"domain": "domain", "class": "class", "app": "app"}, &event.SloClassification{Domain: "xxx", Class: "xxx", App: "xxx"}),
 			config: metadataClassifierConfig{SloDomainMetadataKey: "domain", SloClassMetadataKey: "class", SloAppMetadataKey: "app", OverrideExistingValues: false},
 			result: event.SloClassification{Domain: "xxx", Class: "xxx", App: "xxx"},
 		},
 		{
-			name: "if specified key is not found in metadata, original value of classification is left intact",
-			event: event.Raw{
-				Metadata:          stringmap.StringMap{"domain": "domain", "class": "class"},
-				SloClassification: &event.SloClassification{Domain: "xxx", Class: "xxx", App: "xxx"},
-			},
+			name:   "if specified key is not found in metadata, original value of classification is left intact",
+			event:  event.NewRaw("", 1, stringmap.StringMap{"domain": "domain", "class": "class"}, &event.SloClassification{Domain: "xxx", Class: "xxx", App: "xxx"}),
 			config: metadataClassifierConfig{SloDomainMetadataKey: "domain", SloClassMetadataKey: "class", SloAppMetadataKey: "app", OverrideExistingValues: true},
 			result: event.SloClassification{Domain: "domain", Class: "class", App: "xxx"},
 		},
@@ -56,7 +44,7 @@ func TestMetadataClassifier_generateSloClassification(t *testing.T) {
 		t.Run(tc.name, func(t *testing.T) {
 			generator, err := NewFromConfig(tc.config, logrus.New())
 			assert.NoError(t, err)
-			assert.Equal(t, tc.result, generator.generateSloClassification(&tc.event))
+			assert.Equal(t, tc.result, generator.generateSloClassification(tc.event))
 		})
 	}
 }
diff --git a/pkg/pipeline/manager_test.go b/pkg/pipeline/manager_test.go
index 9afbc1a..e37359d 100644
--- a/pkg/pipeline/manager_test.go
+++ b/pkg/pipeline/manager_test.go
@@ -37,8 +37,8 @@ func (t *testModule) Done() bool {
 	return t.done
 }
 
-func (t *testModule) OutputChannel() chan *event.Raw {
-	return make(chan *event.Raw)
+func (t *testModule) OutputChannel() chan event.Raw {
+	return make(chan event.Raw)
 }
 
 func newEmptyManager() (*Manager, error) {
diff --git a/pkg/pipeline/module.go b/pkg/pipeline/module.go
index b197f9f..0a48490 100644
--- a/pkg/pipeline/module.go
+++ b/pkg/pipeline/module.go
@@ -37,7 +37,7 @@ type WebInterfaceModule interface {
 }
 
 type RawEventIngester interface {
-	SetInputChannel(chan *event.Raw)
+	SetInputChannel(chan event.Raw)
 }
 
 type RawEventIngesterModule interface {
@@ -46,7 +46,7 @@ type RawEventIngesterModule interface {
 }
 
 type RawEventProducer interface {
-	OutputChannel() chan *event.Raw
+	OutputChannel() chan event.Raw
 }
 
 type RawEventProducerModule interface {
@@ -55,7 +55,7 @@ type RawEventProducerModule interface {
 }
 
 type SloEventIngester interface {
-	SetInputChannel(chan *event.Slo)
+	SetInputChannel(chan event.Slo)
 }
 
 type SloEventIngesterModule interface {
@@ -64,7 +64,7 @@ type SloEventIngesterModule interface {
 }
 
 type SloEventProducer interface {
-	OutputChannel() chan *event.Slo
+	OutputChannel() chan event.Slo
 }
 
 type SloEventProducerModule interface {
diff --git a/pkg/pipeline/module_test.go b/pkg/pipeline/module_test.go
index b749317..1bcdc4a 100644
--- a/pkg/pipeline/module_test.go
+++ b/pkg/pipeline/module_test.go
@@ -2,9 +2,9 @@ package pipeline
 
 import (
 	"fmt"
+	"github.com/seznam/slo-exporter/pkg/event"
 	"github.com/sirupsen/logrus"
 	"github.com/spf13/viper"
-	"github.com/seznam/slo-exporter/pkg/event"
 )
 
 func testModuleFactory(moduleName string, logger logrus.FieldLogger, conf *viper.Viper) (Module, error) {
@@ -36,7 +36,7 @@ func (t testRawIngester) Done() bool {
 	return false
 }
 
-func (t testRawIngester) SetInputChannel(chan *event.Raw) {
+func (t testRawIngester) SetInputChannel(chan event.Raw) {
 	return
 }
 
@@ -54,8 +54,8 @@ func (t testRawProducer) Done() bool {
 	return false
 }
 
-func (t testRawProducer) OutputChannel() chan *event.Raw {
-	return make(chan *event.Raw)
+func (t testRawProducer) OutputChannel() chan event.Raw {
+	return make(chan event.Raw)
 }
 
 type testSloIngester struct{}
diff --git a/pkg/prometheus_exporter/prometheus_exporter.go b/pkg/prometheus_exporter/prometheus_exporter.go
index 5ee8c69..ab366f4 100644
--- a/pkg/prometheus_exporter/prometheus_exporter.go
+++ b/pkg/prometheus_exporter/prometheus_exporter.go
@@ -3,11 +3,11 @@ package prometheus_exporter
 import (
 	"fmt"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/sirupsen/logrus"
-	"github.com/spf13/viper"
 	"github.com/seznam/slo-exporter/pkg/event"
 	"github.com/seznam/slo-exporter/pkg/pipeline"
 	"github.com/seznam/slo-exporter/pkg/stringmap"
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/viper"
 	"time"
 )
 
@@ -64,7 +64,7 @@ type PrometheusSloEventExporter struct {
 	eventKeyCache               map[string]int
 	observer                    pipeline.EventProcessingDurationObserver
 
-	inputChannel chan *event.Slo
+	inputChannel chan event.Slo
 	done         bool
 	logger       logrus.FieldLogger
 }
@@ -139,7 +139,7 @@ func (e *PrometheusSloEventExporter) Done() bool {
 	return e.done
 }
 
-func (e *PrometheusSloEventExporter) SetInputChannel(channel chan *event.Slo) {
+func (e *PrometheusSloEventExporter) SetInputChannel(channel chan event.Slo) {
 	e.inputChannel = channel
 }
 
@@ -208,32 +208,32 @@ func (e *PrometheusSloEventExporter) initializeMetricForGivenMetadata(metadata s
 	}
 }
 
-func (e *PrometheusSloEventExporter) labelsFromEvent(sloEvent *event.Slo) stringmap.StringMap {
+func (e *PrometheusSloEventExporter) labelsFromEvent(sloEvent event.Slo) stringmap.StringMap {
 	return stringmap.StringMap{
-		e.labelNames.Result:    string(sloEvent.Result),
-		e.labelNames.SloDomain: sloEvent.Domain,
-		e.labelNames.SloClass:  sloEvent.Class,
-		e.labelNames.SloApp:    sloEvent.App,
-		e.labelNames.EventKey:  sloEvent.Key,
-	}.Merge(sloEvent.Metadata)
+		e.labelNames.Result:    string(sloEvent.Result()),
+		e.labelNames.SloDomain: sloEvent.SloClassification().Domain,
+		e.labelNames.SloClass:  sloEvent.SloClassification().Class,
+		e.labelNames.SloApp:    sloEvent.SloClassification().App,
+		e.labelNames.EventKey:  sloEvent.EventKey(),
+	}.Merge(sloEvent.Metadata())
 }
 
-func (e *PrometheusSloEventExporter) processEvent(newEvent *event.Slo) error {
-	if !e.isValidResult(newEvent.Result) {
-		return &InvalidSloEventResult{string(newEvent.Result), event.PossibleResults}
+func (e *PrometheusSloEventExporter) processEvent(newEvent event.Slo) error {
+	if !e.isValidResult(newEvent.Result()) {
+		return &InvalidSloEventResult{string(newEvent.Result()), event.PossibleResults}
 	}
 
 	labels := e.labelsFromEvent(newEvent)
 
-	if e.isCardinalityExceeded(newEvent.Key) {
-		e.logger.Warnf("event key '%s' exceeded limit '%d', masked as '%s'", newEvent.Key, e.eventKeyLimit, e.exceededKeyLimitPlaceholder)
+	if e.isCardinalityExceeded(newEvent.EventKey()) {
+		e.logger.Warnf("event key '%s' exceeded limit '%d', masked as '%s'", newEvent.EventKey(), e.eventKeyLimit, e.exceededKeyLimitPlaceholder)
 		labels[e.labelNames.EventKey] = e.exceededKeyLimitPlaceholder
 	}
 
 	e.initializeMetricForGivenMetadata(labels)
 
 	// add result to metadata
-	labels[e.labelNames.Result] = string(newEvent.Result)
-	e.aggregatedMetricsSet.add(newEvent.Quantity, labels)
+	labels[e.labelNames.Result] = string(newEvent.Result())
+	e.aggregatedMetricsSet.add(newEvent.Quantity(), labels)
 	return nil
 }
diff --git a/pkg/prometheus_exporter/prometheus_exporter_test.go b/pkg/prometheus_exporter/prometheus_exporter_test.go
index b8335bc..7dbb0f3 100644
--- a/pkg/prometheus_exporter/prometheus_exporter_test.go
+++ b/pkg/prometheus_exporter/prometheus_exporter_test.go
@@ -25,7 +25,7 @@ var conf = prometheusExporterConfig{
 }
 
 type testProcessEvent struct {
-	ev              *event.Slo
+	ev              event.Slo
 	expectedMetrics string
 }
 
@@ -38,26 +38,14 @@ func Test_PrometheusSloEventExporter_processEvent(t *testing.T) {
 
 	testCases := []testProcessEvent{
 		{
-			ev: &event.Slo{
-				Metadata: stringmap.StringMap{"a": "a1", "b": "b1"},
-				Key:      "foo",
-				Domain:   "domain",
-				Result:   event.Fail,
-				Quantity: 1,
-			},
+			ev: event.NewSlo("foo", 1, event.Fail, event.SloClassification{Domain: "domain"}, stringmap.StringMap{"a": "a1", "b": "b1"}),
 			expectedMetrics: metricMetadata + fmt.Sprintf(`
 				%[1]s{ a = "a1" , b = "b1", %[2]s = "foo", %[3]s ="fail", %[4]s = "", %[5]s = "", %[6]s = "domain"} 1
 				%[1]s{ a = "a1" , b = "b1", %[2]s = "foo", %[3]s ="success", %[4]s = "", %[5]s = "", %[6]s = "domain"} 0
 				`, testedMetricName, conf.LabelNames.EventKey, conf.LabelNames.Result, conf.LabelNames.SloApp, conf.LabelNames.SloClass, conf.LabelNames.SloDomain),
 		},
 		{
-			ev: &event.Slo{
-				Metadata: stringmap.StringMap{"a": "a1", "b": "b1"},
-				Key:      "foo",
-				Domain:   "domain",
-				Result:   event.Success,
-				Quantity: 1,
-			},
+			ev: event.NewSlo("foo", 1, event.Success, event.SloClassification{Domain: "domain"}, stringmap.StringMap{"a": "a1", "b": "b1"}),
 			expectedMetrics: metricMetadata + fmt.Sprintf(`
 				%[1]s{ a = "a1" , b = "b1", %[2]s = "foo", %[3]s ="success", %[4]s = "", %[5]s = "", %[6]s = "domain"} 1
 				%[1]s{ a = "a1" , b = "b1", %[2]s = "foo", %[3]s ="fail", %[4]s = "", %[5]s = "", %[6]s = "domain"} 0
diff --git a/pkg/prometheus_ingester/prometheus_ingester.go b/pkg/prometheus_ingester/prometheus_ingester.go
index 72d2cde..20effe6 100644
--- a/pkg/prometheus_ingester/prometheus_ingester.go
+++ b/pkg/prometheus_ingester/prometheus_ingester.go
@@ -12,10 +12,10 @@ import (
 	v1 "github.com/prometheus/client_golang/api/prometheus/v1"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/common/model"
-	"github.com/sirupsen/logrus"
-	"github.com/spf13/viper"
 	"github.com/seznam/slo-exporter/pkg/event"
 	"github.com/seznam/slo-exporter/pkg/stringmap"
+	"github.com/sirupsen/logrus"
+	"github.com/spf13/viper"
 )
 
 const (
@@ -86,7 +86,7 @@ type PrometheusIngester struct {
 	client          api.Client
 	api             v1.API
 	shutdownChannel chan struct{}
-	outputChannel   chan *event.Raw
+	outputChannel   chan event.Raw
 	logger          logrus.FieldLogger
 	done            bool
 }
@@ -113,7 +113,7 @@ func (i *PrometheusIngester) Done() bool {
 	return i.done
 }
 
-func (i *PrometheusIngester) OutputChannel() chan *event.Raw {
+func (i *PrometheusIngester) OutputChannel() chan event.Raw {
 	return i.outputChannel
 }
 
@@ -160,7 +160,7 @@ func New(initConfig PrometheusIngesterConfig, logger logrus.FieldLogger) (*Prome
 		queryTimeout:    initConfig.QueryTimeout,
 		client:          client,
 		api:             v1.NewAPI(client),
-		outputChannel:   make(chan *event.Raw),
+		outputChannel:   make(chan event.Raw),
 		done:            false,
 		shutdownChannel: make(chan struct{}),
 		logger:          logger,
diff --git a/pkg/prometheus_ingester/prometheus_ingester_test.go b/pkg/prometheus_ingester/prometheus_ingester_test.go
index 58d832a..2936219 100644
--- a/pkg/prometheus_ingester/prometheus_ingester_test.go
+++ b/pkg/prometheus_ingester/prometheus_ingester_test.go
@@ -12,10 +12,10 @@ import (
 	"time"
 
 	"github.com/prometheus/common/model"
-	"github.com/sirupsen/logrus"
-	"github.com/stretchr/testify/assert"
 	"github.com/seznam/slo-exporter/pkg/event"
 	"github.com/seznam/slo-exporter/pkg/stringmap"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
 )
 
 type MockedRoundTripper struct {
@@ -71,10 +71,10 @@ func newMetric(name model.LabelValue, labels map[string]string) model.Metric {
 	return m
 }
 
-func HttpRequestsToString(rawResults []*event.Raw) []string {
+func HttpRequestsToString(rawResults []event.Raw) []string {
 	stringResults := make([]string, len(rawResults))
 	for i, rawResult := range rawResults {
-		marshalledBytes, err := json.Marshal(*rawResult)
+		marshalledBytes, err := json.Marshal(rawResult)
 		if err != nil {
 			marshalledBytes = []byte{}
 		}
@@ -86,7 +86,7 @@ func HttpRequestsToString(rawResults []*event.Raw) []string {
 type modelTypeIngestTestCase struct {
 	prometheusResult model.Value
 	query            queryOptions
-	eventsProduced   []*event.Raw
+	eventsProduced   []event.Raw
 }
 
 func Test_Ingests_Various_ModelTypes(t *testing.T) {
@@ -126,23 +126,11 @@ func Test_Ingests_Various_ModelTypes(t *testing.T) {
 				Type:             simpleQueryType,
 				ResultAsQuantity: newFalse(),
 			},
-			eventsProduced: []*event.Raw{
-				{
-					Metadata: metricStringMap.Merge(stringmap.StringMap{metadataValueKey: "1", metadataTimestampKey: "0"}),
-					Quantity: 1,
-				},
-				{
-					Metadata: metricStringMap.Merge(stringmap.StringMap{metadataValueKey: "2", metadataTimestampKey: "0"}),
-					Quantity: 1,
-				},
-				{
-					Metadata: metricStringMap.Merge(stringmap.StringMap{metadataValueKey: "3", metadataTimestampKey: "0"}),
-					Quantity: 1,
-				},
-				{
-					Metadata: metricStringMap.Merge(stringmap.StringMap{metadataValueKey: "4", metadataTimestampKey: "0"}),
-					Quantity: 1,
-				},
+			eventsProduced: []event.Raw{
+				event.NewRaw("", 1, metricStringMap.Merge(stringmap.StringMap{metadataValueKey: "1", metadataTimestampKey: "0"}), nil),
+				event.NewRaw("", 1, metricStringMap.Merge(stringmap.StringMap{metadataValueKey: "2", metadataTimestampKey: "0"}), nil),
+				event.NewRaw("", 1, metricStringMap.Merge(stringmap.StringMap{metadataValueKey: "3", metadataTimestampKey: "0"}), nil),
+				event.NewRaw("", 1, metricStringMap.Merge(stringmap.StringMap{metadataValueKey: "4", metadataTimestampKey: "0"}), nil),
 			},
 		},
 		{
@@ -162,15 +150,9 @@ func Test_Ingests_Various_ModelTypes(t *testing.T) {
 			query: queryOptions{
 				Type:             simpleQueryType,
 				ResultAsQuantity: newFalse(),
-			}, eventsProduced: []*event.Raw{
-				{
-					Metadata: metricStringMap.Merge(stringmap.StringMap{metadataValueKey: "1", metadataTimestampKey: "0"}),
-					Quantity: 1,
-				},
-				{
-					Metadata: metricStringMap.Merge(stringmap.StringMap{metadataValueKey: "2", metadataTimestampKey: "0"}),
-					Quantity: 1,
-				},
+			}, eventsProduced: []event.Raw{
+				event.NewRaw("", 1, metricStringMap.Merge(stringmap.StringMap{metadataValueKey: "1", metadataTimestampKey: "0"}), nil),
+				event.NewRaw("", 1, metricStringMap.Merge(stringmap.StringMap{metadataValueKey: "2", metadataTimestampKey: "0"}), nil),
 			},
 		},
 		{
@@ -182,11 +164,8 @@ func Test_Ingests_Various_ModelTypes(t *testing.T) {
 			query: queryOptions{
 				Type:             simpleQueryType,
 				ResultAsQuantity: newFalse(),
-			}, eventsProduced: []*event.Raw{
-				{
-					Metadata: stringmap.NewFromMetric(make(model.Metric)).Merge(stringmap.StringMap{metadataValueKey: "1", metadataTimestampKey: "0"}),
-					Quantity: 1,
-				},
+			}, eventsProduced: []event.Raw{
+				event.NewRaw("", 1, stringmap.NewFromMetric(make(model.Metric)).Merge(stringmap.StringMap{metadataValueKey: "1", metadataTimestampKey: "0"}), nil),
 			},
 		},
 	}
@@ -194,27 +173,29 @@ func Test_Ingests_Various_ModelTypes(t *testing.T) {
 	for _, tc := range testCases {
 		q := queryExecutor{
 			Query:      tc.query,
-			eventsChan: make(chan *event.Raw),
+			eventsChan: make(chan event.Raw),
 		}
 		go func() {
 			err := q.ProcessResult(tc.prometheusResult, time.Now())
 			assert.NoError(t, err)
 			close(q.eventsChan)
 		}()
-		var actualEventResult []*event.Raw
+		var actualEventResult []event.Raw
 		for newEvent := range q.eventsChan {
 			actualEventResult = append(actualEventResult, newEvent)
 		}
 
-		// Prepare the string interpretation of the actual results
-		assert.ElementsMatchf(t, tc.eventsProduced, actualEventResult, "Produced events doesnt match expected events", "actual", HttpRequestsToString(actualEventResult))
+		assert.Equal(t, len(tc.eventsProduced), len(actualEventResult))
+		for i, e := range tc.eventsProduced {
+			event.AssertRawEventsEqual(t, e, actualEventResult[i], false)
+		}
 	}
 }
 
 type labelAddOrDropTestCase struct {
 	prometheusResult model.Value
 	query            queryOptions
-	eventsProduced   []*event.Raw
+	eventsProduced   []event.Raw
 }
 
 func Test_Add_Or_Drop_Labels(t *testing.T) {
@@ -234,11 +215,8 @@ func Test_Add_Or_Drop_Labels(t *testing.T) {
 					Value:     model.SampleValue(1),
 				},
 			},
-			eventsProduced: []*event.Raw{
-				{
-					Metadata: m.Merge(stringmap.StringMap{"a": "1", "job": "kubernetes", "locality": "nagano", "__name__": "test_metric", metadataValueKey: "1", metadataTimestampKey: "0"}),
-					Quantity: 1,
-				},
+			eventsProduced: []event.Raw{
+				event.NewRaw("", 1, m.Merge(stringmap.StringMap{"a": "1", "job": "kubernetes", "locality": "nagano", "__name__": "test_metric", metadataValueKey: "1", metadataTimestampKey: "0"}), nil),
 			},
 		},
 		{
@@ -255,11 +233,8 @@ func Test_Add_Or_Drop_Labels(t *testing.T) {
 					Value:     model.SampleValue(1),
 				},
 			},
-			eventsProduced: []*event.Raw{
-				{
-					Metadata: m.Merge(stringmap.StringMap{"job": "kubernetes", "locality": "osaka", "__name__": "test_metric", metadataValueKey: "1", metadataTimestampKey: "0"}),
-					Quantity: 1,
-				},
+			eventsProduced: []event.Raw{
+				event.NewRaw("", 1, m.Merge(stringmap.StringMap{"job": "kubernetes", "locality": "osaka", "__name__": "test_metric", metadataValueKey: "1", metadataTimestampKey: "0"}), nil),
 			},
 		},
 		{
@@ -276,11 +251,8 @@ func Test_Add_Or_Drop_Labels(t *testing.T) {
 					Value:     model.SampleValue(1),
 				},
 			},
-			eventsProduced: []*event.Raw{
-				{
-					Metadata: m.Merge(stringmap.StringMap{"locality": "nagano", "__name__": "test_metric", metadataValueKey: "1", metadataTimestampKey: "0"}),
-					Quantity: 1,
-				},
+			eventsProduced: []event.Raw{
+				event.NewRaw("", 1, m.Merge(stringmap.StringMap{"locality": "nagano", "__name__": "test_metric", metadataValueKey: "1", metadataTimestampKey: "0"}), nil),
 			},
 		},
 		{
@@ -297,11 +269,8 @@ func Test_Add_Or_Drop_Labels(t *testing.T) {
 					Value:     model.SampleValue(1),
 				},
 			},
-			eventsProduced: []*event.Raw{
-				{
-					Metadata: m.Merge(stringmap.StringMap{"job": "kubernetes", "locality": "nagano", "__name__": "test_metric", metadataValueKey: "1", metadataTimestampKey: "0"}),
-					Quantity: 1,
-				},
+			eventsProduced: []event.Raw{
+				event.NewRaw("", 1, m.Merge(stringmap.StringMap{"job": "kubernetes", "locality": "nagano", "__name__": "test_metric", metadataValueKey: "1", metadataTimestampKey: "0"}), nil),
 			},
 		},
 		{
@@ -321,11 +290,8 @@ func Test_Add_Or_Drop_Labels(t *testing.T) {
 					Value:     model.SampleValue(1),
 				},
 			},
-			eventsProduced: []*event.Raw{
-				{
-					Metadata: m.Merge(stringmap.StringMap{"job": "openshift", "locality": "nagano", "__name__": "test_metric", metadataValueKey: "1", metadataTimestampKey: "0"}),
-					Quantity: 1,
-				},
+			eventsProduced: []event.Raw{
+				event.NewRaw("", 1, m.Merge(stringmap.StringMap{"job": "openshift", "locality": "nagano", "__name__": "test_metric", metadataValueKey: "1", metadataTimestampKey: "0"}), nil),
 			},
 		},
 	}
@@ -333,7 +299,7 @@ func Test_Add_Or_Drop_Labels(t *testing.T) {
 	for _, tc := range testCases {
 		q := queryExecutor{
 			Query:      tc.query,
-			eventsChan: make(chan *event.Raw),
+			eventsChan: make(chan event.Raw),
 		}
 		go func() {
 			err := q.ProcessResult(tc.prometheusResult, time.Now())
@@ -341,12 +307,15 @@ func Test_Add_Or_Drop_Labels(t *testing.T) {
 			close(q.eventsChan)
 		}()
 
-		var actualEventResult []*event.Raw
+		var actualEventResult []event.Raw
 		for newEvent := range q.eventsChan {
 			actualEventResult = append(actualEventResult, newEvent)
 		}
-		// Prepare the string interpretation of the actual results
-		assert.ElementsMatchf(t, tc.eventsProduced, actualEventResult, "Produced events doesnt match expected events", "actual", HttpRequestsToString(actualEventResult))
+
+		assert.Equal(t, len(tc.eventsProduced), len(actualEventResult))
+		for i, e := range tc.eventsProduced {
+			event.AssertRawEventsEqual(t, e, actualEventResult[i], false)
+		}
 	}
 }
 
@@ -382,7 +351,7 @@ func TestIngesterScalar_Interval_run(t *testing.T) {
 		return
 	}
 
-	var genEvents []*event.Raw
+	var genEvents []event.Raw
 	done := make(chan struct{})
 	go func() {
 		for e := range ingester.outputChannel {
@@ -482,7 +451,7 @@ func Test_processMetricsIncrease(t *testing.T) {
 		q              *queryExecutor
 		ts             time.Time
 		result         []*model.SampleStream // == type Matrix
-		expectedEvents []*event.Raw
+		expectedEvents []event.Raw
 	}
 
 	x := newMetric("x", nil)
@@ -524,11 +493,8 @@ func Test_processMetricsIncrease(t *testing.T) {
 					},
 				},
 			},
-			expectedEvents: []*event.Raw{
-				{
-					Metadata: stringmap.NewFromMetric(x).Merge(stringmap.StringMap{metadataValueKey: "10", metadataTimestampKey: fmt.Sprintf("%d", ts.Unix())}),
-					Quantity: 10,
-				},
+			expectedEvents: []event.Raw{
+				event.NewRaw("", 10, stringmap.NewFromMetric(x).Merge(stringmap.StringMap{metadataValueKey: "10", metadataTimestampKey: fmt.Sprintf("%d", ts.Unix())}), nil),
 			},
 		},
 		// value with reset on x, monotonic value for y
@@ -567,23 +533,17 @@ func Test_processMetricsIncrease(t *testing.T) {
 					},
 				},
 			},
-			expectedEvents: []*event.Raw{
-				{
-					Metadata: stringmap.NewFromMetric(x).Merge(stringmap.StringMap{metadataValueKey: "10", metadataTimestampKey: fmt.Sprintf("%d", ts.Unix())}),
-					Quantity: 10,
-				},
-				{
-					Metadata: stringmap.NewFromMetric(y).Merge(stringmap.StringMap{metadataValueKey: "1", metadataTimestampKey: fmt.Sprintf("%d", ts.Unix())}),
-					Quantity: 1,
-				},
+			expectedEvents: []event.Raw{
+				event.NewRaw("", 10, stringmap.NewFromMetric(x).Merge(stringmap.StringMap{metadataValueKey: "10", metadataTimestampKey: fmt.Sprintf("%d", ts.Unix())}), nil),
+				event.NewRaw("", 1, stringmap.NewFromMetric(y).Merge(stringmap.StringMap{metadataValueKey: "1", metadataTimestampKey: fmt.Sprintf("%d", ts.Unix())}), nil),
 			},
 		},
 	}
 
 	for _, testCase := range testCases {
-		testCase.q.eventsChan = make(chan *event.Raw)
+		testCase.q.eventsChan = make(chan event.Raw)
 
-		var generatedEvents []*event.Raw
+		var generatedEvents []event.Raw
 		done := make(chan struct{})
 		go func() {
 			for e := range testCase.q.eventsChan {
@@ -595,7 +555,10 @@ func Test_processMetricsIncrease(t *testing.T) {
 		close(testCase.q.eventsChan)
 		<-done
 
-		assert.ElementsMatchf(t, testCase.expectedEvents, generatedEvents, "expected events:\n%s\n\nresult:\n%s", testCase.expectedEvents, generatedEvents)
+		assert.Equal(t, len(testCase.expectedEvents), len(generatedEvents))
+		for i, e := range testCase.expectedEvents {
+			event.AssertRawEventsEqual(t, e, generatedEvents[i], false)
+		}
 	}
 }
 
@@ -614,7 +577,7 @@ func Test_processHistogramIncrease(t *testing.T) {
 	type testCase struct {
 		ts             time.Time
 		data           []*model.SampleStream // == type Matrix
-		expectedEvents []*event.Raw
+		expectedEvents []event.Raw
 	}
 	ts := time.Now()
 	tsStr := strconv.Itoa(int(ts.Unix()))
@@ -649,19 +612,19 @@ func Test_processHistogramIncrease(t *testing.T) {
 					Values: []model.SamplePair{{Timestamp: 10, Value: model.SampleValue(10)}},
 				},
 			},
-			expectedEvents: []*event.Raw{
-				{Metadata: stringmap.StringMap{"__name__": "histogram_bucket", "foo": "bar", "le": "1", metadataTimestampKey: tsStr, metadataHistogramMinValue: "-Inf", metadataHistogramMaxValue: "1", metadataValueKey: "2"}, Quantity: 2},
-				{Metadata: stringmap.StringMap{"__name__": "histogram_bucket", "foo": "bar", "le": "3", metadataTimestampKey: tsStr, metadataHistogramMinValue: "1", metadataHistogramMaxValue: "3", metadataValueKey: "6"}, Quantity: 6},
-				{Metadata: stringmap.StringMap{"__name__": "histogram_bucket", "foo": "bar", "le": "+Inf", metadataTimestampKey: tsStr, metadataHistogramMinValue: "6", metadataHistogramMaxValue: "+Inf", metadataValueKey: "2"}, Quantity: 2},
-				{Metadata: stringmap.StringMap{"__name__": "histogram_bucket", "foo": "xxx", "le": "0.5", metadataTimestampKey: tsStr, metadataHistogramMinValue: "-Inf", metadataHistogramMaxValue: "0.5", metadataValueKey: "2"}, Quantity: 2},
-				{Metadata: stringmap.StringMap{"__name__": "histogram_bucket", "foo": "xxx", "le": "+Inf", metadataTimestampKey: tsStr, metadataHistogramMinValue: "0.5", metadataHistogramMaxValue: "+Inf", metadataValueKey: "8"}, Quantity: 8},
+			expectedEvents: []event.Raw{
+				event.NewRaw("", 2, stringmap.StringMap{"__name__": "histogram_bucket", "foo": "bar", "le": "1", metadataTimestampKey: tsStr, metadataHistogramMinValue: "-Inf", metadataHistogramMaxValue: "1", metadataValueKey: "2"}, nil),
+				event.NewRaw("", 6, stringmap.StringMap{"__name__": "histogram_bucket", "foo": "bar", "le": "3", metadataTimestampKey: tsStr, metadataHistogramMinValue: "1", metadataHistogramMaxValue: "3", metadataValueKey: "6"}, nil),
+				event.NewRaw("", 2, stringmap.StringMap{"__name__": "histogram_bucket", "foo": "bar", "le": "+Inf", metadataTimestampKey: tsStr, metadataHistogramMinValue: "6", metadataHistogramMaxValue: "+Inf", metadataValueKey: "2"}, nil),
+				event.NewRaw("", 2, stringmap.StringMap{"__name__": "histogram_bucket", "foo": "xxx", "le": "0.5", metadataTimestampKey: tsStr, metadataHistogramMinValue: "-Inf", metadataHistogramMaxValue: "0.5", metadataValueKey: "2"}, nil),
+				event.NewRaw("", 8, stringmap.StringMap{"__name__": "histogram_bucket", "foo": "xxx", "le": "+Inf", metadataTimestampKey: tsStr, metadataHistogramMinValue: "0.5", metadataHistogramMaxValue: "+Inf", metadataValueKey: "8"}, nil),
 			},
 		},
 	}
 
 	for _, testCase := range testCases {
 		q := &queryExecutor{
-			eventsChan: make(chan *event.Raw),
+			eventsChan: make(chan event.Raw),
 			Query: queryOptions{
 				Type:             histogramQueryType,
 				ResultAsQuantity: newTrue(),
@@ -669,7 +632,7 @@ func Test_processHistogramIncrease(t *testing.T) {
 			previousResult: resultFromSampleStreams(testCase.ts, testCase.data, 0),
 		}
 
-		var generatedEvents []*event.Raw
+		var generatedEvents []event.Raw
 		done := make(chan struct{})
 		go func() {
 			for e := range q.eventsChan {
@@ -682,6 +645,9 @@ func Test_processHistogramIncrease(t *testing.T) {
 		close(q.eventsChan)
 		<-done
 
-		assert.ElementsMatchf(t, testCase.expectedEvents, generatedEvents, "expected events:\n%s\n\nresult:\n%s", testCase.expectedEvents, generatedEvents)
+		assert.Equal(t, len(testCase.expectedEvents), len(generatedEvents))
+		for i, e := range testCase.expectedEvents {
+			event.AssertRawEventsEqual(t, e, generatedEvents[i], false)
+		}
 	}
 }
diff --git a/pkg/prometheus_ingester/query_executor.go b/pkg/prometheus_ingester/query_executor.go
index 8082700..31fac2f 100644
--- a/pkg/prometheus_ingester/query_executor.go
+++ b/pkg/prometheus_ingester/query_executor.go
@@ -12,15 +12,15 @@ import (
 
 	v1 "github.com/prometheus/client_golang/api/prometheus/v1"
 	"github.com/prometheus/common/model"
-	"github.com/sirupsen/logrus"
 	"github.com/seznam/slo-exporter/pkg/event"
 	"github.com/seznam/slo-exporter/pkg/stringmap"
+	"github.com/sirupsen/logrus"
 )
 
 type queryExecutor struct {
 	Query             queryOptions
 	queryTimeout      time.Duration
-	eventsChan        chan *event.Raw
+	eventsChan        chan event.Raw
 	logger            logrus.FieldLogger
 	api               v1.API
 	previousResult    queryResult
@@ -158,15 +158,15 @@ func (q *queryExecutor) emitEvent(ts time.Time, result float64, metadata stringm
 	if quantity == 0 {
 		return
 	}
-	e := &event.Raw{
-		Metadata: metadata,
-		Quantity: quantity,
-	}
-	e.Metadata = e.Metadata.Merge(stringmap.StringMap{
-		metadataValueKey:     fmt.Sprintf("%g", result),
-		metadataTimestampKey: fmt.Sprintf("%d", ts.Unix()),
-	})
-	e.Metadata = e.Metadata.Without(q.Query.DropLabels).Merge(q.Query.AdditionalLabels)
+	e := event.NewRaw(
+		"",
+		quantity,
+		metadata.Merge(stringmap.StringMap{
+			metadataValueKey:     fmt.Sprintf("%g", result),
+			metadataTimestampKey: fmt.Sprintf("%d", ts.Unix()),
+		}).Without(q.Query.DropLabels).Merge(q.Query.AdditionalLabels),
+		nil,
+	)
 	q.eventsChan <- e
 }
 
@@ -213,12 +213,12 @@ func (q *queryExecutor) processHistogramIncrease(matrix model.Matrix, ts time.Ti
 	for _, metric := range metricBucketIncreases {
 		metricBuckets := make([]float64, len(metric))
 		i := 0
-		for bucket, _ := range metric {
+		for bucket := range metric {
 			metricBuckets[i] = bucket
 			i++
 		}
 		sort.Float64s(metricBuckets)
-		var previousBucketKey float64 = math.Inf(-1)
+		var previousBucketKey = math.Inf(-1)
 		// Iterate over all buckets and report event with quantity equal to difference of it's and preceding bucket increase.
 		for _, key := range metricBuckets {
 			maxValue := key
diff --git a/pkg/relabel/relabel.go b/pkg/relabel/relabel.go
index 05917b4..c367e23 100644
--- a/pkg/relabel/relabel.go
+++ b/pkg/relabel/relabel.go
@@ -37,11 +37,11 @@ func NewFromViper(viperConfig *viper.Viper, logger logrus.FieldLogger) (*eventRe
 	return NewFromConfig(relabelConf, logger)
 }
 
-// New returns requestNormalizer which allows to add Key to RequestEvent
+// NewFromConfig returns requestNormalizer which allows to add Key to RequestEvent
 func NewFromConfig(relabelConfig []relabel.Config, logger logrus.FieldLogger) (*eventRelabelManager, error) {
 	relabelManager := eventRelabelManager{
 		relabelConfig: relabelConfig,
-		outputChannel: make(chan *event.Raw),
+		outputChannel: make(chan event.Raw),
 		logger:        logger,
 	}
 	return &relabelManager, nil
@@ -50,8 +50,8 @@ func NewFromConfig(relabelConfig []relabel.Config, logger logrus.FieldLogger) (*
 type eventRelabelManager struct {
 	relabelConfig []relabel.Config
 	observer      pipeline.EventProcessingDurationObserver
-	inputChannel  chan *event.Raw
-	outputChannel chan *event.Raw
+	inputChannel  chan event.Raw
+	outputChannel chan event.Raw
 	done          bool
 	logger        logrus.FieldLogger
 }
@@ -68,11 +68,11 @@ func (r *eventRelabelManager) RegisterMetrics(_ prometheus.Registerer, wrappedRe
 	return wrappedRegistry.Register(droppedEventsTotal)
 }
 
-func (r *eventRelabelManager) SetInputChannel(channel chan *event.Raw) {
+func (r *eventRelabelManager) SetInputChannel(channel chan event.Raw) {
 	r.inputChannel = channel
 }
 
-func (r *eventRelabelManager) OutputChannel() chan *event.Raw {
+func (r *eventRelabelManager) OutputChannel() chan event.Raw {
 	return r.outputChannel
 }
 
@@ -92,15 +92,15 @@ func (r *eventRelabelManager) observeDuration(start time.Time) {
 
 // relabelEvent applies the relabel configs on the event metadata.
 // If event is about to be dropped, nil is returned.
-func (r *eventRelabelManager) relabelEvent(event *event.Raw) *event.Raw {
-	newLabels := event.Metadata.AsPrometheusLabels()
+func (r *eventRelabelManager) relabelEvent(event event.Raw) event.Raw {
+	newLabels := event.Metadata().AsPrometheusLabels()
 	for _, relabelConfigRule := range r.relabelConfig {
 		newLabels = relabel.Process(newLabels, &relabelConfigRule)
 		if newLabels == nil {
 			return nil
 		}
 	}
-	event.Metadata = stringmap.NewFromLabels(newLabels)
+	event.SetMetadata(stringmap.NewFromLabels(newLabels))
 	return event
 }
 
diff --git a/pkg/relabel/relabel_test.go b/pkg/relabel/relabel_test.go
index e42fc77..0f23236 100644
--- a/pkg/relabel/relabel_test.go
+++ b/pkg/relabel/relabel_test.go
@@ -15,40 +15,40 @@ import (
 
 type testCase struct {
 	name        string
-	inputEvent  *event.Raw
-	outputEvent *event.Raw
+	inputEvent  event.Raw
+	outputEvent event.Raw
 }
 
 var testCases = []testCase{
 	{
 		name:        "relabel event with empty metadata",
-		inputEvent:  &event.Raw{Metadata: map[string]string{}},
-		outputEvent: &event.Raw{Metadata: map[string]string{}},
+		inputEvent:  event.NewRaw("xxx", 1, map[string]string{}, nil),
+		outputEvent: event.NewRaw("xxx", 1, map[string]string{}, nil),
 	},
 	{
 		name:        "relabel event with simple metadata that will not be modified",
-		inputEvent:  &event.Raw{Metadata: map[string]string{"foo": "bar"}},
-		outputEvent: &event.Raw{Metadata: map[string]string{"foo": "bar"}},
+		inputEvent:  event.NewRaw("xxx", 1, map[string]string{"foo": "bar"}, nil),
+		outputEvent: event.NewRaw("xxx", 1, map[string]string{"foo": "bar"}, nil),
 	},
 	{
 		name:        "relabel event which should be dropped",
-		inputEvent:  &event.Raw{Metadata: map[string]string{"to_be_dropped": "true"}},
+		inputEvent:  event.NewRaw("xxx", 1, map[string]string{"to_be_dropped": "true"}, nil),
 		outputEvent: nil,
 	},
 	{
 		name:        "relabel event where label should be dropped",
-		inputEvent:  &event.Raw{Metadata: map[string]string{"foo": "bar", "label_to_be_dropped": "xxx"}},
-		outputEvent: &event.Raw{Metadata: map[string]string{"foo": "bar"}},
+		inputEvent:  event.NewRaw("xxx", 1, map[string]string{"foo": "bar", "label_to_be_dropped": "xxx"}, nil),
+		outputEvent: event.NewRaw("xxx", 1, map[string]string{"foo": "bar"}, nil),
 	},
 	{
 		name:        "relabel event where get parameter of url is parsed out to new label",
-		inputEvent:  &event.Raw{Metadata: map[string]string{"url": "http://foo.bar:8080?operationName=test-operation"}},
-		outputEvent: &event.Raw{Metadata: map[string]string{"url": "http://foo.bar:8080?operationName=test-operation", "operation_name": "test-operation"}},
+		inputEvent:  event.NewRaw("xxx", 1, map[string]string{"url": "http://foo.bar:8080?operationName=test-operation"}, nil),
+		outputEvent: event.NewRaw("xxx", 1, map[string]string{"url": "http://foo.bar:8080?operationName=test-operation", "operation_name": "test-operation"}, nil),
 	},
 	{
 		name:        "relabel event to add all labels with prefix http_ as new labels without the prefix",
-		inputEvent:  &event.Raw{Metadata: map[string]string{"http_status": "200", "http_method": "POST"}},
-		outputEvent: &event.Raw{Metadata: map[string]string{"http_status": "200", "http_method": "POST", "status": "200", "method": "POST"}},
+		inputEvent:  event.NewRaw("xxx", 1, map[string]string{"http_status": "200", "http_method": "POST"}, nil),
+		outputEvent: event.NewRaw("xxx", 1, map[string]string{"http_status": "200", "http_method": "POST", "status": "200", "method": "POST"}, nil),
 	},
 }
 
diff --git a/pkg/slo_event_producer/config_test.go b/pkg/slo_event_producer/config_test.go
index b086aa4..28cbf19 100644
--- a/pkg/slo_event_producer/config_test.go
+++ b/pkg/slo_event_producer/config_test.go
@@ -4,8 +4,8 @@ package slo_event_producer
 //revive:enable:var-naming
 
 import (
-	"github.com/stretchr/testify/assert"
 	"github.com/seznam/slo-exporter/pkg/stringmap"
+	"github.com/stretchr/testify/assert"
 	"testing"
 )
 
@@ -25,7 +25,7 @@ func TestConfig_loadFromFile(t *testing.T) {
 				{
 					SloMatcher: sloMatcher{DomainRegexp: "domain"},
 					FailureConditionsOptions: []operatorOptions{
-						operatorOptions{
+						{
 							Operator: "numberIsHigherThan", Key: "statusCode", Value: "500",
 						},
 					},
diff --git a/pkg/slo_event_producer/event_evaluator.go b/pkg/slo_event_producer/event_evaluator.go
index 7e90f61..3c942ac 100644
--- a/pkg/slo_event_producer/event_evaluator.go
+++ b/pkg/slo_event_producer/event_evaluator.go
@@ -6,9 +6,9 @@ package slo_event_producer
 import (
 	"github.com/hashicorp/go-multierror"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/sirupsen/logrus"
 	"github.com/seznam/slo-exporter/pkg/event"
 	"github.com/seznam/slo-exporter/pkg/stringmap"
+	"github.com/sirupsen/logrus"
 )
 
 const (
@@ -126,7 +126,7 @@ func (re *EventEvaluator) AddEvaluationRule(rule *evaluationRule) {
 	re.rules = append(re.rules, rule)
 }
 
-func (re *EventEvaluator) Evaluate(newEvent *event.Raw, outChan chan<- *event.Slo) {
+func (re *EventEvaluator) Evaluate(newEvent event.Raw, outChan chan<- event.Slo) {
 	if !newEvent.IsClassified() {
 		unclassifiedEventsTotal.Inc()
 		re.logger.Warnf("dropping event %s with no classification", newEvent)
diff --git a/pkg/slo_event_producer/event_evaluator_test.go b/pkg/slo_event_producer/event_evaluator_test.go
index 5365b81..b4d2188 100644
--- a/pkg/slo_event_producer/event_evaluator_test.go
+++ b/pkg/slo_event_producer/event_evaluator_test.go
@@ -5,10 +5,10 @@ package slo_event_producer
 
 import (
 	"github.com/go-test/deep"
-	"github.com/sirupsen/logrus"
-	"github.com/stretchr/testify/assert"
 	"github.com/seznam/slo-exporter/pkg/event"
 	"github.com/seznam/slo-exporter/pkg/stringmap"
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
 	"testing"
 )
 
@@ -21,13 +21,13 @@ type sloEventTestCase struct {
 func TestSloEventProducer(t *testing.T) {
 	testCases := []sloEventTestCase{
 		{
-			inputEvent: event.Raw{Metadata: stringmap.StringMap{"statusCode": "502"}, SloClassification: &event.SloClassification{Class: "class", App: "app", Domain: "domain"}},
+			inputEvent: event.NewRaw("", 1, stringmap.StringMap{"statusCode": "502"}, &event.SloClassification{Class: "class", App: "app", Domain: "domain"}),
 			rulesConfig: rulesConfig{Rules: []ruleOptions{
 				{
 					SloMatcher:                       sloMatcher{DomainRegexp: "domain"},
 					MetadataMatcherConditionsOptions: []operatorOptions{},
 					FailureConditionsOptions: []operatorOptions{
-						operatorOptions{
+						{
 							Operator: "numberIsHigherThan", Key: "statusCode", Value: "500",
 						},
 					},
@@ -36,17 +36,17 @@ func TestSloEventProducer(t *testing.T) {
 			},
 			},
 			expectedSloEvents: []event.Slo{
-				{Domain: "domain", Class: "class", App: "app", Key: "", Metadata: stringmap.StringMap{"slo_type": "availability"}, Result: event.Fail},
+				event.NewSlo("", 1, event.Fail, event.SloClassification{Domain: "domain", App: "app", Class: "class"}, stringmap.StringMap{"slo_type": "availability"}),
 			},
 		},
 		{
-			inputEvent: event.Raw{Metadata: stringmap.StringMap{"statusCode": "200"}, SloClassification: &event.SloClassification{Class: "class", App: "app", Domain: "domain"}},
+			inputEvent: event.NewRaw("", 1, stringmap.StringMap{"statusCode": "200"}, &event.SloClassification{Class: "class", App: "app", Domain: "domain"}),
 			rulesConfig: rulesConfig{Rules: []ruleOptions{
 				{
 					SloMatcher:                       sloMatcher{DomainRegexp: "domain"},
 					MetadataMatcherConditionsOptions: []operatorOptions{},
 					FailureConditionsOptions: []operatorOptions{
-						operatorOptions{
+						{
 							Operator: "numberIsHigherThan", Key: "statusCode", Value: "500",
 						},
 					},
@@ -55,25 +55,25 @@ func TestSloEventProducer(t *testing.T) {
 			},
 			},
 			expectedSloEvents: []event.Slo{
-				{Domain: "domain", Class: "class", App: "app", Key: "", Metadata: stringmap.StringMap{"slo_type": "availability"}, Result: event.Success},
+				event.NewSlo("", 1, event.Success, event.SloClassification{Domain: "domain", App: "app", Class: "class"}, stringmap.StringMap{"slo_type": "availability"}),
 			},
 		},
 	}
 
 	for _, tc := range testCases {
-		out := make(chan *event.Slo, 100)
+		out := make(chan event.Slo, 100)
 		testedEvaluator, err := NewEventEvaluatorFromConfig(&tc.rulesConfig, logrus.New())
 		if err != nil {
 			t.Errorf("error when loading config: %v error: %v", tc.rulesConfig, err)
 		}
-		testedEvaluator.Evaluate(&tc.inputEvent, out)
+		testedEvaluator.Evaluate(tc.inputEvent, out)
 		close(out)
 		var results []event.Slo
 		for newEvent := range out {
-			results = append(results, *newEvent)
+			results = append(results, newEvent)
 		}
 		if diff := deep.Equal(tc.expectedSloEvents, results); diff != nil {
-			t.Errorf("events are different %+v, \nexpected: %+v\n result: %+v\n input event metadata: %+v", diff, tc.expectedSloEvents, results, tc.inputEvent.Metadata)
+			t.Errorf("events are different %+v, \nexpected: %+v\n result: %+v\n input event metadata: %+v", diff, tc.expectedSloEvents, results, tc.inputEvent.Metadata())
 		}
 	}
 }
diff --git a/pkg/slo_event_producer/operator.go b/pkg/slo_event_producer/operator.go
index e4a6027..be062f3 100644
--- a/pkg/slo_event_producer/operator.go
+++ b/pkg/slo_event_producer/operator.go
@@ -28,7 +28,7 @@ var operatorFactoryRegistry = map[string]operatorFactory{
 type operatorFactory func() operator
 
 type operator interface {
-	Evaluate(*event.Raw) (bool, error)
+	Evaluate(event.Raw) (bool, error)
 	LoadOptions(operatorOptions) error
 }
 
@@ -87,8 +87,8 @@ func (n *numberComparisonOperator) LoadOptions(options operatorOptions) error {
 	return nil
 }
 
-func (n *numberComparisonOperator) getKeyNumber(evaluatedEvent *event.Raw) (float64, bool, error) {
-	metadataValue, ok := evaluatedEvent.Metadata[n.key]
+func (n *numberComparisonOperator) getKeyNumber(evaluatedEvent event.Raw) (float64, bool, error) {
+	metadataValue, ok := evaluatedEvent.Metadata()[n.key]
 	if !ok {
 		return 0, false, nil
 	}
@@ -115,7 +115,7 @@ type numberIsHigherThan struct {
 	numberComparisonOperator
 }
 
-func (r *numberIsHigherThan) Evaluate(evaluatedEvent *event.Raw) (bool, error) {
+func (r *numberIsHigherThan) Evaluate(evaluatedEvent event.Raw) (bool, error) {
 	testedValue, ok, err := r.getKeyNumber(evaluatedEvent)
 	if !ok {
 		return false, err
@@ -132,7 +132,7 @@ type numberIsEqualOrHigherThan struct {
 	numberComparisonOperator
 }
 
-func (r *numberIsEqualOrHigherThan) Evaluate(evaluatedEvent *event.Raw) (bool, error) {
+func (r *numberIsEqualOrHigherThan) Evaluate(evaluatedEvent event.Raw) (bool, error) {
 	testedValue, ok, err := r.getKeyNumber(evaluatedEvent)
 	if !ok {
 		return false, err
@@ -149,7 +149,7 @@ type numberIsEqualOrLessThan struct {
 	numberComparisonOperator
 }
 
-func (r *numberIsEqualOrLessThan) Evaluate(evaluatedEvent *event.Raw) (bool, error) {
+func (r *numberIsEqualOrLessThan) Evaluate(evaluatedEvent event.Raw) (bool, error) {
 	testedValue, ok, err := r.getKeyNumber(evaluatedEvent)
 	if !ok {
 		return false, err
@@ -166,7 +166,7 @@ type numberIsEqualTo struct {
 	numberComparisonOperator
 }
 
-func (r *numberIsEqualTo) Evaluate(evaluatedEvent *event.Raw) (bool, error) {
+func (r *numberIsEqualTo) Evaluate(evaluatedEvent event.Raw) (bool, error) {
 	testedValue, ok, err := r.getKeyNumber(evaluatedEvent)
 	if !ok {
 		return false, err
@@ -187,7 +187,7 @@ type numberIsNotEqualTo struct {
 	numberComparisonOperator
 }
 
-func (r *numberIsNotEqualTo) Evaluate(evaluatedEvent *event.Raw) (bool, error) {
+func (r *numberIsNotEqualTo) Evaluate(evaluatedEvent event.Raw) (bool, error) {
 	testedValue, ok, err := r.getKeyNumber(evaluatedEvent)
 	if !ok {
 		return false, err
@@ -219,8 +219,8 @@ func (r *durationIsHigherThan) LoadOptions(options operatorOptions) error {
 	return nil
 }
 
-func (r *durationIsHigherThan) Evaluate(evaluatedEvent *event.Raw) (bool, error) {
-	metadataValue, ok := evaluatedEvent.Metadata[r.key]
+func (r *durationIsHigherThan) Evaluate(evaluatedEvent event.Raw) (bool, error) {
+	metadataValue, ok := evaluatedEvent.Metadata()[r.key]
 	if !ok {
 		return false, nil
 	}
@@ -251,8 +251,8 @@ func (r *isEqualTo) LoadOptions(options operatorOptions) error {
 	return nil
 }
 
-func (r *isEqualTo) Evaluate(evaluatedEvent *event.Raw) (bool, error) {
-	testedValue, ok := evaluatedEvent.Metadata[r.key]
+func (r *isEqualTo) Evaluate(evaluatedEvent event.Raw) (bool, error) {
+	testedValue, ok := evaluatedEvent.Metadata()[r.key]
 	if !ok {
 		return false, nil
 	}
@@ -283,8 +283,8 @@ func (r *isNotEqualTo) LoadOptions(options operatorOptions) error {
 	return nil
 }
 
-func (r *isNotEqualTo) Evaluate(evaluatedEvent *event.Raw) (bool, error) {
-	testedValue, ok := evaluatedEvent.Metadata[r.key]
+func (r *isNotEqualTo) Evaluate(evaluatedEvent event.Raw) (bool, error) {
+	testedValue, ok := evaluatedEvent.Metadata()[r.key]
 	if !ok {
 		return false, nil
 	}
@@ -314,8 +314,8 @@ func (r *isMatchingRegexp) LoadOptions(options operatorOptions) error {
 	return err
 }
 
-func (r *isMatchingRegexp) Evaluate(evaluatedEvent *event.Raw) (bool, error) {
-	testedValue, ok := evaluatedEvent.Metadata[r.key]
+func (r *isMatchingRegexp) Evaluate(evaluatedEvent event.Raw) (bool, error) {
+	testedValue, ok := evaluatedEvent.Metadata()[r.key]
 	if !ok {
 		return false, nil
 	}
@@ -345,8 +345,8 @@ func (r *isNotMatchingRegexp) LoadOptions(options operatorOptions) error {
 	return err
 }
 
-func (r *isNotMatchingRegexp) Evaluate(evaluatedEvent *event.Raw) (bool, error) {
-	testedValue, ok := evaluatedEvent.Metadata[r.key]
+func (r *isNotMatchingRegexp) Evaluate(evaluatedEvent event.Raw) (bool, error) {
+	testedValue, ok := evaluatedEvent.Metadata()[r.key]
 	if !ok {
 		return false, nil
 	}
diff --git a/pkg/slo_event_producer/operator_test.go b/pkg/slo_event_producer/operator_test.go
index 3558d45..05b2519 100644
--- a/pkg/slo_event_producer/operator_test.go
+++ b/pkg/slo_event_producer/operator_test.go
@@ -4,9 +4,9 @@ package slo_event_producer
 //revive:enable:var-naming
 
 import (
-	"github.com/stretchr/testify/assert"
 	"github.com/seznam/slo-exporter/pkg/event"
 	"github.com/seznam/slo-exporter/pkg/stringmap"
+	"github.com/stretchr/testify/assert"
 	"regexp"
 	"testing"
 	"time"
@@ -52,56 +52,56 @@ type testEvent struct {
 func TestCriteria(t *testing.T) {
 	testCases := []testEvent{
 		// numberIsHigherThan
-		{event: event.Raw{Metadata: stringmap.StringMap{"number": "20"}}, operator: &numberIsHigherThan{numberComparisonOperator{name: "numberIsHigherThan", key: "number", value: 10}}, result: true, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"number": "1"}}, operator: &numberIsHigherThan{numberComparisonOperator{name: "numberIsHigherThan", key: "number", value: 10}}, result: false, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"number": "12.5"}}, operator: &numberIsHigherThan{numberComparisonOperator{name: "numberIsHigherThan", key: "number", value: 10}}, result: true, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"number": "foo"}}, operator: &numberIsHigherThan{numberComparisonOperator{name: "numberIsHigherThan", key: "number", value: 10}}, result: false, err: true},
-		{event: event.Raw{}, operator: &numberIsHigherThan{numberComparisonOperator{value: 10}}, result: false, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"number": "20"}, nil), operator: &numberIsHigherThan{numberComparisonOperator{name: "numberIsHigherThan", key: "number", value: 10}}, result: true, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"number": "1"}, nil), operator: &numberIsHigherThan{numberComparisonOperator{name: "numberIsHigherThan", key: "number", value: 10}}, result: false, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"number": "12.5"}, nil), operator: &numberIsHigherThan{numberComparisonOperator{name: "numberIsHigherThan", key: "number", value: 10}}, result: true, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"number": "foo"}, nil), operator: &numberIsHigherThan{numberComparisonOperator{name: "numberIsHigherThan", key: "number", value: 10}}, result: false, err: true},
+		{event: event.NewRaw("", 1, nil, nil), operator: &numberIsHigherThan{numberComparisonOperator{value: 10}}, result: false, err: false},
 
 		// numberIsEqualOrHigherThan
-		{event: event.Raw{Metadata: stringmap.StringMap{"number": "10"}}, operator: &numberIsEqualOrHigherThan{numberComparisonOperator{name: "numberIsEqualOrHigherThan", key: "number", value: 10}}, result: true, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"number": "1"}}, operator: &numberIsEqualOrHigherThan{numberComparisonOperator{name: "numberIsEqualOrHigherThan", key: "number", value: 10}}, result: false, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"number": "12.5"}}, operator: &numberIsEqualOrHigherThan{numberComparisonOperator{name: "numberIsEqualOrHigherThan", key: "number", value: 10}}, result: true, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"number": "10"}, nil), operator: &numberIsEqualOrHigherThan{numberComparisonOperator{name: "numberIsEqualOrHigherThan", key: "number", value: 10}}, result: true, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"number": "1"}, nil), operator: &numberIsEqualOrHigherThan{numberComparisonOperator{name: "numberIsEqualOrHigherThan", key: "number", value: 10}}, result: false, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"number": "12.5"}, nil), operator: &numberIsEqualOrHigherThan{numberComparisonOperator{name: "numberIsEqualOrHigherThan", key: "number", value: 10}}, result: true, err: false},
 
 		// numberIsEqualTo
-		{event: event.Raw{Metadata: stringmap.StringMap{"number": "10"}}, operator: &numberIsEqualTo{numberComparisonOperator{name: "numberIsEqualTo", key: "number", value: 10}}, result: true, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"number": "1"}}, operator: &numberIsEqualTo{numberComparisonOperator{name: "numberIsEqualTo", key: "number", value: 10}}, result: false, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"number": "10"}, nil), operator: &numberIsEqualTo{numberComparisonOperator{name: "numberIsEqualTo", key: "number", value: 10}}, result: true, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"number": "1"}, nil), operator: &numberIsEqualTo{numberComparisonOperator{name: "numberIsEqualTo", key: "number", value: 10}}, result: false, err: false},
 
 		// numberIsNotEqualTo
-		{event: event.Raw{Metadata: stringmap.StringMap{"number": "10"}}, operator: &numberIsNotEqualTo{numberComparisonOperator{name: "numberIsNotEqualTo", key: "number", value: 10}}, result: false, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"number": "11"}}, operator: &numberIsNotEqualTo{numberComparisonOperator{name: "numberIsNotEqualTo", key: "number", value: 10}}, result: true, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"number": "10"}, nil), operator: &numberIsNotEqualTo{numberComparisonOperator{name: "numberIsNotEqualTo", key: "number", value: 10}}, result: false, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"number": "11"}, nil), operator: &numberIsNotEqualTo{numberComparisonOperator{name: "numberIsNotEqualTo", key: "number", value: 10}}, result: true, err: false},
 
 		// numberIsEqualOrLessThan
-		{event: event.Raw{Metadata: stringmap.StringMap{"number": "10"}}, operator: &numberIsEqualOrLessThan{numberComparisonOperator{name: "numberIsEqualOrLessThan", key: "number", value: 10}}, result: true, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"number": "1"}}, operator: &numberIsEqualOrLessThan{numberComparisonOperator{name: "numberIsEqualOrLessThan", key: "number", value: 10}}, result: true, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"number": "20"}}, operator: &numberIsEqualOrLessThan{numberComparisonOperator{name: "numberIsEqualOrLessThan", key: "number", value: 10}}, result: false, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"number": "10"}, nil), operator: &numberIsEqualOrLessThan{numberComparisonOperator{name: "numberIsEqualOrLessThan", key: "number", value: 10}}, result: true, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"number": "1"}, nil), operator: &numberIsEqualOrLessThan{numberComparisonOperator{name: "numberIsEqualOrLessThan", key: "number", value: 10}}, result: true, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"number": "20"}, nil), operator: &numberIsEqualOrLessThan{numberComparisonOperator{name: "numberIsEqualOrLessThan", key: "number", value: 10}}, result: false, err: false},
 
 		// durationIsHigherThan
-		{event: event.Raw{Metadata: stringmap.StringMap{"duration": "20s"}}, operator: &durationIsHigherThan{key: "duration", thresholdDuration: 10 * time.Second}, result: true, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"duration": "5ms"}}, operator: &durationIsHigherThan{key: "duration", thresholdDuration: 10 * time.Second}, result: false, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"duration": "foo"}}, operator: &durationIsHigherThan{key: "duration", thresholdDuration: 10 * time.Second}, result: false, err: true},
-		{event: event.Raw{}, operator: &numberIsHigherThan{numberComparisonOperator{value: 10}}, result: false, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"duration": "20s"}, nil), operator: &durationIsHigherThan{key: "duration", thresholdDuration: 10 * time.Second}, result: true, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"duration": "5ms"}, nil), operator: &durationIsHigherThan{key: "duration", thresholdDuration: 10 * time.Second}, result: false, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"duration": "foo"}, nil), operator: &durationIsHigherThan{key: "duration", thresholdDuration: 10 * time.Second}, result: false, err: true},
+		{event: event.NewRaw("", 1, nil, nil), operator: &numberIsHigherThan{numberComparisonOperator{value: 10}}, result: false, err: false},
 
 		// equalTo
-		{event: event.Raw{Metadata: stringmap.StringMap{"foo": "foobar"}}, operator: &isEqualTo{key: "foo", value: "foobar"}, result: true, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"foo": "foobar"}}, operator: &isEqualTo{key: "foo", value: "xxx"}, result: false, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"foo": "foobar"}, nil), operator: &isEqualTo{key: "foo", value: "foobar"}, result: true, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"foo": "foobar"}, nil), operator: &isEqualTo{key: "foo", value: "xxx"}, result: false, err: false},
 
 		// notEqualTo
-		{event: event.Raw{Metadata: stringmap.StringMap{"foo": "foobar"}}, operator: &isNotEqualTo{key: "foo", value: "foobar"}, result: false, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"foo": "foobar"}}, operator: &isNotEqualTo{key: "foo", value: "xxx"}, result: true, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"foo": "foobar"}, nil), operator: &isNotEqualTo{key: "foo", value: "foobar"}, result: false, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"foo": "foobar"}, nil), operator: &isNotEqualTo{key: "foo", value: "xxx"}, result: true, err: false},
 
 		// isMatchingRegexp
-		{event: event.Raw{Metadata: stringmap.StringMap{"foo": "foobar"}}, operator: &isMatchingRegexp{key: "foo", regexp: regexp.MustCompile("bar")}, result: true, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"foo": "foobar"}}, operator: &isMatchingRegexp{key: "foo", regexp: regexp.MustCompile("xxx")}, result: false, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"foo": ""}}, operator: &isMatchingRegexp{key: "foo", regexp: regexp.MustCompile(".*")}, result: true, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"foo": "foobar"}, nil), operator: &isMatchingRegexp{key: "foo", regexp: regexp.MustCompile("bar")}, result: true, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"foo": "foobar"}, nil), operator: &isMatchingRegexp{key: "foo", regexp: regexp.MustCompile("xxx")}, result: false, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"foo": ""}, nil), operator: &isMatchingRegexp{key: "foo", regexp: regexp.MustCompile(".*")}, result: true, err: false},
 
 		// isNotMatchingRegexp
-		{event: event.Raw{Metadata: stringmap.StringMap{"foo": "foobar"}}, operator: &isNotMatchingRegexp{key: "foo", regexp: regexp.MustCompile("bar")}, result: false, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"foo": "foobar"}}, operator: &isNotMatchingRegexp{key: "foo", regexp: regexp.MustCompile("xxx")}, result: true, err: false},
-		{event: event.Raw{Metadata: stringmap.StringMap{"foo": ""}}, operator: &isNotMatchingRegexp{key: "foo", regexp: regexp.MustCompile(".*")}, result: false, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"foo": "foobar"}, nil), operator: &isNotMatchingRegexp{key: "foo", regexp: regexp.MustCompile("bar")}, result: false, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"foo": "foobar"}, nil), operator: &isNotMatchingRegexp{key: "foo", regexp: regexp.MustCompile("xxx")}, result: true, err: false},
+		{event: event.NewRaw("", 1, stringmap.StringMap{"foo": ""}, nil), operator: &isNotMatchingRegexp{key: "foo", regexp: regexp.MustCompile(".*")}, result: false, err: false},
 	}
 	for _, c := range testCases {
-		res, err := c.operator.Evaluate(&c.event)
+		res, err := c.operator.Evaluate(c.event)
 		if c.err {
 			assert.Error(t, err, "expected error for event: %+v", c.event)
 		} else {
diff --git a/pkg/slo_event_producer/rule.go b/pkg/slo_event_producer/rule.go
index 1e2158b..0eff6e4 100644
--- a/pkg/slo_event_producer/rule.go
+++ b/pkg/slo_event_producer/rule.go
@@ -58,21 +58,21 @@ func newEvaluationRule(opts ruleOptions, logger logrus.FieldLogger) (*evaluation
 	if opts.SloMatcher.DomainRegexp != "" {
 		r, err := regexp.Compile(opts.SloMatcher.DomainRegexp)
 		if err != nil {
-			return nil, fmt.Errorf("invalid domain matcher regexp: %w",err)
+			return nil, fmt.Errorf("invalid domain matcher regexp: %w", err)
 		}
 		sloMatcher.domainRegexp = r
 	}
 	if opts.SloMatcher.ClassRegexp != "" {
 		r, err := regexp.Compile(opts.SloMatcher.ClassRegexp)
 		if err != nil {
-			return nil, fmt.Errorf("invalid class matcher regexp: %w",err)
+			return nil, fmt.Errorf("invalid class matcher regexp: %w", err)
 		}
 		sloMatcher.classRegexp = r
 	}
 	if opts.SloMatcher.AppRegexp != "" {
 		r, err := regexp.Compile(opts.SloMatcher.AppRegexp)
 		if err != nil {
-			return nil, fmt.Errorf("invalid app matcher regexp: %w",err)
+			return nil, fmt.Errorf("invalid app matcher regexp: %w", err)
 		}
 		sloMatcher.appRegexp = r
 	}
@@ -93,38 +93,30 @@ type evaluationRule struct {
 	logger             logrus.FieldLogger
 }
 
-func (er *evaluationRule) markEventResult(failed bool, newEvent *event.Slo) {
-	if failed {
-		newEvent.Result = event.Fail
-	} else {
-		newEvent.Result = event.Success
-	}
-}
-
 // evaluateEvent and return bool on whether it is to be considered as failed
-func (er *evaluationRule) evaluateEvent(newEvent *event.Raw) bool {
-	failed := false
+func (er *evaluationRule) evaluateEvent(newEvent event.Raw) event.Result {
+	result := event.Success
 	// Evaluate all criteria and if matches any, mark it as failed.
 	for _, operator := range er.failureConditions {
-		result, err := operator.Evaluate(newEvent)
+		matches, err := operator.Evaluate(newEvent)
 		if err != nil {
 			er.logger.WithError(err).WithField("event", newEvent).Warnf("failed to evaluate operator %v", operator)
 		}
-		if result {
-			failed = true
+		if matches {
+			result = event.Fail
 			break
 		}
 	}
-	return failed
+	return result
 }
 
-func (er *evaluationRule) processEvent(newEvent *event.Raw) (*event.Slo, bool) {
-	eventSloClassification := newEvent.GetSloClassification()
-	if !newEvent.IsClassified() || eventSloClassification == nil {
+func (er *evaluationRule) processEvent(newEvent event.Raw) (event.Slo, bool) {
+	eventSloClassification := newEvent.SloClassification()
+	if !newEvent.IsClassified() {
 		return nil, false
 	}
 	// Check if rule matches the newEvent
-	if !er.sloMatcher.matchesSloClassification(*eventSloClassification) {
+	if !er.sloMatcher.matchesSloClassification(eventSloClassification) {
 		return nil, false
 	}
 	var (
@@ -142,17 +134,9 @@ func (er *evaluationRule) processEvent(newEvent *event.Raw) (*event.Slo, bool) {
 		}
 	}
 
-	failed := er.evaluateEvent(newEvent)
+	result := er.evaluateEvent(newEvent)
 
-	newSloEvent := &event.Slo{
-		Key:      newEvent.EventKey(),
-		Domain:   eventSloClassification.Domain,
-		Class:    eventSloClassification.Class,
-		App:      eventSloClassification.App,
-		Metadata: er.additionalMetadata,
-		Quantity: newEvent.Quantity,
-	}
-	er.markEventResult(failed, newSloEvent)
+	newSloEvent := event.NewSlo(newEvent.EventKey(), newEvent.Quantity(), result, eventSloClassification, er.additionalMetadata)
 	er.logger.WithField("event", newSloEvent).Debug("generated new slo event")
 	return newSloEvent, true
 
diff --git a/pkg/slo_event_producer/rule_test.go b/pkg/slo_event_producer/rule_test.go
index 39ee3b9..cd15e9c 100644
--- a/pkg/slo_event_producer/rule_test.go
+++ b/pkg/slo_event_producer/rule_test.go
@@ -16,7 +16,7 @@ type ruleTestCase struct {
 	name           string
 	rule           evaluationRule
 	inputEvent     event.Raw
-	outputSloEvent *event.Slo
+	outputSloEvent event.Slo
 	ok             bool
 }
 
@@ -29,11 +29,8 @@ func TestEvaluateEvent(t *testing.T) {
 				failureConditions:  []operator{&numberIsEqualOrHigherThan{numberComparisonOperator{key: "statusCode", value: 500}}},
 				logger:             logrus.New(),
 			},
-			inputEvent: event.Raw{
-				Metadata:          stringmap.StringMap{"statusCode": "200"},
-				SloClassification: &event.SloClassification{Class: "class", App: "app", Domain: "domain"},
-			},
-			outputSloEvent: &event.Slo{Domain: "domain", Class: "class", App: "app", Key: "", Metadata: stringmap.StringMap{}, Result: event.Success},
+			inputEvent:     event.NewRaw("", 1, stringmap.StringMap{"statusCode": "200"}, &event.SloClassification{Class: "class", App: "app", Domain: "domain"}),
+			outputSloEvent: event.NewSlo("", 1, event.Success, event.SloClassification{Domain: "domain", Class: "class", App: "app"}, nil),
 			ok:             true,
 		},
 		{
@@ -43,11 +40,8 @@ func TestEvaluateEvent(t *testing.T) {
 				failureConditions:  []operator{&numberIsEqualOrHigherThan{numberComparisonOperator{key: "statusCode", value: 500}}},
 				logger:             logrus.New(),
 			},
-			inputEvent: event.Raw{
-				Metadata:          stringmap.StringMap{"statusCode": "502"},
-				SloClassification: &event.SloClassification{Class: "class", App: "app", Domain: "domain"},
-			},
-			outputSloEvent: &event.Slo{Domain: "domain", Class: "class", App: "app", Key: "", Metadata: stringmap.StringMap{}, Result: event.Fail},
+			inputEvent:     event.NewRaw("", 1, stringmap.StringMap{"statusCode": "502"}, &event.SloClassification{Class: "class", App: "app", Domain: "domain"}),
+			outputSloEvent: event.NewSlo("", 1, event.Fail, event.SloClassification{Domain: "domain", Class: "class", App: "app"}, nil),
 			ok:             true,
 		},
 		{
@@ -57,10 +51,7 @@ func TestEvaluateEvent(t *testing.T) {
 				failureConditions:  []operator{&isMatchingRegexp{key: "statusCode", regexp: regexp.MustCompile("500")}},
 				logger:             logrus.New(),
 			},
-			inputEvent: event.Raw{
-				Metadata:          stringmap.StringMap{"statusCode": "502"},
-				SloClassification: nil,
-			},
+			inputEvent:     event.NewRaw("", 1, stringmap.StringMap{"statusCode": "502"}, nil),
 			outputSloEvent: nil,
 			ok:             false,
 		},
@@ -72,10 +63,7 @@ func TestEvaluateEvent(t *testing.T) {
 				failureConditions:  []operator{&isMatchingRegexp{key: "statusCode", regexp: regexp.MustCompile("500")}},
 				logger:             logrus.New(),
 			},
-			inputEvent: event.Raw{
-				Metadata:          stringmap.StringMap{"statusCode": "502"},
-				SloClassification: &event.SloClassification{Class: "class", App: "app", Domain: "domain"},
-			},
+			inputEvent:     event.NewRaw("", 1, stringmap.StringMap{"statusCode": "502"}, &event.SloClassification{Class: "class", App: "app", Domain: "domain"}),
 			outputSloEvent: nil,
 			ok:             false,
 		},
@@ -88,10 +76,7 @@ func TestEvaluateEvent(t *testing.T) {
 				failureConditions:  []operator{&isMatchingRegexp{key: "statusCode", regexp: regexp.MustCompile("500")}},
 				logger:             logrus.New(),
 			},
-			inputEvent: event.Raw{
-				Metadata:          stringmap.StringMap{"statusCode": "200"},
-				SloClassification: &event.SloClassification{Class: "class", App: "app", Domain: "domain"},
-			},
+			inputEvent:     event.NewRaw("", 1, stringmap.StringMap{"statusCode": "200"}, &event.SloClassification{Class: "class", App: "app", Domain: "domain"}),
 			outputSloEvent: nil,
 			ok:             false,
 		},
@@ -104,18 +89,15 @@ func TestEvaluateEvent(t *testing.T) {
 				failureConditions:  []operator{&isMatchingRegexp{key: "statusCode", regexp: regexp.MustCompile("500")}},
 				logger:             logrus.New(),
 			},
-			inputEvent: event.Raw{
-				Metadata:          stringmap.StringMap{"statusCode": "200", "key": "value"},
-				SloClassification: &event.SloClassification{Class: "class", App: "app", Domain: "domain"},
-			},
-			outputSloEvent: &event.Slo{Domain: "domain", Class: "class", App: "app", Key: "", Metadata: stringmap.StringMap{}, Result: event.Success},
+			inputEvent:     event.NewRaw("", 1, stringmap.StringMap{"statusCode": "200", "key": "value"}, &event.SloClassification{Class: "class", App: "app", Domain: "domain"}),
+			outputSloEvent: event.NewSlo("", 1, event.Success, event.SloClassification{Domain: "domain", Class: "class", App: "app"}, nil),
 			ok:             true,
 		},
 	}
 
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			sloEvent, ok := tc.rule.processEvent(&tc.inputEvent)
+			sloEvent, ok := tc.rule.processEvent(tc.inputEvent)
 			assert.Equal(t, ok, tc.ok)
 			assert.Equal(t, tc.outputSloEvent, sloEvent, "unexpected result evaluating rule: %+v\n  with conditions: %+v\non event:\n  metadata: %+v\n  classification: %+v", tc.rule, tc.rule.failureConditions[0], tc.inputEvent.Metadata, tc.inputEvent.SloClassification)
 
diff --git a/pkg/slo_event_producer/slo_event_producer.go b/pkg/slo_event_producer/slo_event_producer.go
index c5ad6e2..e05c960 100644
--- a/pkg/slo_event_producer/slo_event_producer.go
+++ b/pkg/slo_event_producer/slo_event_producer.go
@@ -6,9 +6,9 @@ package slo_event_producer
 import (
 	"fmt"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/spf13/viper"
 	"github.com/seznam/slo-exporter/pkg/event"
 	"github.com/seznam/slo-exporter/pkg/pipeline"
+	"github.com/spf13/viper"
 	"time"
 
 	"github.com/sirupsen/logrus"
@@ -53,8 +53,8 @@ func New(config sloEventProducerConfig, logger logrus.FieldLogger) (*SloEventPro
 	}
 	return &SloEventProducer{
 		eventEvaluator:       eventEvaluator,
-		inputChannel:         make(chan *event.Raw),
-		outputChannel:        make(chan *event.Slo),
+		inputChannel:         make(chan event.Raw),
+		outputChannel:        make(chan event.Slo),
 		logger:               logger,
 		exposeRulesInMetrics: config.ExposeRulesAsMetrics,
 		done:                 false,
@@ -64,8 +64,8 @@ func New(config sloEventProducerConfig, logger logrus.FieldLogger) (*SloEventPro
 type SloEventProducer struct {
 	eventEvaluator       *EventEvaluator
 	observer             pipeline.EventProcessingDurationObserver
-	inputChannel         chan *event.Raw
-	outputChannel        chan *event.Slo
+	inputChannel         chan event.Raw
+	outputChannel        chan event.Slo
 	logger               logrus.FieldLogger
 	exposeRulesInMetrics bool
 	done                 bool
@@ -75,11 +75,11 @@ func (sep *SloEventProducer) String() string {
 	return "sloEventProducer"
 }
 
-func (sep *SloEventProducer) OutputChannel() chan *event.Slo {
+func (sep *SloEventProducer) OutputChannel() chan event.Slo {
 	return sep.outputChannel
 }
 
-func (sep *SloEventProducer) SetInputChannel(channel chan *event.Raw) {
+func (sep *SloEventProducer) SetInputChannel(channel chan event.Raw) {
 	sep.inputChannel = channel
 }
 
@@ -116,7 +116,7 @@ func (sep *SloEventProducer) observeDuration(start time.Time) {
 	}
 }
 
-func (sep *SloEventProducer) generateSLOEvents(event *event.Raw, sloEventsChan chan<- *event.Slo) {
+func (sep *SloEventProducer) generateSLOEvents(event event.Raw, sloEventsChan chan<- event.Slo) {
 	sep.eventEvaluator.Evaluate(event, sloEventsChan)
 }
 
diff --git a/pkg/statistical_classifier/statistical_classifier.go b/pkg/statistical_classifier/statistical_classifier.go
index 69be346..e3f9178 100644
--- a/pkg/statistical_classifier/statistical_classifier.go
+++ b/pkg/statistical_classifier/statistical_classifier.go
@@ -6,13 +6,13 @@ package statistical_classifier
 import (
 	"context"
 	"fmt"
-	"github.com/sirupsen/logrus"
 	"github.com/seznam/slo-exporter/pkg/pipeline"
+	"github.com/sirupsen/logrus"
 	"time"
 
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/spf13/viper"
 	"github.com/seznam/slo-exporter/pkg/event"
+	"github.com/spf13/viper"
 )
 
 const (
@@ -58,8 +58,8 @@ type StatisticalClassifier struct {
 	classifier    *weightedClassifier
 	observer      pipeline.EventProcessingDurationObserver
 	logger        logrus.FieldLogger
-	inputChannel  chan *event.Raw
-	outputChannel chan *event.Raw
+	inputChannel  chan event.Raw
+	outputChannel chan event.Raw
 	done          bool
 }
 
@@ -114,17 +114,17 @@ func New(conf classifierConfig, logger logrus.FieldLogger) (*StatisticalClassifi
 	return &StatisticalClassifier{
 		classifier:    newClassifier,
 		logger:        logger,
-		inputChannel:  make(chan *event.Raw),
-		outputChannel: make(chan *event.Raw),
+		inputChannel:  make(chan event.Raw),
+		outputChannel: make(chan event.Raw),
 		done:          false,
 	}, nil
 }
 
-func (sc *StatisticalClassifier) OutputChannel() chan *event.Raw {
+func (sc *StatisticalClassifier) OutputChannel() chan event.Raw {
 	return sc.outputChannel
 }
 
-func (sc *StatisticalClassifier) SetInputChannel(channel chan *event.Raw) {
+func (sc *StatisticalClassifier) SetInputChannel(channel chan event.Raw) {
 	sc.inputChannel = channel
 }
 
@@ -157,24 +157,24 @@ func (sc *StatisticalClassifier) observeDuration(start time.Time) {
 }
 
 // To be able to distinguish statistically guessed events from regular ones, some of the classification parts are replaced with placeholder.
-func (sc *StatisticalClassifier) sanitizeGuessedClassification(classification *event.SloClassification) event.SloClassification {
+func (sc *StatisticalClassifier) sanitizeGuessedClassification(classification event.SloClassification) event.SloClassification {
 	newClassification := classification.Copy()
 	newClassification.App = guessedLabelPlaceholder
 	return newClassification
 }
 
 // Classify classifies event. Classification is guessed based on frequency of observed classifications over history window.
-func (sc *StatisticalClassifier) Classify(event *event.Raw) error {
+func (sc *StatisticalClassifier) Classify(event event.Raw) error {
 	if !event.IsClassified() {
 		classification, err := sc.classifier.guessClass()
 		if err != nil {
 			eventsTotal.WithLabelValues("unclassified").Inc()
 			return err
 		}
-		event.UpdateSLOClassification(classification)
+		event.SetSLOClassification(*classification)
 		eventsTotal.WithLabelValues("classified").Inc()
 	} else {
-		sc.classifier.increaseWeight(sc.sanitizeGuessedClassification(event.GetSloClassification()), 1)
+		sc.classifier.increaseWeight(sc.sanitizeGuessedClassification(event.SloClassification()), 1)
 		eventsTotal.WithLabelValues("increased-weight").Inc()
 	}
 	return nil
diff --git a/pkg/stringmap/stringmap.go b/pkg/stringmap/stringmap.go
index d4c665f..557bfc5 100644
--- a/pkg/stringmap/stringmap.go
+++ b/pkg/stringmap/stringmap.go
@@ -73,7 +73,7 @@ func (m StringMap) AddKeys(keys ...string) {
 	}
 }
 
-// Keys returns sorted list of StringMap keys.
+// SortedKeys returns sorted list of StringMap keys.
 func (m StringMap) SortedKeys() []string {
 	keys := m.Keys()
 	sort.Strings(keys)
@@ -179,3 +179,17 @@ func (m StringMap) AsPrometheusLabels() labels.Labels {
 	}
 	return newLabels
 }
+
+// Get returns value of the given key, if not found, returns the default value
+func (m StringMap) Get(key, defaultValue string) string {
+	val, ok := m[key]
+	if !ok {
+		return defaultValue
+	}
+	return val
+}
+
+// Set the value of given key
+func (m StringMap) Set(key, value string) {
+	m[key] = value
+}
diff --git a/pkg/stringmap/stringmap_test.go b/pkg/stringmap/stringmap_test.go
index 1e7b12f..6927dd6 100644
--- a/pkg/stringmap/stringmap_test.go
+++ b/pkg/stringmap/stringmap_test.go
@@ -118,6 +118,44 @@ func TestStringMap_Select(t *testing.T) {
 	}
 }
 
+type stringMapGetTestCase struct {
+	meta         StringMap
+	key          string
+	defaultValue string
+	res          string
+}
+
+func TestStringMap_Get(t *testing.T) {
+	testCases := []stringMapGetTestCase{
+		{meta: StringMap{"a": "1"}, key: "a", defaultValue: "bar", res: "1"},
+		{meta: StringMap{"a": "1"}, key: "foo", defaultValue: "bar", res: "bar"},
+	}
+
+	for _, tc := range testCases {
+		assert.Equal(t, tc.res, tc.meta.Get(tc.key, tc.defaultValue))
+	}
+}
+
+type stringMapSetTestCase struct {
+	meta  StringMap
+	key   string
+	value string
+	res   StringMap
+}
+
+func TestStringMap_Set(t *testing.T) {
+	testCases := []stringMapSetTestCase{
+		{meta: StringMap{}, key: "foo", value: "bar", res: StringMap{"foo": "bar"}},
+		{meta: StringMap{"foo": ""}, key: "foo", value: "bar", res: StringMap{"foo": "bar"}},
+		{meta: StringMap{"xxx": "yyy"}, key: "foo", value: "bar", res: StringMap{"xxx": "yyy", "foo": "bar"}},
+	}
+
+	for _, tc := range testCases {
+		tc.meta.Set(tc.key, tc.value)
+		assert.Equal(t, tc.res, tc.meta)
+	}
+}
+
 type stringMapLowercaseTestCase struct {
 	meta StringMap
 	res  StringMap
diff --git a/pkg/tailer/tailer.go b/pkg/tailer/tailer.go
index 5546166..92889f2 100644
--- a/pkg/tailer/tailer.go
+++ b/pkg/tailer/tailer.go
@@ -3,6 +3,7 @@ package tailer
 import (
 	"errors"
 	"fmt"
+	"github.com/seznam/slo-exporter/pkg/stringmap"
 	"io"
 	"os"
 	"regexp"
@@ -49,6 +50,7 @@ type tailerConfig struct {
 	PositionPersistenceInterval time.Duration
 	LoglineParseRegexp          string
 	EmptyGroupRE                string
+	EventIdMetadataKey          string
 }
 
 // getDefaultPositionsFilePath derives positions file path for given tailed filename
@@ -65,10 +67,11 @@ type Tailer struct {
 	observer                pipeline.EventProcessingDurationObserver
 	lineParseRegexp         *regexp.Regexp
 	emptyGroupRegexp        *regexp.Regexp
-	outputChannel           chan *event.Raw
+	outputChannel           chan event.Raw
 	shutdownChannel         chan struct{}
 	logger                  logrus.FieldLogger
 	done                    bool
+	eventIdMetadataKey      string
 }
 
 func (t *Tailer) String() string {
@@ -150,8 +153,9 @@ func New(config tailerConfig, logger logrus.FieldLogger) (*Tailer, error) {
 		persistPositionInterval: config.PositionPersistenceInterval,
 		lineParseRegexp:         lineParseRegexp,
 		emptyGroupRegexp:        emptyGroupRegexp,
-		outputChannel:           make(chan *event.Raw),
+		outputChannel:           make(chan event.Raw),
 		shutdownChannel:         make(chan struct{}),
+		eventIdMetadataKey:      config.EventIdMetadataKey,
 		done:                    false,
 		logger:                  logger,
 	}, nil
@@ -181,7 +185,7 @@ func (t *Tailer) Done() bool {
 	return t.done
 }
 
-func (t *Tailer) OutputChannel() chan *event.Raw {
+func (t *Tailer) OutputChannel() chan event.Raw {
 	return t.outputChannel
 }
 
@@ -278,8 +282,8 @@ func (t *Tailer) markOffsetPosition() error {
 // parseLine parses the given line, producing a RequestEvent instance
 // - lineParseRegexp is used to parse the line
 // - if content of any of the matched named groups matches emptyGroupRegexp, it is replaced by an empty string ""
-func parseLine(lineParseRegexp *regexp.Regexp, emptyGroupRegexp *regexp.Regexp, line string) (map[string]string, error) {
-	lineData := make(map[string]string)
+func parseLine(lineParseRegexp *regexp.Regexp, emptyGroupRegexp *regexp.Regexp, line string) (stringmap.StringMap, error) {
+	lineData := make(stringmap.StringMap)
 
 	match := lineParseRegexp.FindStringSubmatch(line)
 	if len(match) != len(lineParseRegexp.SubexpNames()) {
@@ -295,10 +299,10 @@ func parseLine(lineParseRegexp *regexp.Regexp, emptyGroupRegexp *regexp.Regexp,
 	return lineData, nil
 }
 
-func (t *Tailer) processLine(line string) (*event.Raw, error) {
+func (t *Tailer) processLine(line string) (event.Raw, error) {
 	lineData, err := parseLine(t.lineParseRegexp, t.emptyGroupRegexp, line)
 	if err != nil {
 		return nil, err
 	}
-	return &event.Raw{Quantity: 1, Metadata: lineData}, nil
+	return event.NewRaw(lineData.Get(t.eventIdMetadataKey, ""), 1, lineData, nil), nil
 }
diff --git a/pkg/tailer/tailer_test.go b/pkg/tailer/tailer_test.go
index f7529f1..bb55ccf 100644
--- a/pkg/tailer/tailer_test.go
+++ b/pkg/tailer/tailer_test.go
@@ -203,9 +203,11 @@ func Test_ParseLineAndBuildEvent(t *testing.T) {
 				continue
 			}
 		}
-		parsedEvent := &event.Raw{Metadata: data}
+		eventId := "xxx"
 
-		var expectedEvent *event.Raw
+		parsedEvent := event.NewRaw(eventId, 1, data, nil)
+
+		var expectedEvent event.Raw
 
 		if test.isLineValid {
 			// line is considered valid, build the expectedEvent struct in order to compare it to the parsed one
@@ -216,7 +218,7 @@ func Test_ParseLineAndBuildEvent(t *testing.T) {
 					delete(test.lineContentMapping, k)
 				}
 			}
-			expectedEvent = &event.Raw{Metadata: test.lineContentMapping}
+			expectedEvent = event.NewRaw(eventId, 1, test.lineContentMapping, nil)
 			if !reflect.DeepEqual(expectedEvent, parsedEvent) {
 				t.Errorf("Unexpected result of parse line: %s\nGot: %+v\nExpected: %+v", requestLine, parsedEvent, expectedEvent)
 			}
@@ -272,7 +274,7 @@ type offsetPersistenceTest struct {
 }
 
 // reads in chan and on close returns count to out chan
-func countEvents(in chan *event.Raw, out chan int) {
+func countEvents(in chan event.Raw, out chan int) {
 	count := 0
 	for range in {
 		count++