// Fetch fetches disk IO metrics from the OS.
func (m *MetricSet) Fetch() ([]common.MapStr, error) {
stats, err := net.IOCounters(true)
if err != nil {
return nil, errors.Wrap(err, "network io counters")
}
var events []common.MapStr
if m.interfaces == nil {
// Include all stats.
for _, counters := range stats {
events = append(events, ioCountersToMapStr(counters))
}
} else {
// Select stats by interface name.
for _, counters := range stats {
name := strings.ToLower(counters.Name)
if _, include := m.interfaces[name]; include {
events = append(events, ioCountersToMapStr(counters))
continue
}
}
}
return events, nil
}
func GetNetStats() string {
v, err := net.IOCounters(false)
format := "bytes_sent=%d bytes_recv=%d packets_sent=%d packets_recv=%d err_in=%d err_out=%d drop_in=%d drop_out=%d"
if err == nil {
return fmt.Sprintf(format, v[0].BytesSent, v[0].BytesRecv, v[0].PacketsSent, v[0].PacketsRecv, v[0].Errin, v[0].Errout, v[0].Dropin, v[0].Dropout)
} else {
return fmt.Sprintf(format, 0, 0, 0, 0, 0, 0, 0, 0)
}
}
// NetworkUsage - list
func NetworkUsage() (NetworkUsageList, error) {
netio, _ := net.IOCounters(true)
time.Sleep(1000 * time.Millisecond) // Sleep 1 second to get kb/s
netioSecondRun, _ := net.IOCounters(true)
ifaces, _ := net.Interfaces()
var usage NetworkUsageList
var validInterfaces []string
for _, iface := range ifaces {
if !stringInSlice("loopback", iface.Flags) {
validInterfaces = append(validInterfaces, iface.Name)
}
}
for _, io := range netio {
if stringInSlice(io.Name, validInterfaces) {
for _, lastio := range netioSecondRun {
if lastio.Name == io.Name {
Inbound := lastio.BytesRecv - io.BytesRecv
InboundKB, _ := util.ConvertBytesTo(Inbound, "kb", 0)
Outbound := lastio.BytesSent - io.BytesSent
OutboundKB, _ := util.ConvertBytesTo(Outbound, "kb", 0)
n := NetworkStruct{
Name: io.Name,
Inbound: InboundKB,
Outbound: OutboundKB,
}
usage = append(usage, n)
}
}
}
}
return usage, nil
}
func NetIfs(ifacePrefix []string) ([]*NetIf, error) {
netifs := make([]*NetIf, 0)
list, err := net.IOCounters(true)
if err != nil {
return nil, err
}
for _, v := range list {
N := NetIf{
v.Name, int64(v.BytesRecv), int64(v.PacketsRecv),
int64(v.Errin), int64(v.Dropin), 0, 0, 0, 0, int64(v.BytesSent),
int64(v.PacketsSent), int64(v.Errout), int64(v.Dropout), 0, 0, 0, 0,
int64(v.BytesRecv + v.BytesSent), int64(v.PacketsRecv + v.PacketsSent),
int64(v.Errin + v.Errout), int64(v.Dropin + v.Dropout), 0, 0, 0,
}
netifs = append(netifs, &N)
}
return netifs, nil
}
func netIOCounters(nss []core.Namespace) ([]plugin.MetricType, error) {
// gather accumulated metrics for all interfaces
netsAll, err := net.IOCounters(false)
if err != nil {
return nil, err
}
// gather metrics per nic
netsNic, err := net.IOCounters(true)
if err != nil {
return nil, err
}
results := []plugin.MetricType{}
for _, ns := range nss {
// set requested metric name from last namespace element
metricName := ns.Element(len(ns) - 1).Value
// check if requested metric is dynamic (requesting metrics for all nics)
if ns[3].Value == "*" {
for _, net := range netsNic {
// prepare namespace copy to update value
// this will allow to keep namespace as dynamic (name != "")
dyn := make([]core.NamespaceElement, len(ns))
copy(dyn, ns)
dyn[3].Value = net.Name
// get requested metric value
val, err := getNetIOCounterValue(&net, metricName)
if err != nil {
return nil, err
}
metric := plugin.MetricType{
Namespace_: dyn,
Data_: val,
Timestamp_: time.Now(),
Unit_: netIOCounterLabels[metricName].unit,
}
results = append(results, metric)
}
} else {
stats := append(netsAll, netsNic...)
// find stats for interface name or all nics
stat := findNetIOStats(stats, ns[3].Value)
if stat == nil {
return nil, fmt.Errorf("Requested interface %s not found", ns[3].Value)
}
// get value for requested metric
val, err := getNetIOCounterValue(stat, metricName)
if err != nil {
return nil, err
}
metric := plugin.MetricType{
Namespace_: ns,
Data_: val,
Timestamp_: time.Now(),
Unit_: netIOCounterLabels[metricName].unit,
}
results = append(results, metric)
}
}
return results, nil
}
func main() {
fmt.Println("Hello RGB-spear")
ser, err := serial.OpenPort(&serial.Config{
Name: flagPort,
Baud: 9600,
})
if err != nil {
panic(err)
}
defer ser.Close()
defer ser.Flush()
fmt.Println("Wating 10 seconds for booting...")
time.Sleep(10 * time.Second)
spr = new(Spear)
// RED for cpu
if flagCPU {
fmt.Println("Enable CPU")
go func() {
for {
c, err := cpu.Percent(100*time.Millisecond, false)
if err != nil {
panic(err)
}
t := byte((c[0] * 255) / 100)
spr.Lock()
spr.R = t
// log.Println("R->", spr.R)
spr.Unlock()
time.Sleep(300 * time.Millisecond)
}
}()
}
// Green for memory
if flagMEM {
fmt.Println("Enable MEM")
go func() {
for {
v, err := mem.VirtualMemory()
if err != nil {
panic(err)
}
t := byte((v.UsedPercent * 255) / 100)
spr.Lock()
spr.G = t
// log.Println("G->", spr.R)
spr.Unlock()
time.Sleep(300 * time.Millisecond)
}
}()
}
// Blue for network
if flagNET {
fmt.Println("Enable Network")
go func() {
lastSent, lastRecv := uint64(0), uint64(0)
for {
c, err := net.IOCounters(false)
if err != nil {
panic(err)
}
currSent := c[0].BytesSent
currRecv := c[0].BytesRecv
sent := currSent - lastSent
recv := currRecv - lastRecv
t := byte(((sent + recv) * 255) / 1000000)
spr.Lock()
spr.B = t
spr.Unlock()
time.Sleep(1 * time.Second)
lastSent = currSent
lastRecv = currRecv
}
}()
t := time.NewTicker(100 * time.Millisecond)
for {
select {
case <-t.C:
fmt.Fprint(ser, spr)
// log.Println("spr:", spr)
ser.Flush()
}
}
}
}
func (s *systemPS) NetIO() ([]net.IOCountersStat, error) {
return net.IOCounters(true)
}
func netMetrics(cycle int) []*types.TimeSeriesData {
cnt, err := net.IOCounters(true)
if err != nil {
return nil
}
ts := time.Now().Unix()
metrics := []*types.TimeSeriesData{}
for _, v := range cnt {
if NameNotAvalid(v.Name) {
continue
}
metrics = append(metrics,
&types.TimeSeriesData{
Metric: "net.bytessent",
Value: float64(v.BytesSent),
Cycle: cycle,
Timestamp: ts,
DataType: "COUNTER",
Tags: map[string]string{"iface": v.Name},
},
&types.TimeSeriesData{
Metric: "net.bytesrecv",
Value: float64(v.BytesRecv),
Cycle: cycle,
Timestamp: ts,
DataType: "COUNTER",
Tags: map[string]string{"iface": v.Name},
},
&types.TimeSeriesData{
Metric: "net.packetssent",
Value: float64(v.PacketsSent),
Cycle: cycle,
Timestamp: ts,
DataType: "COUNTER",
Tags: map[string]string{"iface": v.Name},
},
&types.TimeSeriesData{
Metric: "net.packetsrecv",
Value: float64(v.PacketsRecv),
Cycle: cycle,
Timestamp: ts,
DataType: "COUNTER",
Tags: map[string]string{"iface": v.Name},
},
&types.TimeSeriesData{
Metric: "net.errin",
Value: float64(v.Errin),
Cycle: cycle,
Timestamp: ts,
DataType: "COUNTER",
Tags: map[string]string{"iface": v.Name},
},
&types.TimeSeriesData{
Metric: "net.errout",
Value: float64(v.Errout),
Cycle: cycle,
Timestamp: ts,
DataType: "COUNTER",
Tags: map[string]string{"iface": v.Name},
},
&types.TimeSeriesData{
Metric: "net.dropin",
Value: float64(v.Dropin),
Cycle: cycle,
Timestamp: ts,
DataType: "COUNTER",
Tags: map[string]string{"iface": v.Name},
},
&types.TimeSeriesData{
Metric: "net.dropout",
Value: float64(v.Dropout),
Cycle: cycle,
Timestamp: ts,
DataType: "COUNTER",
Tags: map[string]string{"iface": v.Name},
},
&types.TimeSeriesData{
Metric: "net.fifoin",
Value: float64(v.Fifoin),
Cycle: cycle,
Timestamp: ts,
DataType: "COUNTER",
Tags: map[string]string{"iface": v.Name},
},
&types.TimeSeriesData{
Metric: "net.fifoout",
Value: float64(v.Fifoout),
Cycle: cycle,
Timestamp: ts,
DataType: "COUNTER",
Tags: map[string]string{"iface": v.Name},
},
)
}
return metrics
}