Use message processor in router, all sinks and all receivers

receivers/httpReceiver.go

@@ -10,15 +10,16 @@ import (
 	"sync"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-metric-collector/pkg/ccLogger"
 	lp "github.com/ClusterCockpit/cc-energy-manager/pkg/cc-message"
+	cclog "github.com/ClusterCockpit/cc-metric-collector/pkg/ccLogger"
+	mp "github.com/ClusterCockpit/cc-metric-collector/pkg/messageProcessor"
 	influx "github.com/influxdata/line-protocol/v2/lineprotocol"
 )
 
 const HTTP_RECEIVER_PORT = "8080"
 
 type HttpReceiverConfig struct {
-	Type string `json:"type"`
+	defaultReceiverConfig
 	Addr string `json:"address"`
 	Port string `json:"port"`
 	Path string `json:"path"`
@@ -39,7 +40,7 @@ type HttpReceiverConfig struct {
 
 type HttpReceiver struct {
 	receiver
-	meta   map[string]string
+	//meta   map[string]string
 	config HttpReceiverConfig
 	server *http.Server
 	wg     sync.WaitGroup
@@ -85,8 +86,20 @@ func (r *HttpReceiver) Init(name string, config json.RawMessage) error {
 	if r.config.useBasicAuth && len(r.config.Password) == 0 {
 		return errors.New("basic authentication requires password")
 	}
+	msgp, err := mp.NewMessageProcessor()
+	if err != nil {
+		return fmt.Errorf("initialization of message processor failed: %v", err.Error())
+	}
+	r.mp = msgp
+	if len(r.config.MessageProcessor) > 0 {
+		err = r.mp.FromConfigJSON(r.config.MessageProcessor)
+		if err != nil {
+			return fmt.Errorf("failed parsing JSON for message processor: %v", err.Error())
+		}
+	}
+	r.mp.AddAddMetaByCondition("true", "source", r.name)
 
-	r.meta = map[string]string{"source": r.name}
+	//r.meta = map[string]string{"source": r.name}
 	p := r.config.Path
 	if !strings.HasPrefix(p, "/") {
 		p = "/" + p
@@ -137,80 +150,82 @@ func (r *HttpReceiver) ServerHttp(w http.ResponseWriter, req *http.Request) {
 			return
 		}
 	}
+	if r.sink != nil {
+		d := influx.NewDecoder(req.Body)
+		for d.Next() {
 
-	d := influx.NewDecoder(req.Body)
-	for d.Next() {
-
-		// Decode measurement name
-		measurement, err := d.Measurement()
-		if err != nil {
-			msg := "ServerHttp: Failed to decode measurement: " + err.Error()
-			cclog.ComponentError(r.name, msg)
-			http.Error(w, msg, http.StatusInternalServerError)
-			return
-		}
-
-		// Decode tags
-		tags := make(map[string]string)
-		for {
-			key, value, err := d.NextTag()
+			// Decode measurement name
+			measurement, err := d.Measurement()
 			if err != nil {
-				msg := "ServerHttp: Failed to decode tag: " + err.Error()
+				msg := "ServerHttp: Failed to decode measurement: " + err.Error()
 				cclog.ComponentError(r.name, msg)
 				http.Error(w, msg, http.StatusInternalServerError)
 				return
 			}
-			if key == nil {
-				break
-			}
-			tags[string(key)] = string(value)
-		}
 
-		// Decode fields
-		fields := make(map[string]interface{})
-		for {
-			key, value, err := d.NextField()
+			// Decode tags
+			tags := make(map[string]string)
+			for {
+				key, value, err := d.NextTag()
+				if err != nil {
+					msg := "ServerHttp: Failed to decode tag: " + err.Error()
+					cclog.ComponentError(r.name, msg)
+					http.Error(w, msg, http.StatusInternalServerError)
+					return
+				}
+				if key == nil {
+					break
+				}
+				tags[string(key)] = string(value)
+			}
+
+			// Decode fields
+			fields := make(map[string]interface{})
+			for {
+				key, value, err := d.NextField()
+				if err != nil {
+					msg := "ServerHttp: Failed to decode field: " + err.Error()
+					cclog.ComponentError(r.name, msg)
+					http.Error(w, msg, http.StatusInternalServerError)
+					return
+				}
+				if key == nil {
+					break
+				}
+				fields[string(key)] = value.Interface()
+			}
+
+			// Decode time stamp
+			t, err := d.Time(influx.Nanosecond, time.Time{})
 			if err != nil {
-				msg := "ServerHttp: Failed to decode field: " + err.Error()
+				msg := "ServerHttp: Failed to decode time stamp: " + err.Error()
 				cclog.ComponentError(r.name, msg)
 				http.Error(w, msg, http.StatusInternalServerError)
 				return
 			}
-			if key == nil {
-				break
-			}
-			fields[string(key)] = value.Interface()
-		}
 
-		// Decode time stamp
-		t, err := d.Time(influx.Nanosecond, time.Time{})
+			y, _ := lp.NewMessage(
+				string(measurement),
+				tags,
+				nil,
+				fields,
+				t,
+			)
+
+			m, err := r.mp.ProcessMessage(y)
+			if err == nil && m != nil {
+				r.sink <- m
+			}
+
+		}
+		// Check for IO errors
+		err := d.Err()
 		if err != nil {
-			msg := "ServerHttp: Failed to decode time stamp: " + err.Error()
+			msg := "ServerHttp: Failed to decode: " + err.Error()
 			cclog.ComponentError(r.name, msg)
 			http.Error(w, msg, http.StatusInternalServerError)
 			return
 		}
-
-		y, _ := lp.NewMessage(
-			string(measurement),
-			tags,
-			r.meta,
-			fields,
-			t,
-		)
-
-		if r.sink != nil {
-			r.sink <- y
-		}
-	}
-
-	// Check for IO errors
-	err := d.Err()
-	if err != nil {
-		msg := "ServerHttp: Failed to decode: " + err.Error()
-		cclog.ComponentError(r.name, msg)
-		http.Error(w, msg, http.StatusInternalServerError)
-		return
 	}
 
 	w.WriteHeader(http.StatusOK)

receivers/ipmiReceiver.go

@@ -13,9 +13,10 @@ import (
 	"sync"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-metric-collector/pkg/ccLogger"
 	lp "github.com/ClusterCockpit/cc-energy-manager/pkg/cc-message"
+	cclog "github.com/ClusterCockpit/cc-metric-collector/pkg/ccLogger"
 	"github.com/ClusterCockpit/cc-metric-collector/pkg/hostlist"
+	mp "github.com/ClusterCockpit/cc-metric-collector/pkg/messageProcessor"
 )
 
 type IPMIReceiverClientConfig struct {
@@ -31,11 +32,13 @@ type IPMIReceiverClientConfig struct {
 	Password         string            // Password to use for authentication
 	CLIOptions       []string          // Additional command line options for ipmi-sensors
 	isExcluded       map[string]bool   // is metric excluded
+	mp               mp.MessageProcessor
 }
 
 type IPMIReceiver struct {
 	receiver
 	config struct {
+		defaultReceiverConfig
 		Interval time.Duration
 
 		// Client config for each IPMI hosts
@@ -43,10 +46,11 @@ type IPMIReceiver struct {
 	}
 
 	// Storage for static information
-	meta map[string]string
+	//meta map[string]string
 
 	done chan bool      // channel to finish / stop IPMI receiver
 	wg   sync.WaitGroup // wait group for IPMI receiver
+	mp   mp.MessageProcessor
 }
 
 // doReadMetrics reads metrics from all configure IPMI hosts.
@@ -230,7 +234,14 @@ func (r *IPMIReceiver) doReadMetric() {
 					},
 					time.Now())
 				if err == nil {
-					r.sink <- y
+					mc, err := clientConfig.mp.ProcessMessage(y)
+					if err == nil && mc != nil {
+						m, err := r.mp.ProcessMessage(mc)
+						if err == nil && m != nil {
+							r.sink <- m
+						}
+					}
+
 				}
 			}
 
@@ -296,11 +307,12 @@ func (r *IPMIReceiver) Close() {
 // NewIPMIReceiver creates a new instance of the redfish receiver
 // Initialize the receiver by giving it a name and reading in the config JSON
 func NewIPMIReceiver(name string, config json.RawMessage) (Receiver, error) {
+	var err error
 	r := new(IPMIReceiver)
 
 	// Config options from config file
 	configJSON := struct {
-		Type string `json:"type"`
+		defaultReceiverConfig
 
 		// How often the IPMI sensor metrics should be read and send to the sink (default: 30 s)
 		IntervalString string `json:"interval,omitempty"`
@@ -331,7 +343,8 @@ func NewIPMIReceiver(name string, config json.RawMessage) (Receiver, error) {
 			ExcludeMetrics []string `json:"exclude_metrics,omitempty"`
 
 			// Additional command line options for ipmi-sensors
-			CLIOptions []string `json:"cli_options,omitempty"`
+			CLIOptions       []string        `json:"cli_options,omitempty"`
+			MessageProcessor json.RawMessage `json:"process_messages,omitempty"`
 		} `json:"client_config"`
 	}{
 		// Set defaults values
@@ -347,8 +360,15 @@ func NewIPMIReceiver(name string, config json.RawMessage) (Receiver, error) {
 	// Create done channel
 	r.done = make(chan bool)
 
+	p, err := mp.NewMessageProcessor()
+	if err != nil {
+		return nil, fmt.Errorf("initialization of message processor failed: %v", err.Error())
+	}
+	r.mp = p
+
 	// Set static information
-	r.meta = map[string]string{"source": r.name}
+	//r.meta = map[string]string{"source": r.name}
+	r.mp.AddAddMetaByCondition("true", "source", r.name)
 
 	// Read the IPMI receiver specific JSON config
 	if len(config) > 0 {
@@ -360,12 +380,18 @@ func NewIPMIReceiver(name string, config json.RawMessage) (Receiver, error) {
 		}
 	}
 
+	if len(r.config.MessageProcessor) > 0 {
+		err = r.mp.FromConfigJSON(r.config.MessageProcessor)
+		if err != nil {
+			return nil, fmt.Errorf("failed parsing JSON for message processor: %v", err.Error())
+		}
+	}
 	// Convert interval string representation to duration
-	var err error
+
 	r.config.Interval, err = time.ParseDuration(configJSON.IntervalString)
 	if err != nil {
 		err := fmt.Errorf(
-			"Failed to parse duration string interval='%s': %w",
+			"failed to parse duration string interval='%s': %w",
 			configJSON.IntervalString,
 			err,
 		)
@@ -506,6 +532,16 @@ func NewIPMIReceiver(name string, config json.RawMessage) (Receiver, error) {
 		for _, key := range configJSON.ExcludeMetrics {
 			isExcluded[key] = true
 		}
+		p, err := mp.NewMessageProcessor()
+		if err != nil {
+			return nil, fmt.Errorf("initialization of message processor failed: %v", err.Error())
+		}
+		if len(clientConfigJSON.MessageProcessor) > 0 {
+			err = p.FromConfigJSON(clientConfigJSON.MessageProcessor)
+			if err != nil {
+				return nil, fmt.Errorf("failed parsing JSON for message processor: %v", err.Error())
+			}
+		}
 
 		r.config.ClientConfigs = append(
 			r.config.ClientConfigs,
@@ -520,6 +556,7 @@ func NewIPMIReceiver(name string, config json.RawMessage) (Receiver, error) {
 				Password:         password,
 				CLIOptions:       cliOptions,
 				isExcluded:       isExcluded,
+				mp:               p,
 			})
 	}
 

receivers/metricReceiver.go

@@ -1,11 +1,15 @@
 package receivers
 
 import (
+	"encoding/json"
+
 	lp "github.com/ClusterCockpit/cc-energy-manager/pkg/cc-message"
+	mp "github.com/ClusterCockpit/cc-metric-collector/pkg/messageProcessor"
 )
 
 type defaultReceiverConfig struct {
-	Type string `json:"type"`
+	Type             string          `json:"type"`
+	MessageProcessor json.RawMessage `json:"process_messages,omitempty"`
 }
 
 // Receiver configuration: Listen address, port
@@ -20,12 +24,13 @@ type ReceiverConfig struct {
 type receiver struct {
 	name string
 	sink chan lp.CCMessage
+	mp   mp.MessageProcessor
 }
 
 type Receiver interface {
 	Start()
-	Close()                        // Close / finish metric receiver
-	Name() string                  // Name of the metric receiver
+	Close()                         // Close / finish metric receiver
+	Name() string                   // Name of the metric receiver
 	SetSink(sink chan lp.CCMessage) // Set sink channel
 }
 

receivers/natsReceiver.go

@@ -6,14 +6,15 @@ import (
 	"fmt"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-metric-collector/pkg/ccLogger"
 	lp "github.com/ClusterCockpit/cc-energy-manager/pkg/cc-message"
+	cclog "github.com/ClusterCockpit/cc-metric-collector/pkg/ccLogger"
+	mp "github.com/ClusterCockpit/cc-metric-collector/pkg/messageProcessor"
 	influx "github.com/influxdata/line-protocol/v2/lineprotocol"
 	nats "github.com/nats-io/nats.go"
 )
 
 type NatsReceiverConfig struct {
-	Type    string `json:"type"`
+	defaultReceiverConfig
 	Addr    string `json:"address"`
 	Port    string `json:"port"`
 	Subject string `json:"subject"`
@@ -21,8 +22,8 @@ type NatsReceiverConfig struct {
 
 type NatsReceiver struct {
 	receiver
-	nc     *nats.Conn
-	meta   map[string]string
+	nc *nats.Conn
+	//meta   map[string]string
 	config NatsReceiverConfig
 }
 
@@ -36,65 +37,68 @@ func (r *NatsReceiver) Start() {
 // _NatsReceive receives subscribed messages from the NATS server
 func (r *NatsReceiver) _NatsReceive(m *nats.Msg) {
 
-	d := influx.NewDecoderWithBytes(m.Data)
-	for d.Next() {
+	if r.sink != nil {
+		d := influx.NewDecoderWithBytes(m.Data)
+		for d.Next() {
 
-		// Decode measurement name
-		measurement, err := d.Measurement()
-		if err != nil {
-			msg := "_NatsReceive: Failed to decode measurement: " + err.Error()
-			cclog.ComponentError(r.name, msg)
-			return
-		}
-
-		// Decode tags
-		tags := make(map[string]string)
-		for {
-			key, value, err := d.NextTag()
+			// Decode measurement name
+			measurement, err := d.Measurement()
 			if err != nil {
-				msg := "_NatsReceive: Failed to decode tag: " + err.Error()
+				msg := "_NatsReceive: Failed to decode measurement: " + err.Error()
 				cclog.ComponentError(r.name, msg)
 				return
 			}
-			if key == nil {
-				break
-			}
-			tags[string(key)] = string(value)
-		}
 
-		// Decode fields
-		fields := make(map[string]interface{})
-		for {
-			key, value, err := d.NextField()
+			// Decode tags
+			tags := make(map[string]string)
+			for {
+				key, value, err := d.NextTag()
+				if err != nil {
+					msg := "_NatsReceive: Failed to decode tag: " + err.Error()
+					cclog.ComponentError(r.name, msg)
+					return
+				}
+				if key == nil {
+					break
+				}
+				tags[string(key)] = string(value)
+			}
+
+			// Decode fields
+			fields := make(map[string]interface{})
+			for {
+				key, value, err := d.NextField()
+				if err != nil {
+					msg := "_NatsReceive: Failed to decode field: " + err.Error()
+					cclog.ComponentError(r.name, msg)
+					return
+				}
+				if key == nil {
+					break
+				}
+				fields[string(key)] = value.Interface()
+			}
+
+			// Decode time stamp
+			t, err := d.Time(influx.Nanosecond, time.Time{})
 			if err != nil {
-				msg := "_NatsReceive: Failed to decode field: " + err.Error()
+				msg := "_NatsReceive: Failed to decode time: " + err.Error()
 				cclog.ComponentError(r.name, msg)
 				return
 			}
-			if key == nil {
-				break
+
+			y, _ := lp.NewMessage(
+				string(measurement),
+				tags,
+				nil,
+				fields,
+				t,
+			)
+
+			m, err := r.mp.ProcessMessage(y)
+			if err == nil && m != nil {
+				r.sink <- m
 			}
-			fields[string(key)] = value.Interface()
-		}
-
-		// Decode time stamp
-		t, err := d.Time(influx.Nanosecond, time.Time{})
-		if err != nil {
-			msg := "_NatsReceive: Failed to decode time: " + err.Error()
-			cclog.ComponentError(r.name, msg)
-			return
-		}
-
-		y, _ := lp.NewMessage(
-			string(measurement),
-			tags,
-			r.meta,
-			fields,
-			t,
-		)
-
-		if r.sink != nil {
-			r.sink <- y
 		}
 	}
 }
@@ -127,11 +131,23 @@ func NewNatsReceiver(name string, config json.RawMessage) (Receiver, error) {
 		len(r.config.Subject) == 0 {
 		return nil, errors.New("not all configuration variables set required by NatsReceiver")
 	}
+	p, err := mp.NewMessageProcessor()
+	if err != nil {
+		return nil, fmt.Errorf("initialization of message processor failed: %v", err.Error())
+	}
+	r.mp = p
+	if len(r.config.MessageProcessor) > 0 {
+		err = r.mp.FromConfigJSON(r.config.MessageProcessor)
+		if err != nil {
+			return nil, fmt.Errorf("failed parsing JSON for message processor: %v", err.Error())
+		}
+	}
 
 	// Set metadata
-	r.meta = map[string]string{
-		"source": r.name,
-	}
+	// r.meta = map[string]string{
+	// 	"source": r.name,
+	// }
+	r.mp.AddAddMetaByCondition("true", "source", r.name)
 
 	// Connect to NATS server
 	url := fmt.Sprintf("nats://%s:%s", r.config.Addr, r.config.Port)

receivers/redfishReceiver.go

@@ -13,9 +13,10 @@ import (
 	"sync"
 	"time"
 
-	cclog "github.com/ClusterCockpit/cc-metric-collector/pkg/ccLogger"
 	lp "github.com/ClusterCockpit/cc-energy-manager/pkg/cc-message"
+	cclog "github.com/ClusterCockpit/cc-metric-collector/pkg/ccLogger"
 	"github.com/ClusterCockpit/cc-metric-collector/pkg/hostlist"
+	mp "github.com/ClusterCockpit/cc-metric-collector/pkg/messageProcessor"
 
 	// See: https://pkg.go.dev/github.com/stmcginnis/gofish
 	"github.com/stmcginnis/gofish"
@@ -42,6 +43,8 @@ type RedfishReceiverClientConfig struct {
 	readSensorURLs map[string][]string
 
 	gofish gofish.ClientConfig
+
+	mp mp.MessageProcessor
 }
 
 // RedfishReceiver configuration:
@@ -49,6 +52,7 @@ type RedfishReceiver struct {
 	receiver
 
 	config struct {
+		defaultReceiverConfig
 		fanout      int
 		Interval    time.Duration
 		HttpTimeout time.Duration
@@ -79,13 +83,19 @@ func setMetricValue(value any) map[string]interface{} {
 }
 
 // sendMetric sends the metric through the sink channel
-func (r *RedfishReceiver) sendMetric(name string, tags map[string]string, meta map[string]string, value any, timestamp time.Time) {
+func (r *RedfishReceiver) sendMetric(mp mp.MessageProcessor, name string, tags map[string]string, meta map[string]string, value any, timestamp time.Time) {
 
 	deleteEmptyTags(tags)
 	deleteEmptyTags(meta)
 	y, err := lp.NewMessage(name, tags, meta, setMetricValue(value), timestamp)
 	if err == nil {
-		r.sink <- y
+		mc, err := mp.ProcessMessage(y)
+		if err == nil && mc != nil {
+			m, err := r.mp.ProcessMessage(mc)
+			if err == nil && m != nil {
+				r.sink <- m
+			}
+		}
 	}
 }
 
@@ -119,7 +129,7 @@ func (r *RedfishReceiver) readSensors(
 			"unit":   "degC",
 		}
 
-		r.sendMetric("temperature", tags, meta, sensor.Reading, time.Now())
+		r.sendMetric(clientConfig.mp, "temperature", tags, meta, sensor.Reading, time.Now())
 	}
 
 	writeFanSpeedSensor := func(sensor *redfish.Sensor) {
@@ -145,7 +155,7 @@ func (r *RedfishReceiver) readSensors(
 			"unit":   string(sensor.ReadingUnits),
 		}
 
-		r.sendMetric("fan_speed", tags, meta, sensor.Reading, time.Now())
+		r.sendMetric(clientConfig.mp, "fan_speed", tags, meta, sensor.Reading, time.Now())
 	}
 
 	writePowerSensor := func(sensor *redfish.Sensor) {
@@ -172,7 +182,7 @@ func (r *RedfishReceiver) readSensors(
 			"unit":   "watts",
 		}
 
-		r.sendMetric("power", tags, meta, sensor.Reading, time.Now())
+		r.sendMetric(clientConfig.mp, "power", tags, meta, sensor.Reading, time.Now())
 	}
 
 	if _, ok := clientConfig.readSensorURLs[chassis.ID]; !ok {
@@ -340,7 +350,7 @@ func (r *RedfishReceiver) readThermalMetrics(
 		// ReadingCelsius shall be the current value of the temperature sensor's reading.
 		value := temperature.ReadingCelsius
 
-		r.sendMetric("temperature", tags, meta, value, timestamp)
+		r.sendMetric(clientConfig.mp, "temperature", tags, meta, value, timestamp)
 	}
 
 	for _, fan := range thermal.Fans {
@@ -381,7 +391,7 @@ func (r *RedfishReceiver) readThermalMetrics(
 			"unit":   string(fan.ReadingUnits),
 		}
 
-		r.sendMetric("fan_speed", tags, meta, fan.Reading, timestamp)
+		r.sendMetric(clientConfig.mp, "fan_speed", tags, meta, fan.Reading, timestamp)
 	}
 
 	return nil
@@ -479,7 +489,7 @@ func (r *RedfishReceiver) readPowerMetrics(
 		}
 
 		for name, value := range metrics {
-			r.sendMetric(name, tags, meta, value, timestamp)
+			r.sendMetric(clientConfig.mp, name, tags, meta, value, timestamp)
 		}
 	}
 
@@ -561,7 +571,7 @@ func (r *RedfishReceiver) readProcessorMetrics(
 	if !clientConfig.isExcluded[namePower] &&
 		// Some servers return "ConsumedPowerWatt":65535 instead of "ConsumedPowerWatt":null
 		processorMetrics.ConsumedPowerWatt != 65535 {
-		r.sendMetric(namePower, tags, metaPower, processorMetrics.ConsumedPowerWatt, timestamp)
+		r.sendMetric(clientConfig.mp, namePower, tags, metaPower, processorMetrics.ConsumedPowerWatt, timestamp)
 	}
 	// Set meta data tags
 	metaThermal := map[string]string{
@@ -573,7 +583,7 @@ func (r *RedfishReceiver) readProcessorMetrics(
 	nameThermal := "temperature"
 
 	if !clientConfig.isExcluded[nameThermal] {
-		r.sendMetric(nameThermal, tags, metaThermal, processorMetrics.TemperatureCelsius, timestamp)
+		r.sendMetric(clientConfig.mp, nameThermal, tags, metaThermal, processorMetrics.TemperatureCelsius, timestamp)
 	}
 	return nil
 }
@@ -776,11 +786,13 @@ func (r *RedfishReceiver) Close() {
 // NewRedfishReceiver creates a new instance of the redfish receiver
 // Initialize the receiver by giving it a name and reading in the config JSON
 func NewRedfishReceiver(name string, config json.RawMessage) (Receiver, error) {
+	var err error
 	r := new(RedfishReceiver)
 
 	// Config options from config file
 	configJSON := struct {
-		Type string `json:"type"`
+		Type             string          `json:"type"`
+		MessageProcessor json.RawMessage `json:"process_messages,omitempty"`
 
 		// Maximum number of simultaneous redfish connections (default: 64)
 		Fanout int `json:"fanout,omitempty"`
@@ -820,7 +832,8 @@ func NewRedfishReceiver(name string, config json.RawMessage) (Receiver, error) {
 			DisableThermalMetrics   bool `json:"disable_thermal_metrics"`
 
 			// Per client excluded metrics
-			ExcludeMetrics []string `json:"exclude_metrics,omitempty"`
+			ExcludeMetrics   []string        `json:"exclude_metrics,omitempty"`
+			MessageProcessor json.RawMessage `json:"process_messages,omitempty"`
 		} `json:"client_config"`
 	}{
 		// Set defaults values
@@ -846,13 +859,24 @@ func NewRedfishReceiver(name string, config json.RawMessage) (Receiver, error) {
 			return nil, err
 		}
 	}
+	p, err := mp.NewMessageProcessor()
+	if err != nil {
+		return nil, fmt.Errorf("initialization of message processor failed: %v", err.Error())
+	}
+	r.mp = p
+	if len(r.config.MessageProcessor) > 0 {
+		err = r.mp.FromConfigJSON(r.config.MessageProcessor)
+		if err != nil {
+			return nil, fmt.Errorf("failed parsing JSON for message processor: %v", err.Error())
+		}
+	}
 
 	// Convert interval string representation to duration
-	var err error
+
 	r.config.Interval, err = time.ParseDuration(configJSON.IntervalString)
 	if err != nil {
 		err := fmt.Errorf(
-			"Failed to parse duration string interval='%s': %w",
+			"failed to parse duration string interval='%s': %w",
 			configJSON.IntervalString,
 			err,
 		)
@@ -864,7 +888,7 @@ func NewRedfishReceiver(name string, config json.RawMessage) (Receiver, error) {
 	r.config.HttpTimeout, err = time.ParseDuration(configJSON.HttpTimeoutString)
 	if err != nil {
 		err := fmt.Errorf(
-			"Failed to parse duration string http_timeout='%s': %w",
+			"failed to parse duration string http_timeout='%s': %w",
 			configJSON.HttpTimeoutString,
 			err,
 		)
@@ -948,6 +972,18 @@ func NewRedfishReceiver(name string, config json.RawMessage) (Receiver, error) {
 		for _, key := range configJSON.ExcludeMetrics {
 			isExcluded[key] = true
 		}
+		p, err = mp.NewMessageProcessor()
+		if err != nil {
+			cclog.ComponentError(r.name, err.Error())
+			return nil, err
+		}
+		if len(clientConfigJSON.MessageProcessor) > 0 {
+			err = p.FromConfigJSON(clientConfigJSON.MessageProcessor)
+			if err != nil {
+				cclog.ComponentError(r.name, err.Error())
+				return nil, err
+			}
+		}
 
 		hostList, err := hostlist.Expand(clientConfigJSON.HostList)
 		if err != nil {
@@ -978,6 +1014,7 @@ func NewRedfishReceiver(name string, config json.RawMessage) (Receiver, error) {
 						Endpoint:   endpoint,
 						HTTPClient: httpClient,
 					},
+					mp: p,
 				})
 		}
 
@@ -1002,7 +1039,7 @@ func NewRedfishReceiver(name string, config json.RawMessage) (Receiver, error) {
 	for i := range r.config.ClientConfigs {
 		host := r.config.ClientConfigs[i].Hostname
 		if isDuplicate[host] {
-			err := fmt.Errorf("Found duplicate client config for host %s", host)
+			err := fmt.Errorf("found duplicate client config for host %s", host)
 			cclog.ComponentError(r.name, err)
 			return nil, err
 		}

receivers/sampleReceiver.go

@@ -5,11 +5,13 @@ import (
 	"fmt"
 
 	cclog "github.com/ClusterCockpit/cc-metric-collector/pkg/ccLogger"
+	mp "github.com/ClusterCockpit/cc-metric-collector/pkg/messageProcessor"
 )
 
 // SampleReceiver configuration: receiver type, listen address, port
+// The defaultReceiverConfig contains the keys 'type' and 'process_messages'
 type SampleReceiverConfig struct {
-	Type string `json:"type"`
+	defaultReceiverConfig
 	Addr string `json:"address"`
 	Port string `json:"port"`
 }
@@ -19,7 +21,6 @@ type SampleReceiver struct {
 	config SampleReceiverConfig
 
 	// Storage for static information
-	meta map[string]string
 	// Use in case of own go routine
 	// done chan bool
 	// wg   sync.WaitGroup
@@ -79,8 +80,19 @@ func NewSampleReceiver(name string, config json.RawMessage) (Receiver, error) {
 	// The name should be chosen in such a way that different instances of SampleReceiver can be distinguished
 	r.name = fmt.Sprintf("SampleReceiver(%s)", name)
 
+	// create new message processor
+	p, err := mp.NewMessageProcessor()
+	if err != nil {
+		cclog.ComponentError(r.name, "Initialization of message processor failed:", err.Error())
+		return nil, fmt.Errorf("initialization of message processor failed: %v", err.Error())
+	}
+	r.mp = p
 	// Set static information
-	r.meta = map[string]string{"source": r.name}
+	err = r.mp.AddAddMetaByCondition("true", "source", r.name)
+	if err != nil {
+		cclog.ComponentError(r.name, fmt.Sprintf("Failed to add static information source=%s:", r.name), err.Error())
+		return nil, fmt.Errorf("failed to add static information source=%s: %v", r.name, err.Error())
+	}
 
 	// Set defaults in r.config
 	// Allow overwriting these defaults by reading config JSON
@@ -94,6 +106,15 @@ func NewSampleReceiver(name string, config json.RawMessage) (Receiver, error) {
 		}
 	}
 
+	// Add message processor config
+	if len(r.config.MessageProcessor) > 0 {
+		err = r.mp.FromConfigJSON(r.config.MessageProcessor)
+		if err != nil {
+			cclog.ComponentError(r.name, "Failed parsing JSON for message processor:", err.Error())
+			return nil, fmt.Errorf("failed parsing JSON for message processor: %v", err.Error())
+		}
+	}
+
 	// Check that all required fields in the configuration are set
 	// Use 'if len(r.config.Option) > 0' for strings