// Create a new Heka logging interface.
func NewHekaLogger(conf JsMap) *HekaLogger {
//Preflight
var ok bool
var encoder client.Encoder = nil
var sender client.Sender = nil
var logname string = ""
var err error
var tracer bool = false
var filter int64
pid := int32(os.Getpid())
if _, ok = conf["heka.sender"]; !ok {
conf["heka.sender"] = "tcp"
}
if _, ok = conf["heka.server_addr"]; !ok {
conf["heka.server_addr"] = "127.0.0.1:5565"
}
if _, ok = conf["heka.logger_name"]; !ok {
conf["heka.logger_name"] = "simplepush"
}
if _, ok = conf["heka.current_host"]; !ok {
conf["heka.current_host"], _ = os.Hostname()
}
if _, ok = conf["heka.show_caller"]; ok {
tracer, _ = strconv.ParseBool(conf["heka.show_caller"].(string))
}
filter, _ = strconv.ParseInt(MzGet(conf, "logger.filter", "10"), 0, 0)
if MzGetFlag(conf, "heka.use") {
encoder = client.NewJsonEncoder(nil)
sender, err = client.NewNetworkSender(conf["heka.sender"].(string),
conf["heka.server_addr"].(string))
if err != nil {
log.Panic("Could not create sender ", err)
}
logname = conf["heka.logger_name"].(string)
}
return &HekaLogger{encoder: encoder,
sender: sender,
logname: logname,
pid: pid,
hostname: conf["heka.current_host"].(string),
conf: conf,
tracer: tracer,
filter: filter}
}
func NewHekaLogger(conf JsMap) *HekaLogger {
//Preflight
var ok bool
var encoder client.Encoder
var sender client.Sender
var logname string
var err error
pid := int32(os.Getpid())
hostname, _ := os.Hostname()
encoder = nil
sender = nil
logname = ""
if _, ok = conf["heka_sender"]; !ok {
conf["heka_sender"] = "tcp"
}
if _, ok = conf["heka_server_addr"]; !ok {
conf["heka_server_addr"] = "127.0.0.1:5565"
}
if _, ok = conf["heka_logger_name"]; !ok {
conf["heka_logger_name"] = "simplepush"
}
if _, ok = conf["heka_no"]; !ok {
encoder = client.NewJsonEncoder(nil)
sender, err = client.NewNetworkSender(conf["heka_sender"].(string),
conf["heka_server_addr"].(string))
if err != nil {
log.Panic("Could not create sender ", err)
}
logname = conf["heka_logger_name"].(string)
}
return &HekaLogger{encoder: encoder,
sender: sender,
logname: logname,
pid: pid,
hostname: hostname}
}
func main() {
configFile := flag.String("config", "flood.toml", "Flood configuration file")
configTest := flag.String("test", "default", "Test section to load")
flag.Parse()
if flag.NFlag() == 0 {
flag.PrintDefaults()
os.Exit(0)
}
var config FloodConfig
if _, err := toml.DecodeFile(*configFile, &config); err != nil {
log.Printf("Error decoding config file: %s", err)
return
}
var test FloodTest
var ok bool
if test, ok = config[*configTest]; !ok {
log.Printf("Configuration test: '%s' was not found", *configTest)
return
}
if test.PprofFile != "" {
profFile, err := os.Create(test.PprofFile)
if err != nil {
log.Fatalln(err)
}
pprof.StartCPUProfile(profFile)
defer pprof.StopCPUProfile()
}
sender, err := client.NewNetworkSender(test.Sender, test.IpAddress)
if err != nil {
log.Fatalf("Error creating sender: %s\n", err.Error())
}
var unsignedEncoder client.Encoder
var signedEncoder client.Encoder
switch test.Encoder {
case "json":
unsignedEncoder = client.NewJsonEncoder(nil)
signedEncoder = client.NewJsonEncoder(&test.Signer)
case "protobuf":
unsignedEncoder = client.NewProtobufEncoder(nil)
signedEncoder = client.NewProtobufEncoder(&test.Signer)
}
var numTestMessages = 1
var unsignedMessages [][]byte
var signedMessages [][]byte
rdm := &randomDataMaker{
src: rand.NewSource(time.Now().UnixNano()),
asciiOnly: test.AsciiOnly,
}
if test.VariableSizeMessages {
numTestMessages = 64
unsignedMessages = makeVariableMessage(unsignedEncoder, numTestMessages, rdm)
signedMessages = makeVariableMessage(signedEncoder, numTestMessages, rdm)
} else {
if test.StaticMessageSize == 0 {
test.StaticMessageSize = 1000
}
unsignedMessages = makeFixedMessage(unsignedEncoder, test.StaticMessageSize,
rdm)
signedMessages = makeFixedMessage(signedEncoder, test.StaticMessageSize,
rdm)
}
// wait for sigint
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGINT)
var msgsSent, bytesSent uint64
var corruptPercentage, lastCorruptPercentage, signedPercentage, lastSignedPercentage float64
var corrupt bool
// set up counter loop
ticker := time.NewTicker(time.Duration(time.Second))
go timerLoop(&msgsSent, &bytesSent, ticker)
test.CorruptPercentage /= 100.0
test.SignedPercentage /= 100.0
var buf []byte
for gotsigint := false; !gotsigint; {
runtime.Gosched()
select {
case <-sigChan:
gotsigint = true
continue
default:
}
msgId := rand.Int() % numTestMessages
corruptPercentage = math.Floor(float64(msgsSent) * test.CorruptPercentage)
if corruptPercentage != lastCorruptPercentage {
lastCorruptPercentage = corruptPercentage
corrupt = true
} else {
corrupt = false
}
signedPercentage = math.Floor(float64(msgsSent) * test.SignedPercentage)
if signedPercentage != lastSignedPercentage {
lastSignedPercentage = signedPercentage
buf = signedMessages[msgId]
} else {
buf = unsignedMessages[msgId]
}
bytesSent += uint64(len(buf))
err = sendMessage(sender, buf, corrupt)
if err != nil {
if !strings.Contains(err.Error(), "connection refused") {
log.Printf("Error sending message: %s\n",
err.Error())
}
} else {
msgsSent++
if test.NumMessages != 0 && msgsSent >= test.NumMessages {
break
}
}
}
sender.Close()
log.Println("Clean shutdown: ", msgsSent, " messages sent")
}