Added config-scope custom dispatcher mappings. cihub#39.

Author: goodsign

cfg_config.go

@@ -61,6 +61,40 @@ func LoggerFromConfigAsString(data string) (LoggerInterface, error) {
 	return LoggerFromConfigAsBytes([]byte(data))
 }
 
+// LoggerFromParamConfigAsFile does the same as LoggerFromConfigAsFile, but includes special parser options.
+// See 'CfgParseParams' comments.
+func LoggerFromParamConfigAsFile(fileName string, parserParams *CfgParseParams) (LoggerInterface, error) {
+	file, err := os.Open(fileName)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	conf, err := configFromReaderWithConfig(file, parserParams)
+	if err != nil {
+		return nil, err
+	}
+
+	return createLoggerFromConfig(conf)
+}
+
+// LoggerFromParamConfigAsBytes does the same as LoggerFromConfigAsBytes, but includes special parser options.
+// See 'CfgParseParams' comments.
+func LoggerFromParamConfigAsBytes(data []byte, parserParams *CfgParseParams) (LoggerInterface, error) {
+	conf, err := configFromReaderWithConfig(bytes.NewBuffer(data), parserParams)
+	if err != nil {
+		return nil, err
+	}
+
+	return createLoggerFromConfig(conf)
+}
+
+// LoggerFromParamConfigAsString does the same as LoggerFromConfigAsString, but includes special parser options.
+// See 'CfgParseParams' comments.
+func LoggerFromParamConfigAsString(data string, parserParams *CfgParseParams) (LoggerInterface, error) {
+	return LoggerFromParamConfigAsBytes([]byte(data), parserParams)
+}
+
 // LoggerFromWriterWithMinLevel creates a proxy logger that uses io.Writer as the
 // receiver with minimal level = minLevel.
 //
@@ -79,7 +113,7 @@ func LoggerFromWriterWithMinLevel(output io.Writer, minLevel LogLevel) (LoggerIn
 		return nil, err
 	}
 
-	conf, err := newConfig(constraints, make([]*logLevelException, 0), dispatcher, syncloggerTypeFromString, nil)
+	conf, err := newConfig(constraints, make([]*logLevelException, 0), dispatcher, syncloggerTypeFromString, nil, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -116,7 +150,7 @@ func LoggerFromCustomReceiver(receiver CustomReceiver) (LoggerInterface, error)
 		return nil, err
 	}
 
-	output, err := newCustomReceiverDispatcherByValue(msgonlyformatter, receiver)
+	output, err := newCustomReceiverDispatcherByValue(msgonlyformatter, receiver, "user-proxy", CustomReceiverInitArgs{})
 	if err != nil {
 		return nil, err
 	}
@@ -125,7 +159,7 @@ func LoggerFromCustomReceiver(receiver CustomReceiver) (LoggerInterface, error)
 		return nil, err
 	}
 
-	conf, err := newConfig(constraints, make([]*logLevelException, 0), dispatcher, syncloggerTypeFromString, nil)
+	conf, err := newConfig(constraints, make([]*logLevelException, 0), dispatcher, syncloggerTypeFromString, nil, nil)
 	if err != nil {
 		return nil, err
 	}

cfg_logconfig.go

@@ -83,14 +83,16 @@ type logConfig struct {
 	RootDispatcher dispatcherInterface  // Root of output tree
 	LogType        loggerTypeFromString
 	LoggerData     interface{}
+	Params         *CfgParseParams // Check cfg_parser: CfgParseParams
 }
 
 func newConfig(
 	constraints logLevelConstraints,
 	exceptions []*logLevelException,
 	rootDispatcher dispatcherInterface,
 	logType loggerTypeFromString,
-	logData interface{}) (*logConfig, error) {
+	logData interface{},
+	cfgParams *CfgParseParams) (*logConfig, error) {
 	if constraints == nil {
 		return nil, errors.New("Constraints can not be nil")
 	}
@@ -104,6 +106,7 @@ func newConfig(
 	config.RootDispatcher = rootDispatcher
 	config.LogType = logType
 	config.LoggerData = logData
+	config.Params = cfgParams
 
 	return config, nil
 }

cfg_parser.go

@@ -91,8 +91,38 @@ const (
 	connWriterReconnectOnMsgAttr    = "reconnectonmsg"
 )
 
+// CfgParseParams represent specific parse options or flags used by parser. It is used if seelog parser needs
+// some special directives or additional info to correctly parse a config.
+type CfgParseParams struct {
+	// CustomReceiverProducers expose the same functionality as RegisterReceiver func
+	// but only in the scope (context) of the config parse func instead of a global package scope.
+	//
+	// It means that if you use custom receivers in your code, you may either register them globally once with
+	// RegisterReceiver or you may call funcs like LoggerFromParamConfigAsFile (with 'ParamConfig')
+	// and use CustomReceiverProducers to provide custom producer funcs.
+	//
+	// A producer func is called when config parser processes a '<custom>' element. It takes the 'name' attribute
+	// of the element and tries to find a match in two places:
+	// 1) CfgParseParams.CustomReceiverProducers map
+	// 2) Global type map, filled by RegisterReceiver
+	//
+	// If a match is found in the CustomReceiverProducers map, parser calls the corresponding producer func
+	// passing the init args to it.	The func takes exactly the same args as CustomReceiver.AfterParse.
+	// The producer func must return a correct receiver or an error. If case of error, seelog will behave
+	// in the same way as with any other config error.
+	//
+	// You may use this param to set custom producers in case you need to pass some context when instantiating
+	// a custom receiver or if you frequently change custom receivers with different parameters or in any other
+	// situation where package-level registering (RegisterReceiver) is not an option for you.
+	CustomReceiverProducers map[string]func(initArgs CustomReceiverInitArgs) (CustomReceiver, error)
+}
+
+func (cfg *CfgParseParams) String() string {
+	return fmt.Sprintf("CfgParams: {custom_recs=%d}", len(cfg.CustomReceiverProducers))
+}
+
 type elementMapEntry struct {
-	constructor func(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter) (interface{}, error)
+	constructor func(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter, cfg *CfgParseParams) (interface{}, error)
 }
 
 var elementMap map[string]elementMapEntry
@@ -152,6 +182,13 @@ func fillPredefinedFormats() error {
 // Returns parsed config which can be used to create logger in case no errors occured.
 // Returns error if format is incorrect or anything happened.
 func configFromReader(reader io.Reader) (*logConfig, error) {
+	return configFromReaderWithConfig(reader, nil)
+}
+
+// configFromReader parses data from a given reader.
+// Returns parsed config which can be used to create logger in case no errors occured.
+// Returns error if format is incorrect or anything happened.
+func configFromReaderWithConfig(reader io.Reader, cfg *CfgParseParams) (*logConfig, error) {
 	config, err := unmarshalConfig(reader)
 	if err != nil {
 		return nil, err
@@ -200,7 +237,7 @@ func configFromReader(reader io.Reader) (*logConfig, error) {
 		return nil, err
 	}
 
-	dispatcher, err := getOutputsTree(config, formats)
+	dispatcher, err := getOutputsTree(config, formats, cfg)
 	if err != nil {
 		// If we open several files, but then fail to parse the config, we should close
 		// those files before reporting that config is invalid.
@@ -216,7 +253,7 @@ func configFromReader(reader io.Reader) (*logConfig, error) {
 		return nil, err
 	}
 
-	return newConfig(constraints, exceptions, dispatcher, loggerType, logData)
+	return newConfig(constraints, exceptions, dispatcher, loggerType, logData, cfg)
 }
 
 func getConstraints(node *xmlNode) (logLevelConstraints, error) {
@@ -478,7 +515,7 @@ func getloggerTypeFromStringData(config *xmlNode) (logType loggerTypeFromString,
 	return logType, logData, nil
 }
 
-func getOutputsTree(config *xmlNode, formats map[string]*formatter) (dispatcherInterface, error) {
+func getOutputsTree(config *xmlNode, formats map[string]*formatter, cfg *CfgParseParams) (dispatcherInterface, error) {
 	var outputsNode *xmlNode
 	for _, child := range config.children {
 		if child.name == outputsId {
@@ -498,7 +535,7 @@ func getOutputsTree(config *xmlNode, formats map[string]*formatter) (dispatcherI
 			return nil, err
 		}
 
-		output, err := createSplitter(outputsNode, formatter, formats)
+		output, err := createSplitter(outputsNode, formatter, formats, cfg)
 		if err != nil {
 			return nil, err
 		}
@@ -537,15 +574,15 @@ func getCurrentFormat(node *xmlNode, formatFromParent *formatter, formats map[st
 	return pdFormat, nil
 }
 
-func createInnerReceivers(node *xmlNode, format *formatter, formats map[string]*formatter) ([]interface{}, error) {
+func createInnerReceivers(node *xmlNode, format *formatter, formats map[string]*formatter, cfg *CfgParseParams) ([]interface{}, error) {
 	outputs := make([]interface{}, 0)
 	for _, childNode := range node.children {
 		entry, ok := elementMap[childNode.name]
 		if !ok {
 			return nil, errors.New("Unnknown tag '" + childNode.name + "' in outputs section")
 		}
 
-		output, err := entry.constructor(childNode, format, formats)
+		output, err := entry.constructor(childNode, format, formats, cfg)
 		if err != nil {
 			return nil, err
 		}
@@ -556,7 +593,7 @@ func createInnerReceivers(node *xmlNode, format *formatter, formats map[string]*
 	return outputs, nil
 }
 
-func createSplitter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter) (interface{}, error) {
+func createSplitter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter, cfg *CfgParseParams) (interface{}, error) {
 	err := checkUnexpectedAttribute(node, outputFormatId)
 	if err != nil {
 		return nil, err
@@ -571,15 +608,15 @@ func createSplitter(node *xmlNode, formatFromParent *formatter, formats map[stri
 		return nil, err
 	}
 
-	receivers, err := createInnerReceivers(node, currentFormat, formats)
+	receivers, err := createInnerReceivers(node, currentFormat, formats, cfg)
 	if err != nil {
 		return nil, err
 	}
 
 	return newSplitDispatcher(currentFormat, receivers)
 }
 
-func createCustomReceiver(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter) (interface{}, error) {
+func createCustomReceiver(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter, cfg *CfgParseParams) (interface{}, error) {
 	dataCustomPrefixes := make(map[string]string)
 	// Expecting only 'formatid', 'name' and 'data-' attrs
 	for attr, attrval := range node.attributes {
@@ -611,10 +648,29 @@ func createCustomReceiver(node *xmlNode, formatFromParent *formatter, formats ma
 	args := CustomReceiverInitArgs{
 		XmlCustomAttrs: dataCustomPrefixes,
 	}
+
+	if cfg != nil && cfg.CustomReceiverProducers != nil {
+		if prod, ok := cfg.CustomReceiverProducers[customName]; ok {
+			rec, err := prod(args)
+			if err != nil {
+				return nil, err
+			}
+			creceiver, err := newCustomReceiverDispatcherByValue(currentFormat, rec, customName, args)
+			if err != nil {
+				return nil, err
+			}
+			err = rec.AfterParse(args)
+			if err != nil {
+				return nil, err
+			}
+			return creceiver, nil
+		}
+	}
+
 	return newCustomReceiverDispatcher(currentFormat, customName, args)
 }
 
-func createFilter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter) (interface{}, error) {
+func createFilter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter, cfg *CfgParseParams) (interface{}, error) {
 	err := checkUnexpectedAttribute(node, outputFormatId, filterLevelsAttrId)
 	if err != nil {
 		return nil, err
@@ -639,15 +695,15 @@ func createFilter(node *xmlNode, formatFromParent *formatter, formats map[string
 		return nil, err
 	}
 
-	receivers, err := createInnerReceivers(node, currentFormat, formats)
+	receivers, err := createInnerReceivers(node, currentFormat, formats, cfg)
 	if err != nil {
 		return nil, err
 	}
 
 	return newFilterDispatcher(currentFormat, receivers, levels...)
 }
 
-func createfileWriter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter) (interface{}, error) {
+func createfileWriter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter, cfg *CfgParseParams) (interface{}, error) {
 	err := checkUnexpectedAttribute(node, outputFormatId, pathId)
 	if err != nil {
 		return nil, err
@@ -676,7 +732,7 @@ func createfileWriter(node *xmlNode, formatFromParent *formatter, formats map[st
 }
 
 // Creates new SMTP writer if encountered in the config file.
-func createSmtpWriter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter) (interface{}, error) {
+func createSmtpWriter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter, cfg *CfgParseParams) (interface{}, error) {
 	err := checkUnexpectedAttribute(node, outputFormatId, senderaddressId, senderNameId, hostNameId, hostPortId, userNameId, userPassId)
 	if err != nil {
 		return nil, err
@@ -759,7 +815,7 @@ func createSmtpWriter(node *xmlNode, formatFromParent *formatter, formats map[st
 	return newFormattedWriter(smtpWriter, currentFormat)
 }
 
-func createConsoleWriter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter) (interface{}, error) {
+func createConsoleWriter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter, cfg *CfgParseParams) (interface{}, error) {
 	err := checkUnexpectedAttribute(node, outputFormatId)
 	if err != nil {
 		return nil, err
@@ -782,7 +838,7 @@ func createConsoleWriter(node *xmlNode, formatFromParent *formatter, formats map
 	return newFormattedWriter(consoleWriter, currentFormat)
 }
 
-func createconnWriter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter) (interface{}, error) {
+func createconnWriter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter, cfg *CfgParseParams) (interface{}, error) {
 	if node.hasChildren() {
 		return nil, nodeCannotHaveChildrenError
 	}
@@ -824,7 +880,7 @@ func createconnWriter(node *xmlNode, formatFromParent *formatter, formats map[st
 	return newFormattedWriter(connWriter, currentFormat)
 }
 
-func createRollingFileWriter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter) (interface{}, error) {
+func createRollingFileWriter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter, cfg *CfgParseParams) (interface{}, error) {
 	if node.hasChildren() {
 		return nil, nodeCannotHaveChildrenError
 	}
@@ -943,7 +999,7 @@ func createRollingFileWriter(node *xmlNode, formatFromParent *formatter, formats
 	return nil, errors.New("Incorrect rolling writer type " + rollingTypeStr)
 }
 
-func createbufferedWriter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter) (interface{}, error) {
+func createbufferedWriter(node *xmlNode, formatFromParent *formatter, formats map[string]*formatter, cfg *CfgParseParams) (interface{}, error) {
 	err := checkUnexpectedAttribute(node, outputFormatId, bufferedSizeAttr, bufferedFlushPeriodAttr)
 	if err != nil {
 		return nil, err
@@ -978,7 +1034,7 @@ func createbufferedWriter(node *xmlNode, formatFromParent *formatter, formats ma
 	}
 
 	// Inner writer couldn't have its own format, so we pass 'currentFormat' as its parent format
-	receivers, err := createInnerReceivers(node, currentFormat, formats)
+	receivers, err := createInnerReceivers(node, currentFormat, formats, cfg)
 	if err != nil {
 		return nil, err
 	}