https://grafana.com/docs/mimir/latest/operators-guide/reference-http-api/#rulerHi, all works like a charm, but I'm getting error when upserting dashboard. I'm not even using alerts, so maybe the functionality could be at least optional?

error: could not prepare deletion of previous alerts for dashboard: could not query grafana: {"message":"Not found"} (HTTP status 404)

If I try using cURL right on the particular query for rules:

curl -H "Authorization: Bearer xxx" https://foo.bar/api/ruler/grafana/api/v1/rules?dashboard_uid=ygUo8se7k
{"message":"Not found"}

It looks like the alerts cleanup uses Mimir ruler API?

I'm running self-hosted Grafana instance version 8.4.0 and using latest grabana v0.21.9

Thanks for any pointers

This is a direct copy of the same feature on query variables. Not setting refresh on a datasource variable that uses another variable results in a dashboard that fails to load unless you "re-select" the variable in question.

In some deployments of Grafana, such as at my work (Sourcegraph) basic authentication is more sane than API tokens in e.g. development environments, since it can be automatically provisioned easily.

This adds support for optionally making use of basic auth via a new NewClientBasicAuth method.

Hi all,

I tried following the example code but got the following error.

[ykyuen@camus ci-grafana]$ go run main.go 
Could not create dashboard: could not prepare deletion of previous alerts for dashboard: invalid character '<' looking for beginning of value
exit status 1

I tried on grafana version 7.3.1 and 6.7.1. Both results in the above error but the dashboard is created correctly.

The following is my main.go.

package main

import (
	"context"
	"fmt"
	"net/http"
	"os"

	"github.com/K-Phoen/grabana"
	"github.com/K-Phoen/grabana/dashboard"
	"github.com/K-Phoen/grabana/row"
	"github.com/K-Phoen/grabana/graph"
	"github.com/K-Phoen/grabana/target/prometheus"
	"github.com/K-Phoen/grabana/variable/interval"
)

func main() {
	const GRAFANA_URL = "http://localhost:3000"
	const GRAFANA_API_KEY = "<GRAFANA_API_KEY>"

	ctx := context.Background()
	client := grabana.NewClient(&http.Client{}, GRAFANA_URL, grabana.WithAPIToken(GRAFANA_API_KEY))
	// Create the folder holding the dashboard for the service
	folder, err := client.FindOrCreateFolder(ctx, "Testing")
	if err != nil {
		fmt.Printf("Could not find or create folder: %s\n", err)
		os.Exit(1)
	}
	builder, err := dashboard.New(
		"Awesome dashboard",
		dashboard.AutoRefresh("5s"),
		dashboard.Tags([]string{"generated"}),
		dashboard.VariableAsInterval(
			"interval",
			interval.Values([]string{"30s", "1m", "5m", "10m", "30m", "1h", "6h", "12h"}),
		),
		dashboard.Row(
			"Prometheus",
			row.WithGraph(
				"HTTP Rate",
				graph.DataSource("prometheus-default"),
				graph.WithPrometheusTarget(
					"rate(prometheus_http_requests_total[30s])",
					prometheus.Legend("{{handler}} - {{ code }}"),
				),
			),
		),
	)
	if err != nil {
		fmt.Printf("Could not build dashboard: %s\n", err)
		os.Exit(1)
	}
	dash, err := client.UpsertDashboard(ctx, folder, builder)
	if err != nil {
		fmt.Printf("Could not create dashboard: %s\n", err)
		os.Exit(1)
	}
	fmt.Printf("The deed is done:\n%s\n", GRAFANA_URL + dash.URL)
}

Any idea on what i have missed? Thanks for working on this project.

Regards, Kit

The default limit for results when calling /api/folders is 1000. This increases the limit for client GetFolderByTitle to match that.

See https://grafana.com/docs/grafana/v7.5/http_api/folder/

GetFolderByTitle will still produce unexpected results if there are more than 1000 folders.

In most cases, it's desirable to have an 'interval' variable dropdown sorted by the actual time durations, from lowest to highest rather than a string-based sort.

I'm opting to use the prometheus/common model.ParseDuration function because this includes extended parsing for durations including days (30d), weeks (2w), and years (1y), whereas the stdlib ParseDuration function only supports durations as large as 'hours'.

Before:

After:

Fixes #105

Hey @K-Phoen,

I'm attempting to port some of my existing dashboards to be built using this grabana library and I'm running into an issue with tables.

Expected Behaviour:

• Using table.HideColumn("MyColumn") function, I should be able to hide a table column.

Actual Behaviour:

• The column is never hidden, because the auto-inserted /.*/ "string" rule takes precedence and my column style rule is never evaluated.

Additional Details:

Code:

row.WithTable("Faults",
				table.DataSource("$datasource"),
				table.HideColumn(`/Time/`),
				table.WithPrometheusTarget(`solidfire_cluster_active_faults{sfcluster=~"$cluster"}`,
					prometheus.Instant(),
					prometheus.Format(prometheus.FormatTable),
				),
				table.Span(12),
			),

I should note that I'm currently using Grafana 6.5.1 and v0.13.0 of grabana.

I suspect that this behaviour is happening because of the default rule that gets inserted by the New() function in the table package.

// New creates a new table panel.
func New(title string, options ...Option) *Table {
	panel := &Table{Builder: sdk.NewTable(title)}
	empty := ""

	panel.Builder.IsNew = false
	panel.Builder.TablePanel.Styles = []sdk.ColumnStyle{
		{
			Alias:   &empty,
			Pattern: "/.*/",
			Type:    "string",
		},
	}

	for _, opt := range append(defaults(), options...) {
		opt(panel)
	}

	return panel
}

While building the table with the /.*/ default column style matches what Grafana UI gives us 'out of the box', having no way to remove this top-level rule is blocking me from achieving hiding any column in my table.

If there is a way to remove this tableColumnStyle rule that gets auto-inserted please let me know. If there is no way right now, does the library require additional methods to 'reset' the table columns (or similar functionality?).

This adds support for setting the default time range and timezone of dashboards.

This is useful to e.g. ensure dashboards are all UTC in order to match system logs and other monitoring tools.

BC everywhere, heavy WIP

Todo:

• [x] unit tests for stat panel
• [x] unit tests for alerts
• [x] unit tests for client
• [x] stat panel YAML decoding
• [x] unit tests for stat panel decoding

In this pull request I did this:

• Implemented GetDashboardByTitle. Its functionality is very similar to that of GetFolderByTitle
• Added more fields to the Dashboard struct for the API to return

You can try it out by doing this:

db, err := client.GetDashboardByTitle(ctx, "Awesome Dashboard")

if err != nil {
	fmt.Printf("Could not find dashboard: %s\n", err)
	os.Exit(1)
}

fmt.Println(db)

The above query returns *Dashboard and error

Using the client we are able to find if a folder exists. Likewise, It would be great if we could query whether a dashboard already exists.

It could be accomplished with two functions like this:

// This function queries the /api/search endpoint and returns the dashboard if it exists
func (client *Client) getDashboardByTitle(ctx context.Context, title string) (*DashboardQuery, error) {
	// 1. make a request to search for the dash board
	query := fmt.Sprintf("/api/search?query=%s", title)
	resp, err := client.get(ctx, query)

	if err != nil {
		err1 := fmt.Errorf("grafput: getDashboardByTitle %s", err)
		return nil, err1
	}

	// 2. check the status code
	if resp.StatusCode != http.StatusOK {
		body, err := ioutil.ReadAll(resp.Body)
		if err != nil {
			err1 := fmt.Errorf("grafput: getDashboardByTitle: %s", err)
			return nil, err1
		}

		return nil, fmt.Errorf("could not read body after querying dashboard: %s (HTTP status %d)", body, resp.StatusCode)
	}

	defer func() { _ = resp.Body.Close() }()

	// 3. decode json using our Dashboard Query struct
	var dashboard []DashboardQuery
	if err := decodeJSON(resp.Body, &dashboardQuery); err != nil {
		err1 := fmt.Errorf("grafput: getDashboardByTitle: %s", err)
		return nil, err1
	}

	if len(dashboardQuery) == 0 {
		return nil, nil
	}

	// 4. iterate through the list of dashboards until we match title
	for i := range dashboardQuery {
		if strings.EqualFold(dashboardQuery[i].Title, title) {
			return &dashboardQuery[i], nil
		}
	}

	return nil, nil
}

// This function enables us to search Grafana for a dashboard by its title
func (client *Client) CheckIfDashboardExists(ctx context.Context, title string) (string, error) {
	dashboard, err := client.getDashboardByTitle(ctx, title)
	if err != nil {
		err1 := fmt.Errorf("grafput: CheckIfDashboard Exists: %s", err)
		return "", err1
	}

	if dashboard == nil {
		return "", nil
	}

	dashboardUrl := dashboard.Url

       // here we could return the dashboard object or the URL 
	return dashboardUrl, nil
}

type DashboardQuery struct {
	Id          int      `json:"id"`
	Uid         string   `json:"uid"`
	Title       string   `json:"title"`
	Uri         string   `json:"uri"`
	Url         string   `json:"url"`
	Slug        string   `json:"slug"`
	Type        string   `json:"type"`
	Tags        []string `json:"tags"`
	IsStarred   bool     `json:"isStarred"`
	FolderId    int      `json:"folderId"`
	FolderUid   string   `json:"folderUid"`
	FolderTitle string   `json:"folderTitle"`
	FolderUrl   string   `json:"folderUrl"`
	SortMeta    int      `json:"sortMeta"`
}

Signed-off-by: Martin Chodur [email protected]

Hi, this would make managing dashboards possible with the grabana client without necessarily using the grabana builder API (which does not support all properties of Grafana dashboard JSON) and create/manage also dashboards created using the sdk directly WDYT?

Hi, I see there is no support for gridPos for panels, this is not even in the SDK. Only the old span parameter.

Interesting is that the grafana-tools/sdk supports this, I'm not sure how much is your fork of the SDK different from the original repo, but in some things it looks like the original one is a bit more up to date with the upstream dashboard JSON model. Is there any particular reason that the fork is used? :thinking:

I see the sdk supports the stacking configuration but unfortunately it's not possible to set it using Grabana

It would be great if this would be possible.

Hi, in newer versions of Grafana if you want to use the Heatmap from Prometheus histogram you need to set the heatmap to "calculate": true, otherwise it does not work.

Could it be added to the heatmap options? :pray: