Small improvements (#17)

* new grafana notify

* working grafana alerts

* fix mistakes

* blocks update

* change image h*w

* update orgid feild

* fix id remove grafana host

* small fixes, remove channel override

* Причесал код

* Small fixes

Co-authored-by: Aleksandr Borisov <borisov@clickadu.com>

Author: cl-bvl

config/notifiers.go

@@ -399,7 +399,8 @@ type SlackConfigV2 struct {
 	Token        Secret         `yaml:"token,omitempty" json:"token,omitempty"`
 	GrafanaToken Secret         `yaml:"grafana_token,omitempty" json:"grafana_token,omitempty"`
 	UserToken    Secret         `yaml:"user_token,omitempty" json:"user_token,omitempty"`
-	GrafanaHost  string         `yaml:"grafana_host,omitempty" json:"grafana_host,omitempty"`
+	GrafanaUrl   string         `yaml:"grafana_url,omitempty" json:"grafana_url,omitempty"`
+	GrafanaTZ    string         `yaml:"grafana_tz,omitempty" json:"grafana_tz,omitempty"`
 	Channel      string         `yaml:"channel,omitempty" json:"channel,omitempty"`
 	Color        string         `yaml:"color,omitempty" json:"color,omitempty"`
 	Debug        bool           `yaml:"debug" json:"debug"`

notify/slackV2/grafana.go

@@ -9,127 +9,131 @@ import (
 	"github.com/slack-go/slack"
 	"net/http"
 	url2 "net/url"
+	"path"
 	"strconv"
 	"strings"
 	"time"
 )
 
-func genGrafanaRenderUrl(dash string, panel string, org string, host string) string {
+func genGrafanaRenderUrl(grafanaUrl string, grafanaTZ string, org string, dash string, panel string) (string, error) {
 
-	const unixMinute = 1000 * 60
-	const unixSec = 1000
+	const fromShift = -time.Hour
+	const toShift = -time.Second * 10
 	const imageWidth = "999"
 	const imageHeight = "333"
-	const timeZone = "Europe/Moscow"
 	const urlPath = "/render/d-solo/"
-	const urlScheme = "https"
-
-	url := ""
-
-	if u, err := url2.Parse(""); err == nil {
-		u.Scheme = urlScheme
-		u.Host = host
-		u.Path = urlPath + dash + "/"
-		q := u.Query()
-		q.Set("orgId", org)
-		q.Set("from", strconv.FormatInt(time.Now().UnixMilli()-(unixMinute*60), 10))
-		q.Set("to", strconv.FormatInt(time.Now().UnixMilli()-(unixSec*10), 10))
-		q.Set("panelId", panel)
-		q.Set("width", imageWidth)
-		q.Set("height", imageHeight)
-		q.Set("tz", timeZone)
-		u.RawQuery = q.Encode()
-		url = u.String()
+
+	if grafanaUrl == "" {
+		return "", fmt.Errorf("grafanaUrl is empty")
 	}
-	return url
+
+	u, err := url2.Parse(grafanaUrl)
+	if err != nil {
+		return "", err
+	}
+
+	u.Path = path.Join(u.Path, urlPath, dash)
+	q := u.Query()
+	q.Set("orgId", org)
+	q.Set("from", strconv.Itoa(int(time.Now().Add(fromShift).UnixMilli())))
+	q.Set("to", strconv.Itoa(int(time.Now().Add(toShift).UnixMilli())))
+	q.Set("panelId", panel)
+	q.Set("width", imageWidth)
+	q.Set("height", imageHeight)
+	q.Set("tz", grafanaTZ)
+	u.RawQuery = q.Encode()
+	return u.String(), nil
+
 }
-func genGrafanaUrl(dash string, panel string, org string, host string) string {
 
-	const urlScheme = "https"
+func genGrafanaUrl(grafanaUrl string, org string, dash string, panel string) (string, error) {
 
-	DashUrl := ""
+	if grafanaUrl == "" {
+		return "", fmt.Errorf("grafanaUrl is empty")
+	}
 
-	if u, err := url2.Parse(""); err == nil {
-		u.Scheme = urlScheme
-		u.Host = host
-		u.Path = "d/" + dash
-		q := u.Query()
-		q.Set("orgId", org)
-		if panel != "" {
-			q.Set("viewPanel", panel)
-		}
-		u.RawQuery = q.Encode()
-		DashUrl = u.String()
+	u, err := url2.Parse(grafanaUrl)
+	if err != nil {
+		return "", err
 	}
-	return DashUrl
+
+	u.Path = path.Join(u.Path, "/d/"+dash)
+	q := u.Query()
+	q.Set("orgId", org)
+	if panel != "" {
+		q.Set("viewPanel", panel)
+	}
+	u.RawQuery = q.Encode()
+	return u.String(), nil
 }
-func urlMerger(kUrl string, pUrl string) string {
-	imageLink := ""
-	key := ""
-	if u, err := url2.Parse(kUrl); err == nil {
-		key = u.Path
+
+func urlMerger(publicUrl string, privateUrl string) (string, error) {
+	u, err := url2.Parse(publicUrl)
+	if err != nil {
+		return "", err
 	}
 
-	trunc := []rune(key)
-	key = string(trunc[len(trunc)-10:])
+	trunc := []rune(u.Path)
+	key := string(trunc[len(trunc)-10:])
 
-	if u2, err := url2.Parse(pUrl); err == nil {
-		q := u2.Query()
-		q.Set("pub_secret", key)
-		u2.RawQuery = q.Encode()
-		imageLink = u2.String()
+	u, err = url2.Parse(privateUrl)
+	if err != nil {
+		return "", err
 	}
-	return imageLink
-}
+	q := u.Query()
+	q.Set("pub_secret", key)
+	u.RawQuery = q.Encode()
 
-func getUploadedImageUrl(url string, token config.Secret, grafanaToken config.Secret) string {
+	return u.String(), nil
+}
 
+func getUploadedImageUrl(url string, token config.Secret, grafanaToken config.Secret) (string, error) {
+	const imageExtension = "jpg"
 	client := &http.Client{}
 	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return "", err
+	}
 	req.Header.Set("Authorization", "Bearer "+string(grafanaToken))
-	response, err := client.Do(req)
-
-	defer response.Body.Close()
 
+	response, err := client.Do(req)
 	if err != nil {
-		fmt.Printf("invalid req: %v\n", err)
-		return ""
+		return "", err
 	}
+	defer response.Body.Close()
 
-	if response.StatusCode != 200 {
-		fmt.Printf("received non 200 response code, code: %v\n", response.StatusCode)
-		return ""
+	if response.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("request status code %d != %d", response.StatusCode, http.StatusOK)
 	}
 
-	uuid := uuid.NewV4()
-	fileName := strings.Replace(uuid.String(), "-", "", -1)
+	fileName := fmt.Sprintf("%s.%s", strings.Replace(uuid.NewV4().String(), "-", "", -1), imageExtension)
 	api := slack.New(string(token))
 	params := slack.FileUploadParameters{
 		Reader:   response.Body,
 		Filetype: "jpg",
-		Filename: fileName + ".jpg",
+		Filename: fileName,
 	}
-	image, err := api.UploadFile(params)
 
+	image, err := api.UploadFile(params)
 	if err != nil {
-		fmt.Printf("UPLOAD ERROR. Name: %s\n", image.Name)
-		return ""
+		return "", fmt.Errorf("upload error, image: %s, error: %w", image.Name, err)
 	}
-	sharedUrl, _, _, err := api.ShareFilePublicURL(image.ID)
 
+	sharedUrl, _, _, err := api.ShareFilePublicURL(image.ID)
 	if err != nil {
-		fmt.Printf("SharedError :%v\n", sharedUrl)
-		return ""
+		return "", fmt.Errorf("share error: %w", err)
 	}
 
-	imageUrl := urlMerger(sharedUrl.PermalinkPublic, sharedUrl.URLPrivate)
+	imageUrl, err := urlMerger(sharedUrl.PermalinkPublic, sharedUrl.URLPrivate)
+	if err != nil {
+		return "", fmt.Errorf("url merge error: %w", err)
+	}
 
-	return imageUrl
+	return imageUrl, nil
 
 }
 
 func (n *Notifier) formatGrafanaMessage(data *template.Data) slack.Blocks {
-
 	dashboardUid := ""
 	panelId := ""
 	orgId := ""
@@ -159,7 +163,6 @@ func (n *Notifier) formatGrafanaMessage(data *template.Data) slack.Blocks {
 		}
 		for _, v := range alert.Annotations.SortedPairs() {
 			switch v.Name {
-
 			case "__dashboardUid__":
 				dashboardUid = v.Value
 			case "__panelId__":
@@ -179,11 +182,6 @@ func (n *Notifier) formatGrafanaMessage(data *template.Data) slack.Blocks {
 	firing = UniqStr(firing)
 	envs = UniqStr(envs)
 
-	grafanaDashUrl := genGrafanaUrl(dashboardUid, "", orgId, n.conf.GrafanaHost)
-	grafanaPanelUrl := genGrafanaUrl(dashboardUid, panelId, orgId, n.conf.GrafanaHost)
-	grafanaImageUrl := genGrafanaRenderUrl(dashboardUid, panelId, orgId, n.conf.GrafanaHost)
-	slackImageUrl := getUploadedImageUrl(grafanaImageUrl, n.conf.UserToken, n.conf.GrafanaToken)
-
 	{
 		url := ""
 		if urlParsed, err := url2.Parse(data.ExternalURL); err == nil {
@@ -219,8 +217,8 @@ func (n *Notifier) formatGrafanaMessage(data *template.Data) slack.Blocks {
 		fields = append(fields, &Field{Type: slack.MarkdownType, Text: fmt.Sprintf("*Severety: %s*", strings.ToUpper(strings.Join(severity, ", ")))})
 
 		//Buttons
-		if grafanaPanelUrl != "" {
-			fields = append(fields, &Field{Type: slack.MarkdownType, Text: fmt.Sprintf("*<%s|:chart_with_upwards_trend:Panel>*", grafanaPanelUrl)})
+		if url, err := genGrafanaUrl(n.conf.GrafanaUrl, orgId, dashboardUid, panelId); err == nil {
+			fields = append(fields, &Field{Type: slack.MarkdownType, Text: fmt.Sprintf("*<%s|:chart_with_upwards_trend:Panel>*", url)})
 		} else {
 			fields = append(fields, &Field{Type: slack.MarkdownType, Text: fmt.Sprintf(":chart_with_upwards_trend:~Panel~")})
 		}
@@ -230,8 +228,8 @@ func (n *Notifier) formatGrafanaMessage(data *template.Data) slack.Blocks {
 		} else {
 			fields = append(fields, &Field{Type: slack.MarkdownType, Text: fmt.Sprintf("*<%s|:no_bell:Silence>*", url)})
 		}
-		if grafanaDashUrl != "" {
-			fields = append(fields, &Field{Type: slack.MarkdownType, Text: fmt.Sprintf("*<%s|:dashboard:Dash>*", grafanaDashUrl)})
+		if url, err := genGrafanaUrl(n.conf.GrafanaUrl, orgId, dashboardUid, ""); err == nil {
+			fields = append(fields, &Field{Type: slack.MarkdownType, Text: fmt.Sprintf("*<%s|:dashboard:Dash>*", url)})
 		} else {
 			fields = append(fields, &Field{Type: slack.MarkdownType, Text: fmt.Sprintf(":dashboard:~Dash~")})
 		}
@@ -261,8 +259,10 @@ func (n *Notifier) formatGrafanaMessage(data *template.Data) slack.Blocks {
 	}
 
 	//GrafanaImage
-	if slackImageUrl != "" {
-		blocks = append(blocks, Block{Type: slack.MBTImage, ImageURL: slackImageUrl, AltText: "inspiration"})
+	if imageUrl, err := genGrafanaRenderUrl(n.conf.GrafanaUrl, n.conf.GrafanaTZ, orgId, dashboardUid, panelId); err == nil {
+		if slackImageUrl, err := getUploadedImageUrl(imageUrl, n.conf.UserToken, n.conf.GrafanaToken); err == nil {
+			blocks = append(blocks, Block{Type: slack.MBTImage, ImageURL: slackImageUrl, AltText: "inspiration"})
+		}
 	}
 
 	//Summary and description