Exemple #1
0
// messageHandler is called when a new message arrives
func handleMessage(client *MQTT.Client, msg MQTT.Message) {

	// Unmarshal JSON to RxPacket
	var packet shared.RxPacket
	err := json.Unmarshal(msg.Payload(), &packet)
	if err != nil {
		log.WithField("topic", msg.Topic()).WithError(err).Warn("Failed to unmarshal JSON.")
		return
	}

	// Filter messages by gateway
	if gateway != "" && packet.GatewayEui != gateway {
		return
	}

	// Decode payload
	data, err := base64.StdEncoding.DecodeString(packet.Data)
	if err != nil {
		log.WithField("topic", msg.Topic()).WithError(err).Warn("Failed to decode Payload.")
		return
	}

	ctx := log.WithFields(log.Fields{
		"devAddr": packet.NodeEui,
	})

	if showMeta {
		ctx = ctx.WithFields(log.Fields{
			"gatewayEui": packet.GatewayEui,
			"time":       packet.Time,
			"frequency":  *packet.Frequency,
			"dataRate":   packet.DataRate,
			"rssi":       *packet.Rssi,
			"snr":        *packet.Snr,
		})
	}

	if showRaw {
		ctx = ctx.WithField("data", fmt.Sprintf("%x", data))
	}

	if showTiming {
		rawData, err := base64.StdEncoding.DecodeString(packet.Data)
		if err == nil {
			airtime, err := util.CalculatePacketTime(len(rawData), packet.DataRate)
			if err == nil {
				ctx = ctx.WithField("airtime", fmt.Sprintf("%.1f ms", airtime))
			}
		}
	}

	// Check for unprintable characters
	unprintable, _ := regexp.Compile(`[^[:print:]]`)
	if unprintable.Match(data) {
		ctx.Debug("Received Message")
	} else {
		ctx.WithField("message", fmt.Sprintf("%s", data)).Info("Received Message")
	}

}
Exemple #2
0
// Multiple fields can be set, via chaining, or WithFields().
func Example_multipleFields() {
	log.WithFields(log.Fields{
		"user": "******",
		"file": "sloth.png",
		"type": "image/png",
	}).Info("upload")
}
Exemple #3
0
//Info prints impulse with label
func (c Correction) Info(label string) {
	log.WithFields(log.Fields{
		"M": c.Move,
		"D": fmt.Sprintf("%3d", c.Degree()),
		"T": c.Type(),
	}).Info(label)
}
Exemple #4
0
func TestFielder(t *testing.T) {
	h := memory.New()
	log.SetHandler(h)

	pet := &Pet{"Tobi", 3}
	log.WithFields(pet).Info("add pet")

	e := h.Entries[0]
	assert.Equal(t, log.Fields{"name": "Tobi", "age": 3}, e.Fields)
}
Exemple #5
0
func (m *Markup) printStackTree() {

	for _, one := range m.Impulses {
		log.WithFields(log.Fields{
			"Time": fmt.Sprintf("%s->%s", one.Base.T, one.End.T),
			"Move": fmt.Sprintf("%.2f->%.2f", one.Base.P, one.End.P),
			"Prev": one.PrevWave(),
			"Next": one.NextWave(),
		}).Debug("Imp")
	}

	for _, one := range m.Corrections {
		log.WithFields(log.Fields{
			"Time": fmt.Sprintf("%s->%s", one.Base.T, one.End.T),
			"Move": fmt.Sprintf("%.2f->%.2f", one.Base.P, one.End.P),
			"Prev": one.PrevWave(),
			"Next": one.NextWave(),
		}).Debug("Cor")
	}
}
Exemple #6
0
func main() {
	log.SetHandler(text.New(os.Stderr))

	ctx := log.WithFields(log.Fields{
		"app": "myapp",
		"env": "prod",
	})

	for range time.Tick(time.Second) {
		_ = work(ctx)
	}
}
Exemple #7
0
func (m *Markup) printStack() {

	for _, one := range m.Impulses {
		log.WithFields(log.Fields{
			"D":  one.Duration(),
			"P":  fmt.Sprintf("%.2f->%.2f", one.Base.P, one.End.P),
			"W1": one.W1,
			"W2": one.W2,
			"W3": one.W3,
			"W4": one.W4,
			"W5": one.W5,
		}).Debug("Imp")
	}

	for _, one := range m.Corrections {
		log.WithFields(log.Fields{
			"D": one.Duration(),
			"P": fmt.Sprintf("%.2f->%.2f", one.Base.P, one.End.P),
			"T": one.Type(),
		}).Debug("Corr")
	}
}
Exemple #8
0
func main() {
	log.SetHandler(json.New(os.Stderr))

	ctx := log.WithFields(log.Fields{
		"file": "something.png",
		"type": "image/png",
		"user": "******",
	})

	for range time.Tick(time.Millisecond * 200) {
		ctx.Info("upload")
		ctx.Info("upload complete")
		ctx.Warn("upload retry")
		ctx.WithError(errors.New("unauthorized")).Error("upload failed")
	}
}
Exemple #9
0
func main() {
	log.SetHandler(multi.New(
		text.New(os.Stderr),
		kinesis.New("logs"),
	))

	ctx := log.WithFields(log.Fields{
		"file": "something.png",
		"type": "image/png",
		"user": "******",
	})

	for range time.Tick(time.Millisecond * 100) {
		ctx.Info("upload")
		ctx.Info("upload complete")
	}
}
Exemple #10
0
// Run terraform command in infrastructure directory.
func (p *Proxy) Run(args ...string) error {
	if p.shouldInjectVars(args) {
		args = append(args, p.functionVars()...)
	}

	log.WithFields(log.Fields{
		"args": args,
	}).Debug("terraform")

	cmd := exec.Command("terraform", args...)
	cmd.Env = append(os.Environ(), fmt.Sprintf("AWS_REGION=%s", p.Region))
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	cmd.Dir = filepath.Join(Dir, p.Environment)

	return cmd.Run()
}
Exemple #11
0
func main() {
	flag.Parse()

	if *cfgAddr == "" {
		fmt.Println("required flag not provided: --config-http-address")
		os.Exit(1)
	}

	if *dnsAddr == "" {
		fmt.Println("required flag not provided: --lookupd-dns-address")
		os.Exit(1)
	}

	log.SetHandler(text.New(os.Stderr))
	ctx := log.WithFields(log.Fields{
		"cfgAddr": *cfgAddr,
		"dnsAddr": *dnsAddr,
		"ldPort":  *ldPort,
	})

	ips, err := dnscfg.Get(dnsAddr, ldPort)
	if err != nil {
		ctx.WithError(err).Error("dns lookup")
		os.Exit(1)
	}

	if len(ips) == 0 {
		ctx.Error("no ip addresses found")
		os.Exit(1)
	}

	cfgURL := "http://" + *cfgAddr + "/config/nsqlookupd_tcp_addresses"
	err = httpcfg.Set(cfgURL, ips)
	if err != nil {
		ctx.WithError(err).Error("setting config")
	} else {
		ctx.WithField("ips", ips).Info("setting config")
	}

	go configLoop(ctx, cfgURL)

	http.ListenAndServe(":6060", nil)
}
Exemple #12
0
func (m *Markup) addCorrection(correction *Correction) *Correction {
	context := log.WithFields(log.Fields{
		"M": correction.Move,
		"D": correction.Degree,
	})

	for _, one := range m.Corrections {
		if one.Move.Base.P == correction.Move.Base.P &&
			one.Move.End.P == correction.Move.End.P {

			context.Debug("Correction found")
			return one
		}
	}

	context.Debug("+Correction")

	m.Corrections = append(m.Corrections, correction)
	return correction
}
Exemple #13
0
func (m *Markup) addImpulse(impulse *Impulse) *Impulse {

	context := log.WithFields(log.Fields{
		"M": impulse.Move,
		"D": impulse.Degree,
	})

	for _, one := range m.Impulses {
		if one.Move.Base.P == impulse.Move.Base.P &&
			one.Move.End.P == impulse.Move.End.P {

			context.Debug("Impulse found")
			return one
		}
	}

	context.Debug("+Impulse")

	m.Impulses = append(m.Impulses, impulse)
	return impulse
}
Exemple #14
0
func main() {
	esClient := elastic.New("http://192.168.99.101:9200")
	esClient.HTTPClient = &http.Client{
		Timeout: 5 * time.Second,
	}

	e := es.New(&es.Config{
		Client:     esClient,
		BufferSize: 100,
	})

	t := text.New(os.Stderr)

	log.SetHandler(multi.New(e, t))

	ctx := log.WithFields(log.Fields{
		"file": "something.png",
		"type": "image/png",
		"user": "******",
	})

	go func() {
		for range time.Tick(time.Millisecond * 200) {
			ctx.Info("upload")
			ctx.Info("upload complete")
			ctx.Warn("upload retry")
			ctx.WithError(errors.New("unauthorized")).Error("upload failed")
			ctx.Errorf("failed to upload %s", "img.png")
		}
	}()

	go func() {
		for range time.Tick(time.Millisecond * 25) {
			ctx.Info("upload")
		}
	}()

	select {}
}
Exemple #15
0
func main() {
	log.SetHandler(cli.Default)
	log.SetLevel(log.DebugLevel)

	ctx := log.WithFields(log.Fields{
		"file": "something.png",
		"type": "image/png",
		"user": "******",
	})

	go func() {
		for range time.Tick(time.Second) {
			ctx.Debug("doing stuff")
		}
	}()

	go func() {
		for range time.Tick(100 * time.Millisecond) {
			ctx.Info("uploading")
			ctx.Info("upload complete")
		}
	}()

	go func() {
		for range time.Tick(time.Second) {
			ctx.Warn("upload slow")
		}
	}()

	go func() {
		for range time.Tick(2 * time.Second) {
			err := errors.New("boom")
			ctx.WithError(err).Error("upload failed")
		}
	}()

	select {}
}
Exemple #16
0
func main() {
	flag.Parse()

	log.SetHandler(text.New(os.Stderr))

	if *verbose {
		log.SetLevel(log.DebugLevel)
	} else {
		log.SetLevel(log.InfoLevel)
	}

	if _, err := os.Stat(tpl); os.IsNotExist(err) {
		log.WithError(err).Fatal("template provided does not exist")
	}

	ctx := log.WithFields(log.Fields{
		"app": "spacegophers",
	})

	s := NewServer(ctx, *addr, tpl)

	// serve the server
	s.Serve()
}
Exemple #17
0
//Info prints impulse with label
func (i Impulse) Info(label string) {
	log.WithFields(log.Fields{
		"M": i.Move,
		"D": fmt.Sprintf("%3d", i.Degree()),
	}).Info(label)
}
Exemple #18
0
//Info corrections selector
func (w Wave) Info(label string) {
	log.WithFields(log.Fields{
		"M": w.Move,
		"D": w.Degree(),
	}).Info(label)
}