aboutsummaryrefslogtreecommitdiffstats
path: root/cmd/geth/monitorcmd.go
diff options
context:
space:
mode:
Diffstat (limited to 'cmd/geth/monitorcmd.go')
-rw-r--r--cmd/geth/monitorcmd.go180
1 files changed, 180 insertions, 0 deletions
diff --git a/cmd/geth/monitorcmd.go b/cmd/geth/monitorcmd.go
new file mode 100644
index 000000000..2989800f9
--- /dev/null
+++ b/cmd/geth/monitorcmd.go
@@ -0,0 +1,180 @@
+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
+}