func (reader *ReaderType) PrintReaderEvent(event common.MapStr) {
json, err := json.MarshalIndent(event, "", " ")
if err != nil {
logp.Err("json.Marshal: %s", err)
} else {
logp.Debug("reader", "Reader: %s", string(json))
}
}
func (reader *ReaderType) Run(output chan common.MapStr) error {
logp.Info("Attempting to start %d inputs", len(reader.Input))
for _, plugin := range reader.Input {
err := plugin.Run(output)
if err != nil {
logp.Err("Fail to start input plugin %s : %s", plugin.InputType(), err)
return err
} else {
logp.Info("Started input plugin %s", plugin.InputType())
}
}
return nil
}
func (l *TcpInput) Run(output chan common.MapStr) error {
logp.Info("[TcpInput] Running TCP Input")
server, err := net.Listen("tcp", ":"+strconv.Itoa(l.Port))
if err != nil {
logp.Err("couldn't start listening: " + err.Error())
return nil
}
logp.Info("[TcpInput] Listening on port %d", l.Port)
// dispatch the master listen thread
go func(server net.Listener) {
for {
// accept incoming connections
conn, err := server.Accept()
if err != nil {
logp.Err("Error accepting: ", err.Error())
} else {
// dispatch individual connection handler threads
go l.handleConn(conn, output)
}
}
}(server)
return nil
}
func (reader *ReaderType) Init(inputs map[string]inputs.MothershipConfig) error {
logp.Info("reader input config", inputs)
for inputId, config := range inputs {
// default instance 0
inputName, instance := inputId, "0"
if strings.Contains(inputId, "_") {
// otherwise grok tcp_2 as inputName = tcp, instance = 2
sv := strings.Split(inputId, "_")
inputName, instance = sv[0], sv[1]
}
logp.Info(fmt.Sprintf("input type: %s instance: %s\n", inputName, instance))
logp.Debug("reader", "instance config: %s", config)
plugin := newInputInstance(inputName)
if plugin != nil && config.Enabled {
err := plugin.Init(config)
if err != nil {
logp.Err("Fail to initialize %s plugin as input: %s", inputName, err)
return err
} else {
logp.Info("Initialized %s plugin as input", inputName)
}
reader.Input = append(reader.Input, plugin)
}
}
if len(reader.Input) == 0 {
logp.Info("No inputs are defined. Please define one under the input section.")
return errors.New("No input are defined. Please define one under the input section.")
} else {
logp.Info("%d inputs defined", len(reader.Input))
}
return nil
}
func (l *SyslogInput) Run(output chan common.MapStr) error {
logp.Debug("sysloginput", "Running Syslog Input")
logp.Debug("sysloginput", "Listening on %d", l.Port)
listen := fmt.Sprintf("0.0.0.0:%d", l.Port)
channel := make(syslog.LogPartsChannel)
handler := syslog.NewChannelHandler(channel)
server := syslog.NewServer()
server.SetFormat(syslog.Automatic)
server.SetHandler(handler)
err := server.ListenUDP(listen)
if err != nil {
logp.Err("couldn't start ListenUDP: " + err.Error())
}
err = server.ListenTCP(listen)
if err != nil {
logp.Err("couldn't start ListenTCP: " + err.Error())
}
err = server.Boot()
if err != nil {
logp.Err("couldn't start server.Boot(): " + err.Error())
}
go func(channel syslog.LogPartsChannel, output chan common.MapStr) {
var line uint64 = 0
now := func() time.Time {
t := time.Now()
return t
}
for logParts := range channel {
logp.Debug("sysloginput", "InputEvent: %v", logParts)
line++
event := common.MapStr{}
event["line"] = line
event["type"] = l.Type
for k, v := range logParts {
event[k] = v
}
event["source"] = event["client"].(string)
if event["message"] != nil {
message := event["message"].(string)
event["message"] = &message
} else if event["content"] != nil {
message := event["content"].(string)
event["message"] = &message
}
// This syslog parser uses the standard name "tag"
// which is usually the program that wrote it.
// The logstash syslog_pri puts "program" for this field.
if event["tag"] != nil {
program := event["tag"].(string)
event["program"] = &program
}
event.EnsureTimestampField(now)
event.EnsureCountField()
logp.Debug("sysloginput", "Output Event: %v", event)
output <- event // ship the new event downstream
}
}(channel, output)
return nil
}
