plugeth/cmd/geth/monitorcmd.go

package main

import (
	"reflect"
	"sort"
	"strings"
	"time"

	"github.com/codegangsta/cli"
	"github.com/ethereum/go-ethereum/cmd/utils"
	"github.com/ethereum/go-ethereum/rpc"
	"github.com/ethereum/go-ethereum/rpc/codec"
	"github.com/ethereum/go-ethereum/rpc/comms"
	"github.com/gizak/termui"
)

// monitor starts a terminal UI based monitoring tool for the requested metrics.
func monitor(ctx *cli.Context) {
	var (
		client comms.EthereumClient
		args   []string
		err    error
	)
	// Attach to an Ethereum node over IPC or RPC
	if ctx.Args().Present() {
		// Try to interpret the first parameter as an endpoint
		client, err = comms.ClientFromEndpoint(ctx.Args().First(), codec.JSON)
		if err == nil {
			args = ctx.Args().Tail()
		}
	}
	if !ctx.Args().Present() || err != nil {
		// Either no args were given, or not endpoint, use defaults
		cfg := comms.IpcConfig{
			Endpoint: ctx.GlobalString(utils.IPCPathFlag.Name),
		}
		args = ctx.Args()
		client, err = comms.NewIpcClient(cfg, codec.JSON)
	}
	if err != nil {
		utils.Fatalf("Unable to attach to geth node - %v", err)
	}
	defer client.Close()

	xeth := rpc.NewXeth(client)

	// Retrieve all the available metrics and resolve the user pattens
	metrics, err := xeth.Call("debug_metrics", []interface{}{true})
	if err != nil {
		utils.Fatalf("Failed to retrieve system metrics: %v", err)
	}
	monitored := resolveMetrics(metrics, args)
	sort.Strings(monitored)

	// Create the access function and check that the metric exists
	value := func(metrics map[string]interface{}, metric string) float64 {
		parts, found := strings.Split(metric, "/"), true
		for _, part := range parts[:len(parts)-1] {
			metrics, found = metrics[part].(map[string]interface{})
			if !found {
				utils.Fatalf("Metric not found: %s", metric)
			}
		}
		if v, ok := metrics[parts[len(parts)-1]].(float64); ok {
			return v
		}
		utils.Fatalf("Metric not float64: %s", metric)
		return 0
	}
	// Assemble the terminal UI
	if err := termui.Init(); err != nil {
		utils.Fatalf("Unable to initialize terminal UI: %v", err)
	}
	defer termui.Close()

	termui.UseTheme("helloworld")

	charts := make([]*termui.LineChart, len(monitored))
	for i, metric := range monitored {
		charts[i] = termui.NewLineChart()
		charts[i].Border.Label = metric
		charts[i].Data = make([]float64, 512)
		charts[i].DataLabels = []string{""}
		charts[i].Height = termui.TermHeight() / len(monitored)
		charts[i].AxesColor = termui.ColorWhite
		charts[i].LineColor = termui.ColorGreen

		termui.Body.AddRows(termui.NewRow(termui.NewCol(12, 0, charts[i])))
	}
	termui.Body.Align()
	termui.Render(termui.Body)

	refresh := time.Tick(time.Second)
	for {
		select {
		case event := <-termui.EventCh():
			if event.Type == termui.EventKey && event.Ch == 'q' {
				return
			}
			if event.Type == termui.EventResize {
				termui.Body.Width = termui.TermWidth()
				for _, chart := range charts {
					chart.Height = termui.TermHeight() / len(monitored)
				}
				termui.Body.Align()
				termui.Render(termui.Body)
			}
		case <-refresh:
			metrics, err := xeth.Call("debug_metrics", []interface{}{true})
			if err != nil {
				utils.Fatalf("Failed to retrieve system metrics: %v", err)
			}
			for i, metric := range monitored {
				charts[i].Data = append([]float64{value(metrics, metric)}, charts[i].Data[:len(charts[i].Data)-1]...)
			}
			termui.Render(termui.Body)
		}
	}
}

// resolveMetrics takes a list of input metric patterns, and resolves each to one
// or more canonical metric names.
func resolveMetrics(metrics map[string]interface{}, patterns []string) []string {
	res := []string{}
	for _, pattern := range patterns {
		res = append(res, resolveMetric(metrics, pattern, "")...)
	}
	return res
}

// resolveMetrics takes a single of input metric pattern, and resolves it to one
// or more canonical metric names.
func resolveMetric(metrics map[string]interface{}, pattern string, path string) []string {
	var ok bool

	// Build up the canonical metric path
	parts := strings.Split(pattern, "/")
	for len(parts) > 1 {
		if metrics, ok = metrics[parts[0]].(map[string]interface{}); !ok {
			utils.Fatalf("Failed to retrieve system metrics: %s", path+parts[0])
		}
		path += parts[0] + "/"
		parts = parts[1:]
	}
	// Depending what the last link is, return or expand
	switch metric := metrics[parts[0]].(type) {
	case float64:
		// Final metric value found, return as singleton
		return []string{path + parts[0]}

	case map[string]interface{}:
		return expandMetrics(metric, path+parts[0]+"/")

	default:
		utils.Fatalf("Metric pattern resolved to unexpected type: %v", reflect.TypeOf(metric))
		return nil
	}
}

// expandMetrics expands the entire tree of metrics into a flat list of paths.
func expandMetrics(metrics map[string]interface{}, path string) []string {
	// Iterate over all fields and expand individually
	list := []string{}
	for name, metric := range metrics {
		switch metric := metric.(type) {
		case float64:
			// Final metric value found, append to list
			list = append(list, path+name)

		case map[string]interface{}:
			// Tree of metrics found, expand recursively
			list = append(list, expandMetrics(metric, path+name+"/")...)

		default:
			utils.Fatalf("Metric pattern %s resolved to unexpected type: %v", path+name, reflect.TypeOf(metric))
			return nil
		}
	}
	return list
}