You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2023/06/15 09:58:04 UTC
[plc4x] branch develop updated: feat(plc4go): hook in WithPassLoggerToModel option
This is an automated email from the ASF dual-hosted git repository.
sruehl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
The following commit(s) were added to refs/heads/develop by this push:
new 0a77277f79 feat(plc4go): hook in WithPassLoggerToModel option
0a77277f79 is described below
commit 0a77277f7998e5e1664d06d7ab37fbe0731e7eb3
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Thu Jun 15 11:57:56 2023 +0200
feat(plc4go): hook in WithPassLoggerToModel option
---
plc4go/internal/ads/Connection.go | 17 ++++++++++-------
plc4go/internal/ads/Discoverer.go | 9 ++++++---
plc4go/internal/ads/DiscoveryMessageCodec.go | 9 ++++++---
plc4go/internal/bacnetip/ApplicationLayer.go | 14 ++++++++++++--
plc4go/internal/bacnetip/Discoverer.go | 14 ++++++++++----
plc4go/internal/bacnetip/MessageCodec.go | 8 +++++++-
plc4go/internal/bacnetip/UDPCommunicationsModule.go | 8 +++++++-
plc4go/internal/cbus/MessageCodec.go | 17 +++++++++++------
plc4go/internal/knxnetip/Browser.go | 15 ++++++++++-----
plc4go/internal/knxnetip/Connection.go | 4 +++-
.../knxnetip/ConnectionDriverSpecificOperations.go | 7 +++++--
plc4go/internal/knxnetip/ConnectionHelper.go | 7 +++++--
.../knxnetip/ConnectionInternalOperations.go | 13 +++++++++----
plc4go/internal/knxnetip/MessageCodec.go | 7 +++++--
plc4go/internal/knxnetip/Subscriber.go | 13 ++++++++-----
plc4go/internal/knxnetip/SubscriptionEvent.go | 16 +++++++++++-----
plc4go/internal/knxnetip/Utils.go | 8 ++++----
plc4go/internal/modbus/MessageCodec.go | 7 +++++--
plc4go/internal/modbus/Reader.go | 7 +++++--
plc4go/internal/s7/Driver.go | 2 +-
plc4go/internal/s7/MessageCodec.go | 9 ++++++---
plc4go/internal/s7/Reader.go | 15 +++++++++------
plc4go/internal/s7/TagHandler.go | 13 +++++++++++--
plc4go/internal/simulated/Device.go | 13 ++++++++-----
plc4go/spi/options/Option.go | 21 ++++++++++++++++-----
25 files changed, 190 insertions(+), 83 deletions(-)
diff --git a/plc4go/internal/ads/Connection.go b/plc4go/internal/ads/Connection.go
index a0c2615562..f94b71ee41 100644
--- a/plc4go/internal/ads/Connection.go
+++ b/plc4go/internal/ads/Connection.go
@@ -56,7 +56,8 @@ type Connection struct {
subscriptions map[uint32]apiModel.PlcSubscriptionHandle
- log zerolog.Logger
+ passLogToModel bool
+ log zerolog.Logger
}
func NewConnection(messageCodec spi.MessageCodec, configuration model.Configuration, connectionOptions map[string][]string, _options ...options.WithOption) (*Connection, error) {
@@ -65,11 +66,12 @@ func NewConnection(messageCodec spi.MessageCodec, configuration model.Configurat
return nil, err
}
connection := &Connection{
- messageCodec: messageCodec,
- configuration: configuration,
- driverContext: driverContext,
- subscriptions: map[uint32]apiModel.PlcSubscriptionHandle{},
- log: options.ExtractCustomLogger(_options...),
+ messageCodec: messageCodec,
+ configuration: configuration,
+ driverContext: driverContext,
+ subscriptions: map[uint32]apiModel.PlcSubscriptionHandle{},
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
+ log: options.ExtractCustomLogger(_options...),
}
if traceEnabledOption, ok := connectionOptions["traceEnabled"]; ok {
if len(traceEnabledOption) == 1 {
@@ -261,7 +263,8 @@ func (m *Connection) readDataTypeTableAndSymbolTableSizes(ctx context.Context) (
}
// Parse and process the response
- tableSizes, err := readWriteModel.AdsTableSizesParse(ctx, response.GetData())
+ ctxForModel := options.GetLoggerContextForModel(ctx, m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ tableSizes, err := readWriteModel.AdsTableSizesParse(ctxForModel, response.GetData())
if err != nil {
return nil, fmt.Errorf("error parsing table: %v", err)
}
diff --git a/plc4go/internal/ads/Discoverer.go b/plc4go/internal/ads/Discoverer.go
index 0519056ff1..dc3ea8e12f 100644
--- a/plc4go/internal/ads/Discoverer.go
+++ b/plc4go/internal/ads/Discoverer.go
@@ -48,12 +48,14 @@ type discovery struct {
}
type Discoverer struct {
- log zerolog.Logger
+ passLogToModel bool
+ log zerolog.Logger
}
func NewDiscoverer(_options ...options.WithOption) *Discoverer {
return &Discoverer{
- log: options.ExtractCustomLogger(_options...),
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
+ log: options.ExtractCustomLogger(_options...),
}
}
@@ -155,7 +157,8 @@ func (d *Discoverer) Discover(ctx context.Context, callback func(event apiModel.
if length == 0 {
continue
}
- discoveryResponse, err := model.AdsDiscoveryParse(ctx, buf[0:length])
+ ctxForModel := options.GetLoggerContextForModel(ctx, d.log, options.WithPassLoggerToModel(d.passLogToModel))
+ discoveryResponse, err := model.AdsDiscoveryParse(ctxForModel, buf[0:length])
if err != nil {
d.log.Error().Err(err).Str("src-ip", fromAddr.String()).Msg("error decoding response")
continue
diff --git a/plc4go/internal/ads/DiscoveryMessageCodec.go b/plc4go/internal/ads/DiscoveryMessageCodec.go
index 3a9f120f70..d322070108 100644
--- a/plc4go/internal/ads/DiscoveryMessageCodec.go
+++ b/plc4go/internal/ads/DiscoveryMessageCodec.go
@@ -34,12 +34,14 @@ import (
type DiscoveryMessageCodec struct {
_default.DefaultCodec
- log zerolog.Logger
+ passLogToModel bool
+ log zerolog.Logger
}
func NewDiscoveryMessageCodec(transportInstance transports.TransportInstance, _options ...options.WithOption) *DiscoveryMessageCodec {
codec := &DiscoveryMessageCodec{
- log: options.ExtractCustomLogger(_options...),
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
+ log: options.ExtractCustomLogger(_options...),
}
codec.DefaultCodec = _default.NewDefaultCodec(codec, transportInstance, _options...)
return codec
@@ -88,7 +90,8 @@ func (m *DiscoveryMessageCodec) Receive() (spi.Message, error) {
// TODO: Possibly clean up ...
return nil, nil
}
- tcpPacket, err := model.AdsDiscoveryParse(context.TODO(), data)
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ tcpPacket, err := model.AdsDiscoveryParse(ctxForModel, data)
if err != nil {
m.log.Warn().Err(err).Msg("error parsing")
// TODO: Possibly clean up ...
diff --git a/plc4go/internal/bacnetip/ApplicationLayer.go b/plc4go/internal/bacnetip/ApplicationLayer.go
index 792ae36f85..5249da3866 100644
--- a/plc4go/internal/bacnetip/ApplicationLayer.go
+++ b/plc4go/internal/bacnetip/ApplicationLayer.go
@@ -21,6 +21,8 @@ package bacnetip
import (
"context"
+ "github.com/apache/plc4x/plc4go/spi/options"
+ "github.com/rs/zerolog"
"time"
readWriteModel "github.com/apache/plc4x/plc4go/protocols/bacnetip/readwrite/model"
@@ -389,6 +391,9 @@ func (s *SSM) fillWindow(sequenceNumber uint8) error {
type ClientSSM struct {
*SSM
+
+ passLogToModel bool
+ log zerolog.Logger
}
func NewClientSSM(sap SSMSAPRequirements, pduAddress *Address) (*ClientSSM, error) {
@@ -927,7 +932,8 @@ func (c *ClientSSM) segmentedConfirmation(apdu _PDU) error {
}
// TODO: this is nonsense... We need to parse the service and the apdu not sure where to get it from now...
// TODO: it should be the original apdu, we might just need to use that as base and forward it as non segmented
- parse, err := readWriteModel.APDUParse(context.TODO(), c.segmentAPDU.serviceBytes, uint16(len(c.segmentAPDU.serviceBytes)))
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), c.log, options.WithPassLoggerToModel(c.passLogToModel))
+ parse, err := readWriteModel.APDUParse(ctxForModel, c.segmentAPDU.serviceBytes, uint16(len(c.segmentAPDU.serviceBytes)))
if err != nil {
return errors.Wrap(err, "error parsing apdu")
}
@@ -965,6 +971,9 @@ func (c *ClientSSM) segmentedConfirmationTimeout() error {
type ServerSSM struct {
*SSM
segmentedResponseAccepted bool
+
+ passLogToModel bool
+ log zerolog.Logger
}
func NewServerSSM(sap SSMSAPRequirements, pduAddress *Address) (*ServerSSM, error) {
@@ -1391,7 +1400,8 @@ func (s *ServerSSM) segmentedRequest(apdu _PDU) error {
// TODO: here we need to rebuild again yada yada
// TODO: this is nonsense... We need to parse the service and the apdu not sure where to get it from now..
// TODO: it should be the original apdu, we might just need to use that as base and forward it as non segmented
- parse, err := readWriteModel.APDUParse(context.TODO(), s.segmentAPDU.serviceBytes, uint16(len(s.segmentAPDU.serviceBytes)))
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), s.log, options.WithPassLoggerToModel(s.passLogToModel))
+ parse, err := readWriteModel.APDUParse(ctxForModel, s.segmentAPDU.serviceBytes, uint16(len(s.segmentAPDU.serviceBytes)))
if err != nil {
return errors.Wrap(err, "error parsing apdu")
}
diff --git a/plc4go/internal/bacnetip/Discoverer.go b/plc4go/internal/bacnetip/Discoverer.go
index ac7a2c5bec..651cf5dd71 100644
--- a/plc4go/internal/bacnetip/Discoverer.go
+++ b/plc4go/internal/bacnetip/Discoverer.go
@@ -22,6 +22,7 @@ package bacnetip
import (
"context"
"fmt"
+ "github.com/rs/zerolog"
"net"
"net/url"
"strconv"
@@ -42,6 +43,9 @@ import (
type Discoverer struct {
messageCodec spi.MessageCodec
+
+ passLogToModel bool
+ log zerolog.Logger
}
func NewDiscoverer() *Discoverer {
@@ -70,7 +74,7 @@ func (d *Discoverer) Discover(ctx context.Context, callback func(event apiModel.
defer func() {
cancelFunc()
}()
- incomingBVLCChannel, err := broadcastAndDiscover(ctx, communicationChannels, specificOptions)
+ incomingBVLCChannel, err := d.broadcastAndDiscover(ctx, communicationChannels, specificOptions)
if err != nil {
return errors.Wrap(err, "error broadcasting and discovering")
}
@@ -83,7 +87,7 @@ func (d *Discoverer) Discover(ctx context.Context, callback func(event apiModel.
return nil
}
-func broadcastAndDiscover(ctx context.Context, communicationChannels []communicationChannel, specificOptions *protocolSpecificOptions) (chan receivedBvlcMessage, error) {
+func (d *Discoverer) broadcastAndDiscover(ctx context.Context, communicationChannels []communicationChannel, specificOptions *protocolSpecificOptions) (chan receivedBvlcMessage, error) {
incomingBVLCChannel := make(chan receivedBvlcMessage)
for _, communicationChannelInstance := range communicationChannels {
// Prepare the discovery packet data
@@ -167,7 +171,8 @@ func broadcastAndDiscover(ctx context.Context, communicationChannels []communica
return
}
log.Debug().Stringer("addr", addr).Msg("Received broadcast bvlc")
- incomingBvlc, err := driverModel.BVLCParse(ctx, buf[:n])
+ ctxForModel := options.GetLoggerContextForModel(ctx, d.log, options.WithPassLoggerToModel(d.passLogToModel))
+ incomingBvlc, err := driverModel.BVLCParse(ctxForModel, buf[:n])
if err != nil {
log.Warn().Err(err).Msg("Could not parse bvlc")
blockingReadChan <- true
@@ -202,7 +207,8 @@ func broadcastAndDiscover(ctx context.Context, communicationChannels []communica
return
}
log.Debug().Stringer("addr", addr).Msg("Received broadcast bvlc")
- incomingBvlc, err := driverModel.BVLCParse(ctx, buf[:n])
+ ctxForModel := options.GetLoggerContextForModel(ctx, d.log, options.WithPassLoggerToModel(d.passLogToModel))
+ incomingBvlc, err := driverModel.BVLCParse(ctxForModel, buf[:n])
if err != nil {
log.Warn().Err(err).Msg("Could not parse bvlc")
blockingReadChan <- true
diff --git a/plc4go/internal/bacnetip/MessageCodec.go b/plc4go/internal/bacnetip/MessageCodec.go
index f9dea8b273..da4593e45a 100644
--- a/plc4go/internal/bacnetip/MessageCodec.go
+++ b/plc4go/internal/bacnetip/MessageCodec.go
@@ -22,6 +22,8 @@ package bacnetip
import (
"context"
"fmt"
+ "github.com/apache/plc4x/plc4go/spi/options"
+ "github.com/rs/zerolog"
"net"
"net/url"
"time"
@@ -205,6 +207,9 @@ func (m *ApplicationLayerMessageCodec) GetDefaultIncomingMessageChannel() chan s
type MessageCodec struct {
_default.DefaultCodec
+
+ passLogToModel bool
+ log zerolog.Logger
}
func NewMessageCodec(transportInstance transports.TransportInstance) *MessageCodec {
@@ -256,7 +261,8 @@ func (m *MessageCodec) Receive() (spi.Message, error) {
// TODO: Possibly clean up ...
return nil, nil
}
- bvlcPacket, err := model.BVLCParse(context.TODO(), data)
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ bvlcPacket, err := model.BVLCParse(ctxForModel, data)
if err != nil {
log.Warn().Err(err).Msg("error parsing")
// TODO: Possibly clean up ...
diff --git a/plc4go/internal/bacnetip/UDPCommunicationsModule.go b/plc4go/internal/bacnetip/UDPCommunicationsModule.go
index 124a7fb347..b261e6a69a 100644
--- a/plc4go/internal/bacnetip/UDPCommunicationsModule.go
+++ b/plc4go/internal/bacnetip/UDPCommunicationsModule.go
@@ -22,6 +22,8 @@ package bacnetip
import (
"context"
"fmt"
+ "github.com/apache/plc4x/plc4go/spi/options"
+ "github.com/rs/zerolog"
"net"
"time"
@@ -116,6 +118,9 @@ type UDPDirector struct {
request chan _PDU
peers map[string]*UDPActor
running bool
+
+ passLogToModel bool
+ log zerolog.Logger
}
func NewUDPDirector(address AddressTuple[string, uint16], timeout *int, reuse *bool, sid *int, sapID *int) (*UDPDirector, error) {
@@ -257,7 +262,8 @@ func (d *UDPDirector) handleRead() {
sourceAddr = addr
}
- bvlc, err := model.BVLCParse(context.TODO(), readBytes)
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), d.log, options.WithPassLoggerToModel(d.passLogToModel))
+ bvlc, err := model.BVLCParse(ctxForModel, readBytes)
if err != nil {
// pass along to a handler
d.handleError(errors.Wrap(err, "error parsing bvlc"))
diff --git a/plc4go/internal/cbus/MessageCodec.go b/plc4go/internal/cbus/MessageCodec.go
index 95a8cee30a..ce5504e39d 100644
--- a/plc4go/internal/cbus/MessageCodec.go
+++ b/plc4go/internal/cbus/MessageCodec.go
@@ -49,7 +49,8 @@ type MessageCodec struct {
currentlyReportedServerErrors atomic.Uint64
- log zerolog.Logger `ignore:"true"`
+ passLogToModel bool `ignore:"true"`
+ log zerolog.Logger `ignore:"true"`
}
func NewMessageCodec(transportInstance transports.TransportInstance, _options ...options.WithOption) *MessageCodec {
@@ -58,6 +59,7 @@ func NewMessageCodec(transportInstance transports.TransportInstance, _options ..
cbusOptions: readWriteModel.NewCBusOptions(false, false, false, false, false, false, false, false, false),
monitoredMMIs: make(chan readWriteModel.CALReply, 100),
monitoredSALs: make(chan readWriteModel.MonitoredSAL, 100),
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
log: options.ExtractCustomLogger(_options...),
}
codec.DefaultCodec = _default.NewDefaultCodec(codec, transportInstance, append(_options, _default.WithCustomMessageHandler(extractMMIAndSAL(codec.log)))...)
@@ -149,7 +151,8 @@ func (m *MessageCodec) Receive() (spi.Message, error) {
if bytes, err := ti.PeekReadableBytes(1); err == nil && (bytes[0] == byte(readWriteModel.ConfirmationType_CHECKSUM_FAILURE)) {
_, _ = ti.Read(1)
// Report one Error at a time
- return readWriteModel.CBusMessageParse(context.TODO(), bytes, true, m.requestContext, m.cbusOptions)
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ return readWriteModel.CBusMessageParse(ctxForModel, bytes, true, m.requestContext, m.cbusOptions)
}
peekedBytes, err := ti.PeekReadableBytes(readableBytes)
@@ -266,7 +269,8 @@ lookingForTheEnd:
if foundErrors > m.currentlyReportedServerErrors.Load() {
m.log.Debug().Msgf("We found %d errors in the current message. We have %d reported already", foundErrors, m.currentlyReportedServerErrors.Load())
m.currentlyReportedServerErrors.Add(1)
- return readWriteModel.CBusMessageParse(context.TODO(), []byte{'!'}, true, m.requestContext, m.cbusOptions)
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ return readWriteModel.CBusMessageParse(ctxForModel, []byte{'!'}, true, m.requestContext, m.cbusOptions)
}
if foundErrors > 0 {
m.log.Debug().Msgf("We should have reported all errors by now (%d in total which we reported %d), so we resetting the count", foundErrors, m.currentlyReportedServerErrors.Load())
@@ -294,12 +298,13 @@ lookingForTheEnd:
}
}
m.log.Debug().Msgf("Parsing %q", sanitizedInput)
- cBusMessage, err := readWriteModel.CBusMessageParse(context.TODO(), sanitizedInput, pciResponse, m.requestContext, m.cbusOptions)
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ cBusMessage, err := readWriteModel.CBusMessageParse(ctxForModel, sanitizedInput, pciResponse, m.requestContext, m.cbusOptions)
if err != nil {
m.log.Debug().Err(err).Msg("First Parse Failed")
{ // Try SAL
requestContext := readWriteModel.NewRequestContext(false)
- cBusMessage, secondErr := readWriteModel.CBusMessageParse(context.TODO(), sanitizedInput, pciResponse, requestContext, m.cbusOptions)
+ cBusMessage, secondErr := readWriteModel.CBusMessageParse(ctxForModel, sanitizedInput, pciResponse, requestContext, m.cbusOptions)
if secondErr == nil {
m.log.Trace().Msgf("Parsed message as SAL:\n%s", cBusMessage)
return cBusMessage, nil
@@ -310,7 +315,7 @@ lookingForTheEnd:
{ // Try MMI
requestContext := readWriteModel.NewRequestContext(false)
cbusOptions := readWriteModel.NewCBusOptions(false, false, false, false, false, false, false, false, false)
- cBusMessage, secondErr := readWriteModel.CBusMessageParse(context.TODO(), sanitizedInput, true, requestContext, cbusOptions)
+ cBusMessage, secondErr := readWriteModel.CBusMessageParse(ctxForModel, sanitizedInput, true, requestContext, cbusOptions)
if secondErr == nil {
m.log.Trace().Msgf("Parsed message as MMI:\n%s", cBusMessage)
return cBusMessage, nil
diff --git a/plc4go/internal/knxnetip/Browser.go b/plc4go/internal/knxnetip/Browser.go
index b23d6d91bf..d2f0b35912 100644
--- a/plc4go/internal/knxnetip/Browser.go
+++ b/plc4go/internal/knxnetip/Browser.go
@@ -46,7 +46,8 @@ type Browser struct {
messageCodec spi.MessageCodec
sequenceCounter uint8
- log zerolog.Logger
+ passLogToModel bool
+ log zerolog.Logger
}
func NewBrowser(connection *Connection, messageCodec spi.MessageCodec, _options ...options.WithOption) *Browser {
@@ -54,6 +55,7 @@ func NewBrowser(connection *Connection, messageCodec spi.MessageCodec, _options
connection: connection,
messageCodec: messageCodec,
sequenceCounter: 0,
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
log: options.ExtractCustomLogger(_options...),
}
browser.DefaultBrowser = _default.NewDefaultBrowser(browser, _options...)
@@ -247,13 +249,14 @@ func (m Browser) executeCommunicationObjectQuery(ctx context.Context, query Comm
readResult.GetResponse().GetResponseCode("groupAddressTable").GetName())
}
var knxGroupAddresses []driverModel.KnxGroupAddress
+ ctxForModel := options.GetLoggerContextForModel(ctx, m.log, options.WithPassLoggerToModel(m.passLogToModel))
if readResult.GetResponse().GetValue("groupAddressTable").IsList() {
for _, groupAddress := range readResult.GetResponse().GetValue("groupAddressTable").GetList() {
- groupAddress := Uint16ToKnxGroupAddress(ctx, groupAddress.GetUint16(), 3)
+ groupAddress := Uint16ToKnxGroupAddress(ctxForModel, groupAddress.GetUint16(), 3)
knxGroupAddresses = append(knxGroupAddresses, groupAddress)
}
} else {
- groupAddress := Uint16ToKnxGroupAddress(ctx, readResult.GetResponse().GetValue("groupAddressTable").GetUint16(), 3)
+ groupAddress := Uint16ToKnxGroupAddress(ctxForModel, readResult.GetResponse().GetValue("groupAddressTable").GetUint16(), 3)
knxGroupAddresses = append(knxGroupAddresses, groupAddress)
}
@@ -378,7 +381,8 @@ func (m Browser) executeCommunicationObjectQuery(ctx context.Context, query Comm
}
comObjectSettings := readResult.GetResponse().GetValue(strconv.Itoa(int(comObjectNumber))).GetUint16()
data := []uint8{uint8((comObjectSettings >> 8) & 0xFF), uint8(comObjectSettings & 0xFF)}
- descriptor, err := driverModel.GroupObjectDescriptorRealisationTypeBParse(ctx, data)
+ ctxForModel := options.GetLoggerContextForModel(ctx, m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ descriptor, err := driverModel.GroupObjectDescriptorRealisationTypeBParse(ctxForModel, data)
if err != nil {
m.log.Info().Err(err).Msg("error parsing com object descriptor")
continue
@@ -472,7 +476,8 @@ func (m Browser) executeCommunicationObjectQuery(ctx context.Context, query Comm
for _, tagName := range readResult.GetResponse().GetTagNames() {
array := utils.PlcValueUint8ListToByteArray(readResult.GetResponse().GetValue(tagName))
- descriptor, err := driverModel.GroupObjectDescriptorRealisationType7Parse(ctx, array)
+ ctxForModel := options.GetLoggerContextForModel(ctx, m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ descriptor, err := driverModel.GroupObjectDescriptorRealisationType7Parse(ctxForModel, array)
if err != nil {
return nil, errors.Wrap(err, "error creating read request")
}
diff --git a/plc4go/internal/knxnetip/Connection.go b/plc4go/internal/knxnetip/Connection.go
index 15b35c6913..494c135778 100644
--- a/plc4go/internal/knxnetip/Connection.go
+++ b/plc4go/internal/knxnetip/Connection.go
@@ -138,7 +138,8 @@ type Connection struct {
connectionId string
tracer tracer.Tracer
- log zerolog.Logger
+ passLogToModel bool
+ log zerolog.Logger
}
func (m *Connection) String() string {
@@ -189,6 +190,7 @@ func NewConnection(transportInstance transports.TransportInstance, connectionOpt
defaultTtl: time.Second * 10,
DeviceConnections: map[driverModel.KnxAddress]*KnxDeviceConnection{},
handleTunnelingRequests: true,
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
log: options.ExtractCustomLogger(_options...),
}
connection.connectionTtl = connection.defaultTtl * 2
diff --git a/plc4go/internal/knxnetip/ConnectionDriverSpecificOperations.go b/plc4go/internal/knxnetip/ConnectionDriverSpecificOperations.go
index 53d4cc37a2..ae7a363375 100644
--- a/plc4go/internal/knxnetip/ConnectionDriverSpecificOperations.go
+++ b/plc4go/internal/knxnetip/ConnectionDriverSpecificOperations.go
@@ -21,6 +21,7 @@ package knxnetip
import (
"context"
+ "github.com/apache/plc4x/plc4go/spi/options"
"math"
"runtime/debug"
"strconv"
@@ -179,7 +180,8 @@ func (m *Connection) DeviceConnect(ctx context.Context, targetAddress driverMode
if propertyValueResponse.GetCount() > 0 {
dataLength := uint8(len(propertyValueResponse.GetData()))
data := propertyValueResponse.GetData()
- plcValue, err := driverModel.KnxPropertyParse(context.Background(), data,
+ ctxForModel := options.GetLoggerContextForModel(ctx, m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ plcValue, err := driverModel.KnxPropertyParse(ctxForModel, data,
driverModel.KnxInterfaceObjectProperty_PID_DEVICE_MAX_APDULENGTH.PropertyDataType(), dataLength)
// Return the result
@@ -370,7 +372,8 @@ func (m *Connection) DeviceReadProperty(ctx context.Context, targetAddress drive
dataLength := uint8(len(propertyValueResponse.GetData()))
data := propertyValueResponse.GetData()
- plcValue, err := driverModel.KnxPropertyParse(context.Background(), data, property.PropertyDataType(), dataLength)
+ ctxForModel := options.GetLoggerContextForModel(ctx, m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ plcValue, err := driverModel.KnxPropertyParse(ctxForModel, data, property.PropertyDataType(), dataLength)
if err != nil {
sendResponse(nil, 0, err)
} else {
diff --git a/plc4go/internal/knxnetip/ConnectionHelper.go b/plc4go/internal/knxnetip/ConnectionHelper.go
index 5f5577ba17..5d8383a9d2 100644
--- a/plc4go/internal/knxnetip/ConnectionHelper.go
+++ b/plc4go/internal/knxnetip/ConnectionHelper.go
@@ -22,6 +22,7 @@ package knxnetip
import (
"context"
"fmt"
+ "github.com/apache/plc4x/plc4go/spi/options"
"math"
"net"
"runtime/debug"
@@ -86,7 +87,8 @@ func (m *Connection) handleIncomingTunnelingRequest(ctx context.Context, tunneli
return
}
// If this is an individual address, and it is targeted at us, we need to ack that.
- targetAddress := ByteArrayToKnxAddress(ctx, dataFrame.GetDestinationAddress())
+ ctxForModel := options.GetLoggerContextForModel(ctx, m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ targetAddress := ByteArrayToKnxAddress(ctxForModel, dataFrame.GetDestinationAddress())
if targetAddress == m.ClientKnxAddress {
m.log.Info().Msg("Acknowleding an unhandled data message.")
_ = m.sendDeviceAck(ctx, dataFrame.GetSourceAddress(), dataFrame.GetApdu().GetCounter(), func(err error) {})
@@ -97,7 +99,8 @@ func (m *Connection) handleIncomingTunnelingRequest(ctx context.Context, tunneli
return
}
// If this is an individual address, and it is targeted at us, we need to ack that.
- targetAddress := ByteArrayToKnxAddress(ctx, dataFrame.GetDestinationAddress())
+ ctxForModel := options.GetLoggerContextForModel(ctx, m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ targetAddress := ByteArrayToKnxAddress(ctxForModel, dataFrame.GetDestinationAddress())
if targetAddress == m.ClientKnxAddress {
m.log.Info().Msg("Acknowleding an unhandled contol message.")
_ = m.sendDeviceAck(ctx, dataFrame.GetSourceAddress(), dataFrame.GetApdu().GetCounter(), func(err error) {})
diff --git a/plc4go/internal/knxnetip/ConnectionInternalOperations.go b/plc4go/internal/knxnetip/ConnectionInternalOperations.go
index 8c2fb677f9..d1c9e3588d 100644
--- a/plc4go/internal/knxnetip/ConnectionInternalOperations.go
+++ b/plc4go/internal/knxnetip/ConnectionInternalOperations.go
@@ -21,6 +21,7 @@ package knxnetip
import (
"context"
+ "github.com/apache/plc4x/plc4go/spi/options"
"reflect"
"time"
@@ -370,7 +371,8 @@ func (m *Connection) sendDeviceConnectionRequest(ctx context.Context, targetAddr
return false
}
// Check if the address matches
- if ByteArrayToKnxAddress(ctx, lDataFrameExt.GetDestinationAddress()) != targetAddress {
+ ctxForModel := options.GetLoggerContextForModel(ctx, m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ if ByteArrayToKnxAddress(ctxForModel, lDataFrameExt.GetDestinationAddress()) != targetAddress {
return false
}
apduControlContainer, ok := lDataFrameExt.GetApdu().(driverModel.ApduControlContainerExactly)
@@ -459,7 +461,8 @@ func (m *Connection) sendDeviceDisconnectionRequest(ctx context.Context, targetA
if !ok {
return false
}
- curTargetAddress := ByteArrayToKnxAddress(ctx, dataFrameExt.GetDestinationAddress())
+ ctxForModel := options.GetLoggerContextForModel(ctx, m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ curTargetAddress := ByteArrayToKnxAddress(ctxForModel, dataFrameExt.GetDestinationAddress())
// Check if the address matches
if curTargetAddress != targetAddress {
return false
@@ -577,7 +580,8 @@ func (m *Connection) sendDeviceAuthentication(ctx context.Context, targetAddress
if !ok {
return false
}
- curTargetAddress := ByteArrayToKnxAddress(ctx, dataFrameExt.GetDestinationAddress())
+ ctxForModel := options.GetLoggerContextForModel(ctx, m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ curTargetAddress := ByteArrayToKnxAddress(ctxForModel, dataFrameExt.GetDestinationAddress())
// Check if the addresses match
if curTargetAddress != m.ClientKnxAddress {
return false
@@ -1117,7 +1121,8 @@ func (m *Connection) sendDeviceAck(ctx context.Context, targetAddress driverMode
if dataFrameExt.GetSourceAddress() != m.ClientKnxAddress {
return false
}
- curTargetAddress := ByteArrayToKnxAddress(ctx, dataFrameExt.GetDestinationAddress())
+ ctxForModel := options.GetLoggerContextForModel(ctx, m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ curTargetAddress := ByteArrayToKnxAddress(ctxForModel, dataFrameExt.GetDestinationAddress())
if curTargetAddress != targetAddress {
return false
}
diff --git a/plc4go/internal/knxnetip/MessageCodec.go b/plc4go/internal/knxnetip/MessageCodec.go
index 95a2750f28..94906da454 100644
--- a/plc4go/internal/knxnetip/MessageCodec.go
+++ b/plc4go/internal/knxnetip/MessageCodec.go
@@ -37,12 +37,14 @@ type MessageCodec struct {
sequenceCounter int32
messageInterceptor func(message spi.Message)
- log zerolog.Logger
+ passLogToModel bool
+ log zerolog.Logger
}
func NewMessageCodec(transportInstance transports.TransportInstance, messageInterceptor func(message spi.Message), _options ...options.WithOption) *MessageCodec {
codec := &MessageCodec{
messageInterceptor: messageInterceptor,
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
log: options.ExtractCustomLogger(_options...),
}
codec.DefaultCodec = _default.NewDefaultCodec(
@@ -97,7 +99,8 @@ func (m *MessageCodec) Receive() (spi.Message, error) {
// TODO: Possibly clean up ...
return nil, nil
}
- knxMessage, err := model.KnxNetIpMessageParse(context.TODO(), data)
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ knxMessage, err := model.KnxNetIpMessageParse(ctxForModel, data)
if err != nil {
m.log.Warn().Err(err).Msg("error parsing message")
// TODO: Possibly clean up ...
diff --git a/plc4go/internal/knxnetip/Subscriber.go b/plc4go/internal/knxnetip/Subscriber.go
index 8d7fd11844..c6c9dec419 100644
--- a/plc4go/internal/knxnetip/Subscriber.go
+++ b/plc4go/internal/knxnetip/Subscriber.go
@@ -39,14 +39,16 @@ type Subscriber struct {
connection *Connection
consumers map[*spiModel.DefaultPlcConsumerRegistration]apiModel.PlcSubscriptionEventConsumer
- log zerolog.Logger
+ passLogToModel bool
+ log zerolog.Logger
}
func NewSubscriber(connection *Connection, _options ...options.WithOption) *Subscriber {
return &Subscriber{
- connection: connection,
- consumers: make(map[*spiModel.DefaultPlcConsumerRegistration]apiModel.PlcSubscriptionEventConsumer),
- log: options.ExtractCustomLogger(_options...),
+ connection: connection,
+ consumers: make(map[*spiModel.DefaultPlcConsumerRegistration]apiModel.PlcSubscriptionEventConsumer),
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
+ log: options.ExtractCustomLogger(_options...),
}
}
@@ -103,7 +105,8 @@ func (m *Subscriber) Unsubscribe(ctx context.Context, unsubscriptionRequest apiM
func (m *Subscriber) handleValueChange(ctx context.Context, destinationAddress []byte, payload []byte, changed bool) {
// Decode the group-address according to the settings in the driver
// Group addresses can be 1, 2 or 3 levels (3 being the default)
- groupAddress, err := driverModel.KnxGroupAddressParse(ctx, destinationAddress, m.connection.getGroupAddressNumLevels())
+ ctxForModel := options.GetLoggerContextForModel(ctx, m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ groupAddress, err := driverModel.KnxGroupAddressParse(ctxForModel, destinationAddress, m.connection.getGroupAddressNumLevels())
if err != nil {
return
}
diff --git a/plc4go/internal/knxnetip/SubscriptionEvent.go b/plc4go/internal/knxnetip/SubscriptionEvent.go
index c47125d374..07ea1f88c5 100644
--- a/plc4go/internal/knxnetip/SubscriptionEvent.go
+++ b/plc4go/internal/knxnetip/SubscriptionEvent.go
@@ -36,7 +36,8 @@ type SubscriptionEvent struct {
*spiModel.DefaultPlcSubscriptionEvent
addresses map[string][]byte
- log zerolog.Logger
+ passLogToModel bool
+ log zerolog.Logger
}
func NewSubscriptionEvent(
@@ -48,7 +49,11 @@ func NewSubscriptionEvent(
values map[string]values.PlcValue,
_options ...options.WithOption,
) SubscriptionEvent {
- subscriptionEvent := SubscriptionEvent{addresses: addresses}
+ subscriptionEvent := SubscriptionEvent{
+ addresses: addresses,
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
+ log: options.ExtractCustomLogger(_options...),
+ }
event := spiModel.NewDefaultPlcSubscriptionEvent(&subscriptionEvent, tags, types, intervals, responseCodes, values, _options...)
subscriptionEvent.DefaultPlcSubscriptionEvent = event.(*spiModel.DefaultPlcSubscriptionEvent)
return subscriptionEvent
@@ -60,13 +65,14 @@ func (m SubscriptionEvent) GetAddress(name string) string {
tag := m.DefaultPlcSubscriptionEvent.GetTag(name)
var groupAddress driverModel.KnxGroupAddress
var err error
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), m.log, options.WithPassLoggerToModel(m.passLogToModel))
switch tag.(type) {
case GroupAddress3LevelPlcTag:
- groupAddress, err = driverModel.KnxGroupAddressParse(context.TODO(), rawAddress, 3)
+ groupAddress, err = driverModel.KnxGroupAddressParse(ctxForModel, rawAddress, 3)
case GroupAddress2LevelPlcTag:
- groupAddress, err = driverModel.KnxGroupAddressParse(context.TODO(), rawAddress, 2)
+ groupAddress, err = driverModel.KnxGroupAddressParse(ctxForModel, rawAddress, 2)
case GroupAddress1LevelPlcTag:
- groupAddress, err = driverModel.KnxGroupAddressParse(context.TODO(), rawAddress, 1)
+ groupAddress, err = driverModel.KnxGroupAddressParse(ctxForModel, rawAddress, 1)
}
if err != nil {
m.log.Debug().Err(err).Msg("error parsing")
diff --git a/plc4go/internal/knxnetip/Utils.go b/plc4go/internal/knxnetip/Utils.go
index c067f50206..84fe2bf75e 100644
--- a/plc4go/internal/knxnetip/Utils.go
+++ b/plc4go/internal/knxnetip/Utils.go
@@ -68,8 +68,8 @@ func GroupAddressToString(groupAddress driverModel.KnxGroupAddress) (string, err
}
}
-func ByteArrayToKnxAddress(ctx context.Context, data []byte) driverModel.KnxAddress {
- knxAddress, err := driverModel.KnxAddressParse(ctx, data)
+func ByteArrayToKnxAddress(ctxForModel context.Context, data []byte) driverModel.KnxAddress {
+ knxAddress, err := driverModel.KnxAddressParse(ctxForModel, data)
if err != nil {
return nil
}
@@ -95,11 +95,11 @@ func Uint16ToKnxAddress(data uint16) driverModel.KnxAddress {
return knxAddress
}
-func Uint16ToKnxGroupAddress(ctx context.Context, data uint16, numLevels uint8) driverModel.KnxGroupAddress {
+func Uint16ToKnxGroupAddress(ctxForModel context.Context, data uint16, numLevels uint8) driverModel.KnxGroupAddress {
rawData := make([]uint8, 2)
rawData[0] = uint8(data >> 8)
rawData[1] = uint8(data & 0xFF)
- knxGroupAddress, err := driverModel.KnxGroupAddressParse(ctx, rawData, numLevels)
+ knxGroupAddress, err := driverModel.KnxGroupAddressParse(ctxForModel, rawData, numLevels)
if err != nil {
return nil
}
diff --git a/plc4go/internal/modbus/MessageCodec.go b/plc4go/internal/modbus/MessageCodec.go
index 7f7e8dba34..990f8038ad 100644
--- a/plc4go/internal/modbus/MessageCodec.go
+++ b/plc4go/internal/modbus/MessageCodec.go
@@ -36,12 +36,14 @@ type MessageCodec struct {
_default.DefaultCodec
expectationCounter int32
- log zerolog.Logger
+ passLogToModel bool
+ log zerolog.Logger
}
func NewMessageCodec(transportInstance transports.TransportInstance, _options ...options.WithOption) *MessageCodec {
codec := &MessageCodec{
expectationCounter: 1,
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
log: options.ExtractCustomLogger(_options...),
}
codec.DefaultCodec = _default.NewDefaultCodec(codec, transportInstance)
@@ -91,7 +93,8 @@ func (m *MessageCodec) Receive() (spi.Message, error) {
// TODO: Possibly clean up ...
return nil, nil
}
- tcpAdu, err := model.ModbusTcpADUParse(context.TODO(), data, model.DriverType_MODBUS_TCP, true)
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ tcpAdu, err := model.ModbusTcpADUParse(ctxForModel, data, model.DriverType_MODBUS_TCP, true)
if err != nil {
m.log.Warn().Err(err).Msg("error parsing")
// TODO: Possibly clean up ...
diff --git a/plc4go/internal/modbus/Reader.go b/plc4go/internal/modbus/Reader.go
index 4985f65b26..d0289e8647 100644
--- a/plc4go/internal/modbus/Reader.go
+++ b/plc4go/internal/modbus/Reader.go
@@ -42,7 +42,8 @@ type Reader struct {
unitIdentifier uint8
messageCodec spi.MessageCodec
- log zerolog.Logger
+ passLogToModel bool
+ log zerolog.Logger
}
func NewReader(unitIdentifier uint8, messageCodec spi.MessageCodec, _options ...options.WithOption) *Reader {
@@ -50,6 +51,7 @@ func NewReader(unitIdentifier uint8, messageCodec spi.MessageCodec, _options ...
transactionIdentifier: 0,
unitIdentifier: unitIdentifier,
messageCodec: messageCodec,
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
log: options.ExtractCustomLogger(_options...),
}
}
@@ -200,7 +202,8 @@ func (m *Reader) ToPlc4xReadResponse(responseAdu readWriteModel.ModbusTcpADU, re
// Decode the data according to the information from the request
m.log.Trace().Msg("decode data")
- value, err := readWriteModel.DataItemParse(context.Background(), data, tag.Datatype, tag.Quantity)
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ value, err := readWriteModel.DataItemParse(ctxForModel, data, tag.Datatype, tag.Quantity)
if err != nil {
return nil, errors.Wrap(err, "Error parsing data item")
}
diff --git a/plc4go/internal/s7/Driver.go b/plc4go/internal/s7/Driver.go
index 56a9e9127b..59eaf3633d 100644
--- a/plc4go/internal/s7/Driver.go
+++ b/plc4go/internal/s7/Driver.go
@@ -49,7 +49,7 @@ func NewDriver(_options ...options.WithOption) plc4go.PlcDriver {
log: options.ExtractCustomLogger(_options...),
}
- driver.DefaultDriver = _default.NewDefaultDriver(driver, "s7", "Siemens S7 (Basic)", "tcp", NewTagHandler())
+ driver.DefaultDriver = _default.NewDefaultDriver(driver, "s7", "Siemens S7 (Basic)", "tcp", NewTagHandler(_options...))
return driver
}
diff --git a/plc4go/internal/s7/MessageCodec.go b/plc4go/internal/s7/MessageCodec.go
index ece5f377c1..725e48c3cc 100644
--- a/plc4go/internal/s7/MessageCodec.go
+++ b/plc4go/internal/s7/MessageCodec.go
@@ -35,12 +35,14 @@ import (
type MessageCodec struct {
_default.DefaultCodec
- log zerolog.Logger
+ passLogToModel bool
+ log zerolog.Logger
}
func NewMessageCodec(transportInstance transports.TransportInstance, _options ...options.WithOption) *MessageCodec {
codec := &MessageCodec{
- log: options.ExtractCustomLogger(_options...),
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
+ log: options.ExtractCustomLogger(_options...),
}
codec.DefaultCodec = _default.NewDefaultCodec(codec, transportInstance, _options...)
return codec
@@ -90,7 +92,8 @@ func (m *MessageCodec) Receive() (spi.Message, error) {
// TODO: Possibly clean up ...
return nil, nil
}
- tpktPacket, err := model.TPKTPacketParse(context.TODO(), data)
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ tpktPacket, err := model.TPKTPacketParse(ctxForModel, data)
if err != nil {
m.log.Warn().Err(err).Msg("error parsing")
// TODO: Possibly clean up ...
diff --git a/plc4go/internal/s7/Reader.go b/plc4go/internal/s7/Reader.go
index 967808b7d2..91917b2551 100644
--- a/plc4go/internal/s7/Reader.go
+++ b/plc4go/internal/s7/Reader.go
@@ -42,15 +42,17 @@ type Reader struct {
messageCodec spi.MessageCodec
tm transactions.RequestTransactionManager
- log zerolog.Logger
+ passLogToModel bool
+ log zerolog.Logger
}
func NewReader(tpduGenerator *TpduGenerator, messageCodec spi.MessageCodec, tm transactions.RequestTransactionManager, _options ...options.WithOption) *Reader {
return &Reader{
- tpduGenerator: tpduGenerator,
- messageCodec: messageCodec,
- tm: tm,
- log: options.ExtractCustomLogger(_options...),
+ tpduGenerator: tpduGenerator,
+ messageCodec: messageCodec,
+ tm: tm,
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
+ log: options.ExtractCustomLogger(_options...),
}
}
@@ -233,7 +235,8 @@ func (m *Reader) ToPlc4xReadResponse(response readWriteModel.S7Message, readRequ
m.log.Trace().Msg("decode data")
responseCodes[tagName] = responseCode
if responseCode == apiModel.PlcResponseCode_OK {
- plcValue, err := readWriteModel.DataItemParse(context.Background(), payloadItem.GetData(), tag.GetDataType().DataProtocolId(), int32(tag.GetNumElements()))
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ plcValue, err := readWriteModel.DataItemParse(ctxForModel, payloadItem.GetData(), tag.GetDataType().DataProtocolId(), int32(tag.GetNumElements()))
if err != nil {
return nil, errors.Wrap(err, "Error parsing data item")
}
diff --git a/plc4go/internal/s7/TagHandler.go b/plc4go/internal/s7/TagHandler.go
index df984cc4e1..3d0306b8dd 100644
--- a/plc4go/internal/s7/TagHandler.go
+++ b/plc4go/internal/s7/TagHandler.go
@@ -23,6 +23,8 @@ import (
"context"
"encoding/hex"
"fmt"
+ "github.com/apache/plc4x/plc4go/spi/options"
+ "github.com/rs/zerolog"
"regexp"
"strconv"
"strings"
@@ -53,9 +55,12 @@ type TagHandler struct {
dataBlockStringAddressPattern *regexp.Regexp
dataBlockStringShortPattern *regexp.Regexp
plcProxyAddressPattern *regexp.Regexp
+
+ passLogToModel bool
+ log zerolog.Logger
}
-func NewTagHandler() TagHandler {
+func NewTagHandler(_options ...options.WithOption) TagHandler {
return TagHandler{
addressPattern: regexp.MustCompile(`^%(?P<memoryArea>.)(?P<transferSizeCode>[XBWD]?)(?P<byteOffset>\d{1,7})(.(?P<bitOffset>[0-7]))?:(?P<dataType>[a-zA-Z_]+)(\[(?P<numElements>\d+)])?`),
//blockNumber usually has its max hat around 64000 --> 5digits
@@ -64,6 +69,9 @@ func NewTagHandler() TagHandler {
dataBlockStringAddressPattern: regexp.MustCompile(`^%DB(?P<blockNumber>\d{1,5}).DB(?P<transferSizeCode>[XBWD]?)(?P<byteOffset>\d{1,7})(.(?P<bitOffset>[0-7]))?:(?P<dataType>STRING|WSTRING)\((?P<stringLength>\d{1,3})\)(\[(?P<numElements>\d+)])?`),
dataBlockStringShortPattern: regexp.MustCompile(`^%DB(?P<blockNumber>\d{1,5}):(?P<byteOffset>\d{1,7})(.(?P<bitOffset>[0-7]))?:(?P<dataType>STRING|WSTRING)\((?P<stringLength>\d{1,3})\)(\[(?P<numElements>\d+)])?`),
plcProxyAddressPattern: regexp.MustCompile(`[0-9A-F]{2}-[0-9A-F]{2}-[0-9A-F]{2}-[0-9A-F]{2}-[0-9A-F]{2}-[0-9A-F]{2}-[0-9A-F]{2}-[0-9A-F]{2}-[0-9A-F]{2}-[0-9A-F]{2}`),
+
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
+ log: options.ExtractCustomLogger(_options...),
}
}
@@ -255,7 +263,8 @@ func (m TagHandler) ParseTag(tagAddress string) (apiModel.PlcTag, error) {
if err != nil {
return nil, errors.Wrapf(err, "Unable to parse address: %s", tagAddress)
}
- s7Address, err := readWriteModel.S7AddressAnyParse(context.TODO(), addressData)
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), m.log, options.WithPassLoggerToModel(m.passLogToModel))
+ s7Address, err := readWriteModel.S7AddressAnyParse(ctxForModel, addressData)
if err != nil {
return nil, errors.Wrapf(err, "Unable to parse address: %s", tagAddress)
}
diff --git a/plc4go/internal/simulated/Device.go b/plc4go/internal/simulated/Device.go
index bd4b09a691..3b8e40b904 100644
--- a/plc4go/internal/simulated/Device.go
+++ b/plc4go/internal/simulated/Device.go
@@ -33,14 +33,16 @@ type Device struct {
Name string
State map[simulatedTag]*apiValues.PlcValue
- log zerolog.Logger
+ passLogToModel bool
+ log zerolog.Logger
}
func NewDevice(name string, _options ...options.WithOption) *Device {
return &Device{
- Name: name,
- State: make(map[simulatedTag]*apiValues.PlcValue),
- log: options.ExtractCustomLogger(_options...),
+ Name: name,
+ State: make(map[simulatedTag]*apiValues.PlcValue),
+ passLogToModel: options.ExtractPassLoggerToModel(_options...),
+ log: options.ExtractCustomLogger(_options...),
}
}
@@ -72,7 +74,8 @@ func (d *Device) getRandomValue(tag simulatedTag) *apiValues.PlcValue {
size := tag.GetDataTypeSize().DataTypeSize()
data := make([]byte, uint16(size)*tag.Quantity)
rand.Read(data)
- plcValue, err := readWriteModel.DataItemParse(context.Background(), data, tag.DataTypeSize.String(), tag.Quantity)
+ ctxForModel := options.GetLoggerContextForModel(context.TODO(), d.log, options.WithPassLoggerToModel(d.passLogToModel))
+ plcValue, err := readWriteModel.DataItemParse(ctxForModel, data, tag.DataTypeSize.String(), tag.Quantity)
if err != nil {
d.log.Err(err).Msg("Unable to parse random bytes")
return nil
diff --git a/plc4go/spi/options/Option.go b/plc4go/spi/options/Option.go
index 599e957342..18c41b2ceb 100644
--- a/plc4go/spi/options/Option.go
+++ b/plc4go/spi/options/Option.go
@@ -42,11 +42,6 @@ func WithCustomLogger(logger zerolog.Logger) WithOption {
return withCustomLogger{logger: logger}
}
-// WithPassLoggerToModel enables passing of log to the model
-func WithPassLoggerToModel(passLogger bool) WithOption {
- return withPassLoggerToModel{passLogger: passLogger}
-}
-
// ExtractCustomLogger can be used to extract the custom logger
func ExtractCustomLogger(options ...WithOption) (customLogger zerolog.Logger) {
for _, option := range options {
@@ -59,6 +54,22 @@ func ExtractCustomLogger(options ...WithOption) (customLogger zerolog.Logger) {
return
}
+// WithPassLoggerToModel enables passing of log to the model
+func WithPassLoggerToModel(passLogger bool) WithOption {
+ return withPassLoggerToModel{passLogger: passLogger}
+}
+
+// ExtractPassLoggerToModel to extract the flag indicating that model should be passed to Model
+func ExtractPassLoggerToModel(options ...WithOption) bool {
+ for _, option := range options {
+ switch option := option.(type) {
+ case withPassLoggerToModel:
+ return option.passLogger
+ }
+ }
+ return false
+}
+
// GetLoggerContextForModel returns a log context if the WithPassLoggerToModel WithOption is set
func GetLoggerContextForModel(ctx context.Context, log zerolog.Logger, options ...WithOption) context.Context {
passToModel := false