main 83f856f

_examples/fiber is broken

I want to zoom out and explore more metrics in the past. Can you please provide such feature?

How to register statviz into echo instance?

See https://github.com/plotly/plotly.js/pull/6574/files#diff-34e0af7d37f2e01e228d823f1edaf08b008458cc64ac14a17e02129917af7716

If you use long polling, you will have the following advantages:
better compatibility
The server does not have multiple sets of time.Tick
Have smaller dependencies

Is it somehow possible to use this package with fasthttp as HTTP wrapper in combination with fasthttp-routing?

Because I really like the project and really want to integrate it into one of my projects which bases on these packages.

Custom metrics is now easier after new released #75.
But it seems that custom metrics like cpu, memory, io and network etc. must be implemented only inside statsviz's plot package which would be too invasive for the lib itself.
Maybe we can change statsviz's interface for add-on metrics using http package's middleware pattern?

Hi,

I tested with Firefox (103.0.2 Arch Linux (64 bits)) and Chromium (104.0.5112.79 Arch Linux (64 bits)). It works perfectly with Chromium but in Firefox, the graphs are not "responsive" and end up in-line.

Left - Firefox
Right - Chromium

Is there any example to use statsviz with https://github.com/beego/beego？

If statsviz cannot help is there a alternative?

Package level doc string don't reflect the new API

代码如下：

package handler

import (
	"net/http/pprof"

	"github.com/arl/statsviz"
	"github.com/beego/beego/v2/server/web"
	"github.com/beego/beego/v2/server/web/context"
)

func init() {
	// web.Router(defaultPprofPrefix, &PprofController{}, "*:Index")
	web.AutoPrefix(defaultPprofPrefix, &PprofController{})
	// web.Router(defaultStatsvizPrefix, &PprofController{}, "*:StatIndex")
	// web.Router(defaultStatsvizPrefix+":path([\\w]+)", &PprofController{}, "*:StatPath")
	// web.Router(defaultStatsvizPrefix+"ws", &PprofController{}, "*:StatWs")

	web.Any("/debug/pprof/", func(ctx *context.Context) {
		pprof.Index(ctx.ResponseWriter, ctx.Request)
	})

	web.Any(defaultStatsvizPrefix, func(ctx *context.Context) {
		statsviz.Index.ServeHTTP(ctx.ResponseWriter, ctx.Request)
	})

	web.Any(defaultStatsvizPrefix+":path([\\w]+)", func(ctx *context.Context) {
		statsviz.Index.ServeHTTP(ctx.ResponseWriter, ctx.Request)
	})

	web.Any(defaultStatsvizPrefix+"ws", func(ctx *context.Context) {
		statsviz.Ws.ServeHTTP(ctx.ResponseWriter, ctx.Request)
	})
}

错误提示：

compile on windows and can not show UI

Plotly already handles exporting plots as png.

At the moment, the whole plotly bar that normally shows at the top of each plot has been disabled.
We should re-enable it but only keeping the save plot image button.

Chi is is a lightweight router for HTTP services, 100% compatible with net/http. Should be awesome to get an example with it, something like (following the gorilla/mux example):

r := chi.NewRouter()
r.Get("/debug/statsviz/ws", statsviz.Ws)
r.Handle("/debug/statsviz/", statsviz.Index)

the main process may be killed and then restarted while developing. but therefore the webpage stopped receiving metrics from the process? so can you please make the webpage reconnect the backend automatically after the restart?

Can statsviz be used to show history runtime metric stored in external tsdb ?

Otherwise the stats is gone after a restart.

func SendFrequency(freq time.Duration) OptionFunc {
	return func(s *server) error {
		s.freq = freq
		return nil
	}
}

func sendStats(conn *websocket.Conn) error {
	tick := time.NewTicker(defaultSendFrequency)
	defer tick.Stop()

	var stats stats
	for {
		select {
		case <-tick.C:
			runtime.ReadMemStats(&stats.Mem)
			stats.NumGoroutine = runtime.NumGoroutine()
			if err := conn.WriteJSON(stats); err != nil {
				return err
			}
		}
	}
}

sendStats always use defaultSendFrequency, instead of server.freq.
so that SendFrequency does nothing.

Hi,

When I build a project with go version 1.21.5 the process is killed with signal: killed after 1 or 2 seconds.
I can't catch the signal with signal.Notify, as of yet I have not found any workaround, or fix for this.

It can be reproduced with the basic example.

However when I build the project with go version 1.20.7 everything works as expected.

I'll try to dig more into this when I have time. But someone more familiar with this codebase probably could find the problem faster.

Currently there's a CI check to build all examples
That's not enough (see #58) , we should also check examples work

We're currently using a linear Y axis, which makes low size classes difficulty visible, if not hidden.

linear (default):

log 10

Switching to a log 10 axis improves that, but makes the highest size classes barely visible.

log 10 axis is obtained by setting the axis type to log in Plotly.

layout: {
    yaxis: {
        title: 'size classes',
        type: 'log', 
    },
},

log 2 ?

Using log 2 could help, but would require manual tick creation (see this plotly issue).

equal heights?

Another possibility is to give each bucket the same height, independently of the actual size class it represents.
Doc

Thanks for this tool, it's really useful for debug.

Could it be possible to add custom metrics and not only those expose by runtime?

I'm developping an application and it exposes a lot of internal metrics.

Thank.

/debug/statsviz/libs/js/tippy-bundle.umd.min.js.map 404 Not Found
/debug/statsviz/libs/js/bootstrap-toggle.min.js.map 404 Not Found
/debug/statsviz/libs/js/popper.min.js.map 404 Not Found
/debug/statsviz/libs/js/bootstrap.bundle.min.js.map 404 Not Found

https://github.com/daheige/statsviz/blob/master/statsviz.go#L87

After this operation, the timer will not leak before the function exits. Especially before the service exits smoothly, it is recommended to clean up the timer here.

fix it like this:
tick := time.NewTicker(defaultSendPeriod)
defer tick.Stop()

Open 2 or more pages and you will see the phenomenon

code like this:

statsviz.NewServer(statsviz.TimeseriesPlot(func() statsviz.TimeSeriesPlot {
        plot, _ := statsviz.TimeSeriesPlotConfig{
            Name:  "testCall",
            Title: "testCall",
            Type:  statsviz.Scatter,
            Series: []statsviz.TimeSeries{{
                Name:     "call",
                GetValue: func() float64 {
                    println("call",time.Now().Format(time.DateTime))
                    return float64(0)
                },
            }},
        }.Build()
        return plot
    }()))

Here's the log with 3 pages opened

First, thank you for the great tool! It really helps to visualize and analyze runtime stats

I noticed that package websocket is a copy of github.com/gorilla/websocket. I would suggest to remove it from the repo and add to go.mod file. Even if there are some changes, it's better to create a fork. What do you say?

If you are using Gin, I hope the following content can help you:

router = gin.New()
router.GET("/debug/statsviz/*filepath", func(context *gin.Context) {
	if context.Param("filepath") == "/ws" {
		statsviz.Ws(context.Writer, context.Request)
		return
	}
	statsviz.IndexAtRoot("/debug/statsviz").ServeHTTP(context.Writer, context.Request)
})
router.Run(":8080")

Failed example

Fail one: "Not Found."

router = gin.New()
router.GET("/debug/statsviz/ws", gin.WrapF(statsviz.Ws))
router.GET("/debug/statsviz/",  gin.WrapH(statsviz.Index))
router.Run(":8080")

Because /debug/statsviz/ is a static directory, Need to register with router.StaticFS("/more_static", http.Dir("my_file_system"))

gin#serving-static-files

Fail two: "wildcard route conflicts with existing children"

router = gin.New()
router.GET("/debug/statsviz/ws", gin.WrapF(statsviz.Ws))
router.GET("/debug/statsviz/*filepath",  gin.WrapH(statsviz.Index))
router.Run(":8080")

panic: '/ws' in new path '/debug/statsviz/ws' conflicts with existing wildcard '/*filepath' in existing prefix '/debug/statsviz/*filepath'

Related issue:

gin-gonic/gin#2016
gin-gonic/gin#1681

Good debugging tool, hope to help more people.

http://0.0.0.0:8001/debug/statsviz/

http://0.0.0.0:8001/debug/statsviz/ws

ws, err := upgrader.Upgrade(w, r, nil)
		if err != nil {
			return
		}

接口访问 /debug/statsviz/ws HTTP/1.0" 400

Current one is not so easy to read at first glance, it has too many colors, and is probably not vision-impaired friendly at all.

We should probably switch to a monochromatic colorscale (if possible one that is accessible to highest number of users).
See https://medium.com/envoy-design/how-to-design-an-accessible-color-scheme-4a13ca12c92b

It would be nice to be able to add graphs dynamically. For example, we wanted to convert Prometheus metrics to Statsviz graphs, with one graph per Prometheus label value. But the full set of values is not known in advance, so it is not possible to pass all options to statsviz.Register.

It is almost possible to do now by creating Statsviz HTTP handler on the fly in the other HTTP handler:

// pseudocode
http.HandleFunc("/debug/graphs", func(rw http.ResponseWriter, req *http.Request) {
	s, _ := statsviz.NewServer()
	s.Index().ServeHTTP(rw, req)
})

Unfortunately, there are two handlers: Index() and Ws(). Maybe it is possible to create a single handler that would route to one or another based on, say, HTTP headers?

With recent go1.20 and go1.21 metrics, the number of plots is starting to be important.

I think users would benefit from a way to hide and show

• 1. single plots (collapse)
• 2. multiple categories of plots at once

1. each plot would be associated to a category tag, and the dashboard would have a new widgets, allowing to select the hide/show plot categories.

2. on top of each plot there would be a collapse icon (an arrow maybe?) allowing the user to disable a plot.

In addition when a plot is now shown, its plot would not be updated, even though it's circular buffer would continue to get updated, so that when a plot is suddenly activated, its visualized data immediately catches up the plots that remained visible.

Add a dark/light mode switch to the top menu.

The thing is to also change the plot background color when in dark mode.

Bonus point: use system setting, if exists

pretty standard stuff, maybe reuse a template or use a template generator?

Issue template should thank the user and ask them:

• to run go env
• to share Go code
• to explain what they did
• what they were expecting
• what happened instead

PR template should just thank the user and ask them to link the PR to a specific issue (and possibly to have created that issue first)

http://localhost:6060/debug/statsviz/ is ok
http://localhost:6060/debug/statsviz/ws response Bad Request

We should add unit tests to verify the behaviour if we're trying to encode floating points equals to NaN or infinite, whether they come from runtime/metrics (if that's even possible) or more probably, from user provided values