func main() {
// Initialize the StatsD client
prefix := "test.rob-egan."
statsdclient := statsd.NewStatsdClient(agentServer, prefix)
err := statsdclient.CreateSocket()
if err != nil {
log.Println(err)
os.Exit(1)
}
interval := time.Second * 2 // aggregate stats and flush every 2 seconds
stats := statsd.NewStatsdBuffer(interval, statsdclient)
defer stats.Close()
// Handler functions
http.HandleFunc("/", handler)
http.HandleFunc("/lissajous", func(w http.ResponseWriter, r *http.Request) {
lissajous(w)
})
http.HandleFunc("/debug", debug)
http.HandleFunc("/count", counter)
http.HandleFunc("/help", help)
// The actual web server
log.Print("Starting web server...\n")
log.Print("Point your browser to http://", webServerHost, "/help for more info...\n")
log.Fatal(http.ListenAndServe(webServerHost, nil))
}
func runLoop(redisHost string, redisPort int64, redisDb int64, statsdHost string, statsdPort int64, statsPrefix string, interval int64, queues []string) {
client := redis.NewClient(&redis.Options{
Addr: fmt.Sprintf("%s:%d", redisHost, redisPort),
DB: redisDb,
})
_, connErr := client.Ping().Result()
fmt.Println("connection errors? ", connErr)
statsdClient := statsd.NewStatsdClient(
fmt.Sprintf("%s:%d", statsdHost, statsdPort),
fmt.Sprintf("%s.", statsPrefix),
)
statsdClient.CreateSocket()
stats := statsd.NewStatsdBuffer(time.Second*2, statsdClient)
defer stats.Close()
timeoutInterval := time.Duration(interval) * time.Millisecond
for true {
for _, name := range queues {
go func(oneName string) {
listLength, err := client.LLen(oneName).Result()
stats.Gauge(oneName, listLength)
fmt.Println(oneName, listLength, err)
}(name)
}
time.Sleep(timeoutInterval)
}
}
func (varnishncsa *Varnishncsa) Connect() {
statsdclient := statsd.NewStatsdClient(varnishncsa.StatsdServer, varnishncsa.StatsdPrefix)
statsdclient.CreateSocket()
interval := time.Duration(int(time.Millisecond) * varnishncsa.StatsdSendInterval)
stats := statsd.NewStatsdBuffer(interval, statsdclient)
defer stats.Close()
cmd := exec.Command("varnishncsa", "-F", `%h %l %u %t "%r" %s %b "%{Referer}i" "%{User-agent}i" %{Varnish:time_firstbyte}x`)
stdout, outerr := cmd.StdoutPipe()
if outerr != nil {
log.Fatal(outerr)
}
err := cmd.Start()
if err != nil {
log.Fatal(err)
}
scanner := bufio.NewScanner(stdout)
for scanner.Scan() {
r := Record{scanner.Text(), stats, varnishncsa.RecordRegex}
r.Process()
}
if err := scanner.Err(); err != nil {
fmt.Fprintln(os.Stderr, "There was an error with the scanner attached to varnishncsa", err)
}
cmd.Wait()
}
// CreateStatsdClient creates a local instances of a statsd client. Any errors will be logged to
// console and ignored.
func CreateStatsdClient(statsdURL, statsdPrefix string) error {
lock.Lock()
defer lock.Unlock()
if stats != noopClient {
// Already initialized. Don't overwrite
return nil
}
if statsdURL != "" {
hostname, err := os.Hostname()
if err != nil {
log.Printf("Could not read hostname. Using default noop statsd client: %s", err)
return err
}
prefix := fmt.Sprintf("%s.%s.artifacts.", statsdPrefix, hostname)
statsdClient := statsd.NewStatsdClient(statsdURL, prefix)
if statsdClient != nil {
stats = statsd.NewStatsdBuffer(updateInterval, statsdClient)
}
} else {
log.Println("No statsd URL provided. Using default noop statsd client")
}
return nil
}
func InitStatsd(ch chan *map[string]map[string]int64, conf *StatsdConfig) error {
go func() {
statsdclient := statsd.NewStatsdClient(conf.Host, conf.Prefix)
statsdclient.CreateSocket()
interval, err := time.ParseDuration(conf.Interval)
if err != nil {
Conf.Logger.Fatalf("can't parse interval %+v", err)
}
stats := statsd.NewStatsdBuffer(interval, statsdclient)
defer stats.Close()
for data := range statsdCh {
for op, values := range *data {
for key, val := range values {
switch op {
case "increment":
debug("send incr", key, val)
go stats.Incr(key, val)
case "timing":
debug("send timing", key, val)
go stats.Timing(key, val)
case "gauge":
debug("send gauge", key, val)
go stats.Gauge(key, val)
}
}
}
}
}()
return nil
}
func initStatsd(address string, prefix string) *statsd.StatsdBuffer {
statsdclient := statsd.NewStatsdClient(address, prefix)
statsdclient.CreateSocket()
interval := time.Second * 10 // aggregate stats and flush every 2 seconds
stats := statsd.NewStatsdBuffer(interval, statsdclient)
return stats
}
func mustStartStatsd(host string, prefix string, frequency time.Duration) *statsd.StatsdBuffer {
sClient := statsd.NewStatsdClient(opts.StatsDHost, opts.StatsDPrefix)
if err := sClient.CreateSocket(); err != nil {
log.WithField("error", err).Fatal("could not open socket to statsd")
}
return statsd.NewStatsdBuffer(opts.statsdFrequency, sClient)
}
func main() {
setupHTTP()
uaaURL, err := url.Parse(uaa)
if nil != err {
panic("Failed to parse uaa url!")
}
creds, err := uaaclientcredentials.New(uaaURL, true, clientID, clientSecret)
if nil != err {
panic("Failed to obtain creds!")
}
consumer := noaa.NewConsumer(dopplerAddress, &tls.Config{InsecureSkipVerify: true}, nil)
httpStartStopProcessor := processors.NewHttpStartStopProcessor()
sender := statsd.NewStatsdClient(statsdAddress, statsdPrefix)
sender.CreateSocket()
var processedMetrics []metrics.Metric
msgChan := make(chan *events.Envelope)
go func() {
defer close(msgChan)
errorChan := make(chan error)
token, err := creds.GetBearerToken()
if nil != err {
panic(err)
}
go consumer.Firehose(firehoseSubscriptionID, token, msgChan, errorChan, nil)
for err := range errorChan {
fmt.Fprintf(os.Stderr, "%v\n", err.Error())
}
}()
for msg := range msgChan {
eventType := msg.GetEventType()
switch eventType {
case events.Envelope_HttpStartStop:
processedMetrics = httpStartStopProcessor.Process(msg)
default:
atomic.AddUint64(&count, 1)
// do nothing
}
if len(processedMetrics) > 0 {
for _, metric := range processedMetrics {
metric.Send(sender)
}
}
processedMetrics = nil
}
}
func getStatsdBuffer(host string) (*statsd.StatsdBuffer, error) {
statsdclient := statsd.NewStatsdClient(host, "aws.sqs.")
if err := statsdclient.CreateSocket(); err != nil {
log.WithField("error", err).Warn("unable to open socket for statsd")
return nil, err
}
return statsd.NewStatsdBuffer(time.Minute, statsdclient), nil
}
func NewStatsdClient(simulationPrefix string) *StatsdClient {
statsdClient := statsd.NewStatsdClient("localhost:8125", simulationPrefix)
statsdClient.CreateSocket()
interval := time.Second * 2
stats := statsd.NewStatsdBuffer(interval, statsdClient)
return &StatsdClient{
Stats: stats,
}
}
func ConnectToURL(s string, prefix string) (c *statsd.StatsdClient, err error) {
statsdUrl, err := url.Parse(s)
if err != nil {
return nil, err
}
c = statsd.NewStatsdClient(statsdUrl.Host, prefix)
err = c.CreateSocket()
return c, err
}
func main() {
consumer := noaa.NewConsumer(DopplerAddress, &tls.Config{InsecureSkipVerify: true}, nil)
httpStartStopProcessor := processors.NewHttpStartStopProcessor()
valueMetricProcessor := processors.NewValueMetricProcessor()
containerMetricProcessor := processors.NewContainerMetricProcessor()
heartbeatProcessor := processors.NewHeartbeatProcessor()
counterProcessor := processors.NewCounterProcessor()
sender := statsd.NewStatsdClient(statsdAddress, statsdPrefix)
sender.CreateSocket()
var processedMetrics []metrics.Metric
msgChan := make(chan *events.Envelope)
go func() {
defer close(msgChan)
errorChan := make(chan error)
go consumer.Firehose(firehoseSubscriptionId, authToken, msgChan, errorChan, nil)
for err := range errorChan {
fmt.Fprintf(os.Stderr, "%v\n", err.Error())
}
}()
for msg := range msgChan {
eventType := msg.GetEventType()
// graphite-nozzle can handle CounterEvent, ContainerMetric, Heartbeat,
// HttpStartStop and ValueMetric events
switch eventType {
case events.Envelope_ContainerMetric:
processedMetrics = containerMetricProcessor.Process(msg)
case events.Envelope_CounterEvent:
processedMetrics = counterProcessor.Process(msg)
case events.Envelope_Heartbeat:
processedMetrics = heartbeatProcessor.Process(msg)
case events.Envelope_HttpStartStop:
processedMetrics = httpStartStopProcessor.Process(msg)
case events.Envelope_ValueMetric:
processedMetrics = valueMetricProcessor.Process(msg)
default:
// do nothing
}
if len(processedMetrics) > 0 {
for _, metric := range processedMetrics {
metric.Send(sender)
}
}
processedMetrics = nil
}
}
func (driver *QuipoStatsdDriver) Initialize(connectionString string) error {
client := quipo.NewStatsdClient(connectionString, "")
err := client.CreateSocket()
if err != nil {
return err
}
driver.conn = client
driver.connectionString = connectionString
return nil
}
func main() {
fmt.Println("Starting eISCP (ethernet Integra Serial Communication Protocol) Gateway")
// Command line options
flag.BoolVar(&debug, "debug", false, "enable verbose debugging")
flag.BoolVar(&statsEnabled, "stats", false, "enable stats collecting")
flag.StringVar(&defaultDevice, "device", "192.168.2.143", "IP address of device to connect to")
flag.IntVar(&devicePort, "port", 60128, "port on device to commmunicate with")
flag.IntVar(&defaultPort, "serve", 3000, "port to host REST API on")
flag.StringVar(&statsdAddress, "statsd", "localhost:8125", "IP and Port of Statsd server")
flag.StringVar(&statsdPrefix, "prefix", "eiscp", "A prefix prepended to all stats")
// Now that we've defined our flags, parse them
flag.Parse()
if debug {
fmt.Println("Displaying debug output.")
}
// init
statsdclient := statsd.NewStatsdClient(statsdAddress, statsdPrefix)
if statsEnabled {
if debug {
fmt.Println("Attempting connection to statsd")
}
statsdclient.CreateSocket()
interval := time.Second * 2 // aggregate stats and flush every 2 seconds
stats = statsd.NewStatsdBuffer(interval, statsdclient)
defer stats.Close()
}
fmt.Println("Searching for device on port", devicePort, "at", defaultDevice)
// Do our device stuff here
go func() {
for true {
deviceLoop()
}
}()
r := mux.NewRouter()
r.HandleFunc("/kill", HandleKill) //Debug Function
r.HandleFunc("/status/", GetStatus).Methods("GET")
r.HandleFunc("/device/", DeleteDevice).Methods("DELETE")
r.HandleFunc("/device/{ip}/{port}", PutDevice).Methods("PUT")
r.HandleFunc("/device/{property}", GetProperty).Methods("GET")
r.HandleFunc("/device/{property}/{value}", PostProperty).Methods("POST")
http.Handle("/", r)
fmt.Println("REST API listening on port", strconv.Itoa(defaultPort))
http.ListenAndServe(":"+strconv.Itoa(defaultPort), nil)
}
func TestMain(m *testing.M) {
var statsdHost = flag.String("test_statsd_host", "", "Statsd server hostname or IP")
var statsdInterval = flag.Int("test_statsd_interval", 3, "Seconds between metric flush")
var statsdPrefix = flag.String("test_statsd_prefix", "gopassivedns", "statsd metric prefix")
flag.Parse()
if *statsdHost != "" {
statsdclient := statsd.NewStatsdClient(*statsdHost, *statsdPrefix)
stats = statsd.NewStatsdBuffer(time.Duration(*statsdInterval)*time.Second, statsdclient)
}
os.Exit(m.Run())
}
func (s *StatsdPump) connect() *statsd.StatsdClient {
client := statsd.NewStatsdClient(s.dbConf.Address, "")
err := client.CreateSocket()
if err != nil {
log.WithFields(logrus.Fields{
"prefix": statsdPrefix,
}).Error("StatsD connection failed:", err)
time.Sleep(5)
s.connect()
}
return client
}
func BenchmarkQuipoTimingAsDuration(b *testing.B) {
s := newServer()
c := quipo.NewStatsdBuffer(flushPeriod, quipo.NewStatsdClient(addr, prefix))
c.Logger = logger{}
b.StartTimer()
for i := 0; i < b.N; i++ {
c.Incr(counterKey, 1)
c.Gauge(gaugeKey, gaugeValue)
c.PrecisionTiming(timingKey, tValDur)
}
c.Close()
b.StopTimer()
s.Close()
}
func BenchmarkQuipo(b *testing.B) {
s := newServer()
c := quipo.NewStatsdBuffer(flushPeriod, quipo.NewStatsdClient(s.Addr(), prefix))
c.Logger = logger{}
b.ResetTimer()
for i := 0; i < b.N; i++ {
c.Incr(counterKey, 1)
c.Gauge(gaugeKey, gaugeValue)
c.Timing(timingKey, int64(timingValue))
}
c.Close()
s.Close()
}
func main() {
//insert the ENV as defaults here, then after the parse we add the true defaults if nothing has been set
//also convert true/false strings to true/false types
config := initConfig()
if config.cpuprofile != "" {
f, err := os.Create(config.cpuprofile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
}
var stats *statsd.StatsdBuffer = nil
if config.statsdHost != "" {
statsdclient := statsd.NewStatsdClient(config.statsdHost, config.statsdPrefix+"."+config.sensorName+".")
stats = statsd.NewStatsdBuffer(time.Duration(config.statsdInterval)*time.Second, statsdclient)
}
handle := initHandle(config)
if handle == nil {
log.Fatal("Could not initilize the capture.")
}
logOpts := NewLogOptions(config)
logChan := initLogging(logOpts)
reChan := make(chan tcpDataStruct)
//spin up logging thread(s)
go logConn(logChan, logOpts, stats)
//spin up the actual capture threads
doCapture(handle, logChan, config, reChan, stats)
log.Debug("Done! Goodbye.")
os.Exit(0)
}
func InitStatsd(conf interface{}) {
host := conf.(map[string]interface{})["host"].(string)
prefix := ""
_interval := "1s"
if val, ok := conf.(map[string]interface{})["prefix"].(string); ok {
prefix = val
}
if val, ok := conf.(map[string]interface{})["interval"].(string); ok {
_interval = val
}
statsdclient := statsd.NewStatsdClient(host, prefix)
statsdclient.CreateSocket()
interval, err := time.ParseDuration(_interval)
if err != nil {
Conf.Logger.Fatalf("can't parse interval %+v", err)
}
stats := statsd.NewStatsdBuffer(interval, statsdclient)
go func() {
defer stats.Close()
Conf.Logger.Println("Statsd queue is starts")
for data := range statsdCh {
for op, values := range *data {
for key, val := range values {
switch op {
case "increment":
debug("send incr", key, val)
go stats.Incr(key, val)
case "timing":
debug("send timing", key, val)
go stats.Timing(key, val)
case "gauge":
debug("send gauge", key, val)
go stats.Gauge(key, val)
}
}
}
}
}()
return
}
func NewMasterWithStatsd(host string, workerConfig *WorkerConfig, command, balanceConfigTemplate, balanceConfigFile, digitalOceanToken, digitalOceanImageID string,
overloadedCpuThreshold, underusedCpuThreshold float64, minWorkers, maxWorkers int64, pollInterval, cooldownInterval, surveyDeadline, queryInterval time.Duration,
scaleNodes, changeWeights bool,
statsdAddr, statsdPrefix string, statsdInterval time.Duration) *Master {
master := NewMaster(
host, workerConfig, command,
balanceConfigTemplate, balanceConfigFile,
digitalOceanToken, digitalOceanImageID,
overloadedCpuThreshold, underusedCpuThreshold,
minWorkers, maxWorkers,
pollInterval, cooldownInterval, surveyDeadline, queryInterval,
scaleNodes, changeWeights,
)
statsdClient := statsd.NewStatsdClient(statsdAddr, statsdPrefix)
statsdClient.CreateSocket()
master.statsdClientBuffer = statsd.NewStatsdBuffer(statsdInterval, statsdClient)
return master
}
func NewMetricsManager(givenQueueManager *queueManager) *MetricsManager {
m := MetricsManager{}
m.queueManager = givenQueueManager
m.metricsChannel = make(chan *Metric, 100)
if Configuration.StatsDEndpoint != "" {
m.statsdEnabled = true
statsClient := statsd.NewStatsdClient(Configuration.StatsDEndpoint, "gamq.")
statsClient.CreateSocket()
interval := time.Second
m.statsBuffer = statsd.NewStatsdBuffer(interval, statsClient)
log.Debugf("Initialized StatsD - sending metrics to: %s", Configuration.StatsDEndpoint)
} else {
m.statsdEnabled = false
}
go m.listenForMetrics()
return &m
}
func main() {
// init
prefix := "myproject."
statsdclient := statsd.NewStatsdClient("localhost:8125", prefix)
err := statsdclient.CreateSocket()
if nil != err {
log.Println(err)
os.Exit(1)
}
interval := time.Second * 2 // aggregate stats and flush every 2 seconds
stats := statsd.NewStatsdBuffer(interval, statsdclient)
defer stats.Close()
// not buffered: send immediately
statsdclient.Incr("mymetric", 4)
// buffered: aggregate in memory before flushing
stats.Incr("mymetric", 1)
stats.Incr("mymetric", 3)
stats.Incr("mymetric", 1)
stats.Incr("mymetric", 1)
}
func main() {
c, err := parseArgs()
if err != nil {
log.Fatalf("Error parsing arguments: %s", err.Error())
}
if len(c.logfile) > 0 {
logfile, err := os.OpenFile(c.logfile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
if err != nil {
log.Fatalf("Error opening log file %s: %v", c.logfile, err)
}
defer logfile.Close()
log.SetOutput(logfile)
}
if len(c.statsdServer) > 0 {
c.stats = statsd.NewStatsdClient(c.statsdServer, c.statsdPrefix)
c.stats.CreateSocket()
c.debug("Statsd enabled.")
go c.sendStats()
} else {
c.stats = statsd.NoopClient{}
}
getter := s3getter{region: c.region, bucket: c.bucket, prefix: c.prefix}
c.debug("Fetching zones...")
z, err := c.getZones(getter)
if err != nil {
log.Fatal(err)
}
c.stats.Gauge("zones", int64(len(z)))
c.debug(fmt.Sprintf("Fetched %d zones...", len(z)))
c.debug("Loading zones...")
err = c.loadZones(z)
if err != nil {
log.Fatal(err)
}
c.registerVersionHandler()
c.debug("Starting server...")
c.startServer()
log.Printf("DNS server running on TCP/UDP port %s (v%s)", c.port, version)
c.stats.Incr("started", 1)
doUpdate := make(chan bool)
go func() {
for {
select {
case <-doUpdate:
c.debug("Update signal... fetching updating zones")
case <-time.After(c.update):
c.debug("Update timeout... fetching updating zones")
}
z, err := c.getZones(getter)
if err != nil {
log.Fatal(err)
}
c.debug(fmt.Sprintf("Fetched %d updated zones", len(z)))
if len(z) > 0 {
c.stats.Incr("zoneupdates", int64(len(z)))
c.debug(fmt.Sprintf("Reloading %d zones now", len(z)))
err = c.loadZones(z)
if err != nil {
log.Fatal(err)
}
}
c.debug("Updated zones successfully")
}
}()
sig := make(chan os.Signal)
signal.Notify(sig, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM)
for {
select {
case s := <-sig:
if s == syscall.SIGHUP {
doUpdate <- true
} else {
log.Fatalf("Signal (%d) received, stopping", s)
}
}
}
}
func main() {
log.SetFlags(log.LstdFlags | log.Lshortfile)
cfg := config.Config{}
err := config.LoadConfigurationFromFileAndEnvironment("config.json", &cfg)
if err != nil {
log.Fatal("Could not load configuration file=config.json due to error=", err)
}
//Check for arguments.
if len(os.Args) > 1 {
auth, err := aws.GetAuth(cfg.AWSAccessKey, cfg.AWSSecretKey)
if err != nil {
log.Fatal("Could not load aws authentication")
}
pool := createRedisPool(cfg.RedisHost, cfg.RedisPassword)
conn := pool.Get()
_, err = conn.Do("PING")
if err != nil {
pool = nil
}
ctx := routes.CreateContext(nil, pool, auth, &cfg)
cli.Dispatch(os.Args[1:], ctx)
return
}
// Open up the DB and Redis connections.
db, err := sqlx.Open("postgres", cfg.PostgresConnectionURL)
if err != nil {
log.Fatal("Could not open postgres connection with url=", cfg.PostgresConnectionURL, " error=", err)
}
err = db.Ping()
if err != nil {
log.Fatal("Could not ping postgres connection with url=", cfg.PostgresConnectionURL, " error=", err)
}
pool := createRedisPool(cfg.RedisHost, cfg.RedisPassword)
conn := pool.Get()
_, err = conn.Do("PING")
if err != nil {
log.Fatal("Could not ping redis DB with host=", cfg.RedisHost, " error=", err)
}
client := statsd.NewStatsdClient(cfg.StatsDHost, cfg.StatsDPrefix)
err = client.CreateSocket()
if err != nil {
log.Fatal("Could not create statsd socket with host=", cfg.RedisHost, " error=", err)
}
auth, err := aws.GetAuth(cfg.AWSAccessKey, cfg.AWSSecretKey)
if err != nil {
log.Fatal("Could not load aws authentication")
}
ctx := routes.CreateContext(db, pool, auth, &cfg)
router := mux.NewRouter()
router.NotFoundHandler = http.HandlerFunc(routes.NotFound)
router.HandleFunc("/favicon{suffix}", serveFavicon)
router.HandleFunc("/mstile{suffix}", serveFavicon)
blog.RegisterRoutes(router, ctx)
admin.RegisterRoutes(router, ctx)
gallery.RegisterRoutes(router, ctx)
if cfg.Debug {
debug.RegisterRoutes(router, ctx)
}
go collectStats(db, pool, client)
listeningAddress := fmt.Sprintf("localhost:%d", cfg.Port)
log.Print("Listening on addr=", listeningAddress)
err = http.ListenAndServe(listeningAddress, router)
if err != nil {
log.Print(err)
}
}
func main() {
in := ""
prefix := "MemFlash."
stats := statsd.NewStatsdClient(STATSD_IP+STATSD_PORT, prefix)
err := stats.CreateSocket()
check(err)
//stats:=statsd.NewStatsdBuffer(1*time.Second, statsdclient)
//mc := memcache.New("192.168.99.100:11211")
//fmt.Printf("mc: %T\n", mc)
mydb := memflash.DB{MEM_IP + MEM_PORT, "", nil}
ref := mydb.New()
session, err := mgo.Dial(MONGO_IP + MONGO_PORT)
if err != nil {
panic(err)
}
defer session.Close()
session.SetMode(mgo.Monotonic, true)
c := session.DB("test").C("people")
result := Person{}
// s1 := rand.NewSource(time.Now().UnixNano())
// r1 := rand.New(s1)
start := time.Now()
for i := 0; i < 10000; i++ {
memCh := make(chan bool)
mongoCh := make(chan bool)
timeout := make(chan bool, 1)
fmt.Println("Iteration: ", i)
//time.Sleep(5*time.Millisecond)
start1 := time.Now()
go func() {
time.Sleep(TIMEOUT * time.Millisecond)
timeout <- true
}()
go func(i int) {
item, err := ref.Get(strconv.Itoa(i))
if err == memcache.ErrCacheMiss {
//Cache MISS
}
if item != nil {
//HIT
memCh <- true
}
}(i)
go func(i int) {
err = c.Find(bson.M{"index": strconv.Itoa(i)}).One(&result)
check(err)
//time.Sleep(time.Duration(r1.Intn(5)) * time.Millisecond)
mongoCh <- true
}(i)
select {
case <-memCh:
fmt.Println("Memcache WINS")
fmt.Printf("*** time %s \n ", time.Since(start1))
stats.Gauge("p1", int64(time.Since(start1)))
<-timeout
case <-mongoCh:
fmt.Println("MONGO wins")
fmt.Printf("*** time %s \n ", time.Since(start1))
stats.Gauge("p1", int64(time.Since(start1)))
fmt.Println(int64(time.Since(start1)))
<-timeout
case <-timeout:
fmt.Println("Slow connection")
continue
}
}
fmt.Printf("****** Executed in time %s \n ", time.Since(start))
fmt.Scanf("%s", &in)
}
func main() {
in := ""
memCh := make(chan bool)
mongoCh := make(chan bool)
timeout := make(chan bool, 1)
prefix := "MemFlash."
statsdclient := statsd.NewStatsdClient(STATSD_IP+STATSD_PORT, prefix)
err := statsdclient.CreateSocket()
check(err)
//mc := memcache.New("192.168.99.100:11211")
//fmt.Printf("mc: %T\n", mc)
mydb := memflash.DB{MEM_IP + MEM_PORT, "", nil}
ref := mydb.New()
session, err := mgo.Dial(MONGO_IP + MONGO_PORT)
if err != nil {
panic(err)
}
defer session.Close()
session.SetMode(mgo.Monotonic, true)
c := session.DB("test").C("people")
result := Person{}
start := time.Now()
for i := 0; i < 10000; i++ {
time.Sleep(10 * time.Millisecond)
start1 := time.Now()
go func() {
time.Sleep(3 * time.Second)
timeout <- true
}()
go func(i int) {
item, err := ref.Get(strconv.Itoa(i))
if err == memcache.ErrCacheMiss {
//fmt.Println("CACHE MISS!!!!!")
// err = c.Find(bson.M{"index": strconv.Itoa(i)}).One(&result)
// //fmt.Println(err)
// check(err)
// //log.Println("Mongo Result:", result.Data)
// //fmt.Println("MONGO RES ~~~~~~~~~~~~~~")
// mongoCh <- true
}
if item != nil {
//log.Println("******************* Mem Result:", string(item.Value))
//fmt.Println("HIT")
memCh <- true
}
}(i)
go func(i int) {
err = c.Find(bson.M{"index": strconv.Itoa(i)}).One(&result)
//fmt.Println(err)
check(err)
//log.Println("Mongo Result:", result.Data)
//fmt.Println("MONGO RES ~~~~~~~~~~~~~~")
mongoCh <- true
}(i)
select {
case <-memCh:
fmt.Println("MEMCACHE WINS!!")
fmt.Printf("* time %s \n ", time.Since(start1))
statsdclient.Absolute("p11", int64(time.Since(start1)))
case <-mongoCh:
fmt.Println("MONGO wins xxxxxxxxxxxxxxxxxx")
fmt.Printf("* time %s \n ", time.Since(start1))
statsdclient.Absolute("p11", int64(time.Since(start1)))
case <-timeout:
fmt.Println("TOO SLOW------------------------------------------")
continue
}
}
fmt.Printf("****** Executed in time %s \n ", time.Since(start))
fmt.Scanf("%s", &in)
}
func main() {
kingpin.Parse()
fmt.Println(*uaaEndpoint)
fmt.Println(*username)
fmt.Println(*password)
tokenFetcher := &token.UAATokenFetcher{
UaaUrl: *uaaEndpoint,
Username: *username,
Password: *password,
InsecureSSLSkipVerify: *skipSSLValidation,
}
authToken, err := tokenFetcher.FetchAuthToken()
if err != nil {
fmt.Println(err)
os.Exit(-1)
}
consumer := noaa.NewConsumer(*dopplerEndpoint, &tls.Config{InsecureSkipVerify: *skipSSLValidation}, nil)
httpStartStopProcessor := processors.NewHttpStartStopProcessor()
valueMetricProcessor := processors.NewValueMetricProcessor()
containerMetricProcessor := processors.NewContainerMetricProcessor()
heartbeatProcessor := processors.NewHeartbeatProcessor()
counterProcessor := processors.NewCounterProcessor()
sender := statsd.NewStatsdClient(*statsdEndpoint, *statsdPrefix)
sender.CreateSocket()
var processedMetrics []metrics.Metric
msgChan := make(chan *events.Envelope)
go func() {
defer close(msgChan)
errorChan := make(chan error)
go consumer.Firehose(*subscriptionId, authToken, msgChan, errorChan, nil)
for err := range errorChan {
fmt.Fprintf(os.Stderr, "%v\n", err.Error())
}
}()
for msg := range msgChan {
eventType := msg.GetEventType()
// graphite-nozzle can handle CounterEvent, ContainerMetric, Heartbeat,
// HttpStartStop and ValueMetric events
switch eventType {
case events.Envelope_ContainerMetric:
processedMetrics = containerMetricProcessor.Process(msg)
case events.Envelope_CounterEvent:
processedMetrics = counterProcessor.Process(msg)
case events.Envelope_Heartbeat:
processedMetrics = heartbeatProcessor.Process(msg)
case events.Envelope_HttpStartStop:
processedMetrics = httpStartStopProcessor.Process(msg)
case events.Envelope_ValueMetric:
processedMetrics = valueMetricProcessor.Process(msg)
default:
// do nothing
}
if !*debug {
if len(processedMetrics) > 0 {
for _, metric := range processedMetrics {
var prefix string
if *prefixJob {
prefix = msg.GetJob() + "." + msg.GetIndex()
}
metric.Send(sender, prefix)
}
}
} else {
for _, msg := range processedMetrics {
fmt.Println(msg)
}
}
processedMetrics = nil
}
}
metric = metric[:2] + "bit" + metric[4:]
value = value * 1024 * 8
}
if record[3] != "-" && record[3] != "all" {
// add device name to metric
metric = record[3] + "." + metric
}
metric = strings.Replace(metric, "%", "pct_", -1)
sd.FGauge(metric, value)
return nil
}
var statsdServer = flag.String("d", ":8125", "Destination statsd server address")
var statsdPrefix = flag.String("p", "sar", "Statsd prefix for metrics")
var interval = flag.Duration("i", 10*time.Second, "Interval to send metrics")
var sd = statsd.NewStatsdClient(*statsdServer, *statsdPrefix+".")
func main() {
flag.Parse()
err := sd.CreateSocket()
if err != nil {
log.Fatal(err)
}
c := time.Tick(*interval)
for _ = range c {
go getStats()
}
}