SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.
TypeScript apmapplication-monitoringdistributed-tracinggogood-first-issuejaegerloglogsmetricsmonitoringnextjsobservabilityopen-sourceopentelemetryprometheusreactreactjsself-hostedtracingtypescript
feat(alerts): Support telegram channel for alerts (#13074)
praneeth-signoz37f3cd4403ea
diff --git a/docs/api/openapi.yml b/docs/api/openapi.ymlindex 3ae26462a4..9ff454df46 100644--- a/docs/api/openapi.yml+++ b/docs/api/openapi.yml@@ -251,6 +251,7 @@ components:opsgenie: '#/components/schemas/AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelOpsgenieConfig'pagerduty: '#/components/schemas/AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelPagerdutyConfig'slack: '#/components/schemas/AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelSlackConfig'+ telegram: '#/components/schemas/AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelTelegramConfig'webhook: '#/components/schemas/AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelWebhookConfig'propertyName: kindoneOf:@@ -264,6 +265,7 @@ components:- $ref: '#/components/schemas/AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelJiraConfig'- $ref: '#/components/schemas/AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelJSMOpsConfig'- $ref: '#/components/schemas/AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelIncidentIOConfig'+ - $ref: '#/components/schemas/AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelTelegramConfig'type: objectAlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelEmailConfig:properties:@@ -373,6 +375,18 @@ components:- kind- spectype: object+ AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelTelegramConfig:+ properties:+ kind:+ enum:+ - telegram+ type: string+ spec:+ $ref: '#/components/schemas/AlertmanagertypesChannelTelegramConfig'+ required:+ - kind+ - spec+ type: objectAlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelWebhookConfig:properties:kind:@@ -525,6 +539,7 @@ components:- jira- jsmops- incidentio+ - telegramtype: stringAlertmanagertypesChannelListOrder:enum:@@ -729,6 +744,31 @@ components:- title- valuetype: object+ AlertmanagertypesChannelTelegramConfig:+ properties:+ apiUrl:+ type: string+ botToken:+ format: password+ type: string+ chatId:+ format: int64+ type: integer+ disableNotifications:+ type: boolean+ message:+ type: string+ messageThreadId:+ type: integer+ sendResolved:+ nullable: true+ type: boolean+ title:+ type: string+ required:+ - botToken+ - chatId+ type: objectAlertmanagertypesChannelWebhookConfig:properties:bearerToken:@@ -1022,6 +1062,8 @@ components:- jsmops_configs- required:- incidentio_configs+ - required:+ - telegram_configs- required:- discord_configs- required:@@ -1042,8 +1084,6 @@ components:- victorops_configs- required:- sns_configs- - required:- - telegram_configs- required:- webex_configs- required:@@ -1119,7 +1159,7 @@ components:type: arraytelegram_configs:items:- $ref: '#/components/schemas/ConfigTelegramConfig'+ $ref: '#/components/schemas/AlertmanagertypesTelegramReceiverConfig'type: arrayvictorops_configs:items:@@ -1263,7 +1303,7 @@ components:type: arraytelegram_configs:items:- $ref: '#/components/schemas/ConfigTelegramConfig'+ $ref: '#/components/schemas/AlertmanagertypesTelegramReceiverConfig'type: arrayvictorops_configs:items:@@ -1334,6 +1374,34 @@ components:- timezone- startTimetype: object+ AlertmanagertypesTelegramReceiverConfig:+ properties:+ api_url:+ $ref: '#/components/schemas/ConfigURLType2'+ chat:+ format: int64+ type: integer+ chat_file:+ type: string+ disable_notifications:+ type: boolean+ http_config:+ $ref: '#/components/schemas/ConfigHTTPClientConfig'+ message:+ type: string+ message_thread_id:+ type: integer+ parse_mode:+ type: string+ send_resolved:+ type: boolean+ title:+ type: string+ token:+ type: string+ token_file:+ type: string+ type: objectAlertmanagertypesTestableNotificationChannel:properties:config:diff --git a/ee/query-service/rules/anomaly.go b/ee/query-service/rules/anomaly.goindex 6387b5b31e..b8cb4da2af 100644--- a/ee/query-service/rules/anomaly.go+++ b/ee/query-service/rules/anomaly.go@@ -277,10 +277,7 @@ func (r *AnomalyRule) Eval(ctx context.Context, ts time.Time) (int, error) {lb.Set(ruletypes.AlertRuleIDLabel, r.ID())lb.Set(ruletypes.RuleSourceLabel, r.GeneratorURL())- annotations := make(ruletypes.Labels, 0, len(r.Annotations().Map()))- for name, value := range r.Annotations().Map() {- annotations = append(annotations, ruletypes.Label{Name: name, Value: expand(value)})- }+ annotations := r.ExpandAnnotations(expand)if smpl.IsMissing {lb.Set(ruletypes.AlertNameLabel, "[No data] "+r.Name())lb.Set(ruletypes.NoDataLabel, "true")diff --git a/frontend/src/api/generated/services/sigNoz.schemas.ts b/frontend/src/api/generated/services/sigNoz.schemas.tsindex 7d660a0fad..911c54960b 100644--- a/frontend/src/api/generated/services/sigNoz.schemas.ts+++ b/frontend/src/api/generated/services/sigNoz.schemas.ts@@ -872,6 +872,55 @@ export interface AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTyspec: AlertmanagertypesChannelIncidentIOConfigDTO;}+export enum AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelTelegramConfigDTOKind {+ telegram = 'telegram',+}+export interface AlertmanagertypesChannelTelegramConfigDTO {+ /**+ * @type string+ */+ apiUrl?: string;+ /**+ * @type string+ * @format password+ */+ botToken: string;+ /**+ * @type integer+ * @format int64+ */+ chatId: number;+ /**+ * @type boolean+ */+ disableNotifications?: boolean;+ /**+ * @type string+ */+ message?: string;+ /**+ * @type integer+ */+ messageThreadId?: number;+ /**+ * @type boolean,null+ */+ sendResolved?: boolean | null;+ /**+ * @type string+ */+ title?: string;+}++export interface AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelTelegramConfigDTO {+ /**+ * @enum telegram+ * @type string+ */+ kind: AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelTelegramConfigDTOKind;+ spec: AlertmanagertypesChannelTelegramConfigDTO;+}+export type AlertmanagertypesChannelConfigDTO =| AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelSlackConfigDTO| AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelEmailConfigDTO@@ -882,7 +931,8 @@ export type AlertmanagertypesChannelConfigDTO =| AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelGoogleChatConfigDTO| AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelJiraConfigDTO| AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelJSMOpsConfigDTO- | AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelIncidentIOConfigDTO;+ | AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelIncidentIOConfigDTO+ | AlertmanagertypesChannelConfigVariantGithubComSigNozSignozPkgTypesAlertmanagertypesChannelTelegramConfigDTO;export enum AlertmanagertypesChannelDefectDTO {none = 'none',@@ -902,6 +952,7 @@ export enum AlertmanagertypesChannelKindDTO {jira = 'jira',jsmops = 'jsmops',incidentio = 'incidentio',+ telegram = 'telegram',}export enum AlertmanagertypesChannelListOrderDTO {asc = 'asc',@@ -2462,7 +2513,7 @@ export interface ConfigSNSConfigDTO {topic_arn?: string;}-export interface ConfigTelegramConfigDTO {+export interface AlertmanagertypesTelegramReceiverConfigDTO {api_url?: ConfigURLType2DTO;/*** @type integer@@ -2494,6 +2545,10 @@ export interface ConfigTelegramConfigDTO {* @type boolean*/send_resolved?: boolean;+ /**+ * @type string+ */+ title?: string;/*** @type string*/@@ -2699,7 +2754,7 @@ export type AlertmanagertypesPostableChannelDTO = unknown & {/*** @type array*/- telegram_configs?: ConfigTelegramConfigDTO[];+ telegram_configs?: AlertmanagertypesTelegramReceiverConfigDTO[];/*** @type array*/@@ -2846,7 +2901,7 @@ export interface AlertmanagertypesReceiverDTO {/*** @type array*/- telegram_configs?: ConfigTelegramConfigDTO[];+ telegram_configs?: AlertmanagertypesTelegramReceiverConfigDTO[];/*** @type array*/@@ -4422,6 +4477,48 @@ export interface ConfigJiraConfigDTO {wont_fix_resolution?: string;}+export interface ConfigTelegramConfigDTO {+ api_url?: ConfigURLType2DTO;+ /**+ * @type integer+ * @format int64+ */+ chat?: number;+ /**+ * @type string+ */+ chat_file?: string;+ /**+ * @type boolean+ */+ disable_notifications?: boolean;+ http_config?: ConfigHTTPClientConfigDTO;+ /**+ * @type string+ */+ message?: string;+ /**+ * @type integer+ */+ message_thread_id?: number;+ /**+ * @type string+ */+ parse_mode?: string;+ /**+ * @type boolean+ */+ send_resolved?: boolean;+ /**+ * @type string+ */+ token?: string;+ /**+ * @type string+ */+ token_file?: string;+}+export interface DashboardGridItemDTO {content?: CommonJSONRefDTO;/**diff --git a/pkg/alertmanager/alertmanagernotify/receiver.go b/pkg/alertmanager/alertmanagernotify/receiver.goindex f7f561b0fe..579c3fe8a5 100644--- a/pkg/alertmanager/alertmanagernotify/receiver.go+++ b/pkg/alertmanager/alertmanagernotify/receiver.go@@ -13,6 +13,7 @@ import ("github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/opsgenie""github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/pagerduty""github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/slack"+ "github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/telegram""github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/webhook""github.com/SigNoz/signoz/pkg/types/alertmanagertypes""github.com/prometheus/alertmanager/config/receiver"@@ -32,6 +33,7 @@ var customNotifierIntegrations = []string{jira.Integration,jsmops.Integration,incidentio.Integration,+ telegram.Integration,}func NewReceiverIntegrations(nc *alertmanagertypes.Receiver, tmpl *template.Template, logger *slog.Logger, templater alertmanagertypes.Templater) ([]notify.Integration, error) {@@ -102,6 +104,11 @@ func NewReceiverIntegrations(nc *alertmanagertypes.Receiver, tmpl *template.Tempreturn incidentio.New(c, tmpl, l, templater)})}+ for i, c := range nc.TelegramConfigs {+ add(telegram.Integration, i, c, func(l *slog.Logger) (notify.Notifier, error) {+ return telegram.New(c, tmpl, l, templater)+ })+ }if errs.Len() > 0 {return nil, &errsdiff --git a/pkg/alertmanager/alertmanagernotify/telegram/telegram.go b/pkg/alertmanager/alertmanagernotify/telegram/telegram.gonew file mode 100644index 0000000000..d451e8f150--- /dev/null+++ b/pkg/alertmanager/alertmanagernotify/telegram/telegram.go@@ -0,0 +1,279 @@+// Copyright (c) 2026 SigNoz, Inc.+// Copyright 2022 Prometheus Team+// SPDX-License-Identifier: Apache-2.0++// Package telegram delivers alerts to a Telegram chat. It follows upstream's+// notifier for everything about the transport and adds the channel title and+// the per-rule title and body templates carried on the _title_template and+// _body_template annotations.+package telegram++import (+ "bytes"+ "context"+ "encoding/json"+ "log/slog"+ "net/http"+ "os"+ "strconv"+ "strings"++ "github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"+ "github.com/SigNoz/signoz/pkg/errors"+ "github.com/SigNoz/signoz/pkg/templating/markdownrenderer"+ "github.com/SigNoz/signoz/pkg/types/alertmanagertypes"+ "github.com/prometheus/alertmanager/config"+ "github.com/prometheus/alertmanager/notify"+ "github.com/prometheus/alertmanager/template"+ "github.com/prometheus/alertmanager/types"+ commoncfg "github.com/prometheus/common/config"+)++const (+ Integration = "telegram"++ // Telegram supports 4096 chars max - from https://limits.tginfo.me/en.+ maxMessageLenRunes = 4096++ parseModeHTML = "HTML"+)++type Notifier struct {+ conf *alertmanagertypes.TelegramReceiverConfig+ tmpl *template.Template+ logger *slog.Logger+ client *http.Client+ retrier *notify.Retrier+ templater alertmanagertypes.Templater+}++func New(conf *alertmanagertypes.TelegramReceiverConfig, t *template.Template, l *slog.Logger, templater alertmanagertypes.Templater, httpOpts ...commoncfg.HTTPClientOption) (*Notifier, error) {+ if conf.HTTPConfig == nil {+ return nil, errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "telegram http_config is nil")+ }++ if conf.APIUrl == nil {+ withAPIURL := *conf+ withAPIURL.APIUrl = config.DefaultGlobalConfig().TelegramAPIUrl+ conf = &withAPIURL+ }++ // Rendering targets the HTML subset only. A receiver stored through the v1+ // API can still carry another mode; failing here would fail the whole org's+ // config, so the send is forced to HTML instead.+ if conf.ParseMode != parseModeHTML {+ l.WarnContext(context.Background(), "telegram parse_mode is not supported, sending as HTML", slog.String("parse_mode", conf.ParseMode))+ htmlConf := *conf+ htmlConf.ParseMode = parseModeHTML+ conf = &htmlConf+ }++ httpclient, err := notify.NewClientWithTracing(*conf.HTTPConfig, Integration, httpOpts...)+ if err != nil {+ return nil, err+ }++ return &Notifier{+ conf: conf,+ tmpl: t,+ logger: l,+ client: httpclient,+ retrier: ¬ify.Retrier{RetryCodes: []int{http.StatusTooManyRequests}},+ templater: templater,+ }, nil+}++func (n *Notifier) Notify(ctx context.Context, as ...*types.Alert) (bool, error) {+ key, err := notify.ExtractGroupKey(ctx)+ if err != nil {+ return false, err+ }++ logger := n.logger.With(slog.String("group_key", key.String()))++ messageText, err := n.buildMessage(ctx, logger, as)+ if err != nil {+ return false, err+ }++ messageText, truncated := notify.TruncateInRunes(messageText, maxMessageLenRunes)+ if truncated {+ logger.WarnContext(ctx, "truncated message", slog.Int("max_runes", maxMessageLenRunes))+ }++ botToken, err := n.getBotToken()+ if err != nil {+ return true, err+ }++ chatID, err := n.getChatID()+ if err != nil {+ return true, err+ }++ buf, err := n.encodeSendMessage(chatID, messageText)+ if err != nil {+ return false, err+ }++ resp, err := notify.PostJSON(ctx, n.client, n.conf.APIUrl.String()+"/bot"+botToken+"/sendMessage", buf) //nolint:bodyclose+ if err != nil {+ return true, notify.RedactURL(err)+ }+ defer notify.Drain(resp)++ shouldRetry, err := n.retrier.Check(resp.StatusCode, resp.Body)+ if err != nil {+ return shouldRetry, notify.NewErrorWithReason(notify.GetFailureReasonFromStatusCode(resp.StatusCode), err)+ }+ return shouldRetry, err+}++// encodeSendMessage builds the sendMessage payload with every value as a+// string, the encoding upstream's telebot client uses.+func (n *Notifier) encodeSendMessage(chatID int64, text string) (*bytes.Buffer, error) {+ params := map[string]string{+ "chat_id": strconv.FormatInt(chatID, 10),+ "text": text,+ "parse_mode": n.conf.ParseMode,+ "disable_web_page_preview": "true",+ }+ if n.conf.DisableNotifications {+ params["disable_notification"] = "true"+ }+ if n.conf.MessageThreadID != 0 {+ params["message_thread_id"] = strconv.Itoa(n.conf.MessageThreadID)+ }++ var buf bytes.Buffer+ if err := json.NewEncoder(&buf).Encode(params); err != nil {+ return nil, err+ }++ return &buf, nil+}++// buildMessage sends the title in bold above the message. Each half comes from+// the rule's template when it has one and from the channel's otherwise; an+// empty title sends the message alone.+func (n *Notifier) buildMessage(ctx context.Context, logger *slog.Logger, as []*types.Alert) (string, error) {+ customTitle, customBody := alertmanagertemplate.ExtractTemplatesFromAnnotations(as)++ var result *alertmanagertypes.ExpandResult+ if customTitle != "" || customBody != "" {+ var err error+ result, err = n.templater.Expand(ctx, alertmanagertypes.ExpandRequest{+ TitleTemplate: customTitle,+ BodyTemplate: customBody,+ }, as)+ if err != nil {+ return "", err+ }++ if len(result.MissingVars) > 0 {+ logger.WarnContext(ctx, "unresolved variables in rule template", slog.Any("template_missing_vars", result.MissingVars))+ }+ }++ var (+ title, body string+ err error+ )+ if customTitle != "" {+ title, err = n.renderRuleTemplate(result.Title)+ } else {+ title, err = n.renderChannelTemplate(ctx, as, n.conf.Title)+ }+ if err != nil {+ return "", err+ }++ if customBody != "" {+ body, err = n.renderRuleTemplate(strings.Join(nonEmpty(result.Body), "\n\n"))+ } else {+ body, err = n.renderChannelTemplate(ctx, as, n.conf.Message)+ }+ if err != nil {+ return "", err+ }++ if title == "" {+ return body, nil+ }++ return strings.TrimSpace("<b>" + title + "</b>\n\n" + body), nil+}++// renderChannelTemplate reproduces upstream's rendering, including its choice+// of engine under parse_mode HTML: html/template escapes every interpolated+// value, so a channel template that does not pipe through html still sends.+func (n *Notifier) renderChannelTemplate(ctx context.Context, as []*types.Alert, text string) (string, error) {+ if text == "" {+ return "", nil+ }++ var tmplErr error+ data := notify.GetTemplateData(ctx, n.tmpl, as, n.logger)++ rendered := notify.TmplHTML(n.tmpl, data, &tmplErr)(text)+ if tmplErr != nil {+ return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to execute telegram template: %s", tmplErr.Error())+ }++ return strings.TrimSpace(rendered), nil+}++// renderRuleTemplate converts the templater's output from markdown, which is+// the format rule templates are authored in for every channel, into Telegram's+// HTML subset. The renderer escapes as it goes, so a stray < or & in an alert+// value cannot fail the send with "can't parse entities".+func (n *Notifier) renderRuleTemplate(markdown string) (string, error) {+ rendered, err := markdownrenderer.RenderTelegramHTML(markdown)+ if err != nil {+ return "", err+ }++ return strings.TrimSpace(rendered), nil+}++func (n *Notifier) getBotToken() (string, error) {+ if n.conf.BotTokenFile == "" {+ return string(n.conf.BotToken), nil+ }++ content, err := os.ReadFile(n.conf.BotTokenFile)+ if err != nil {+ return "", errors.WrapInternalf(err, errors.CodeInternal, "could not read %s", n.conf.BotTokenFile)+ }++ return strings.TrimSpace(string(content)), nil+}++func (n *Notifier) getChatID() (int64, error) {+ if n.conf.ChatIDFile == "" {+ return n.conf.ChatID, nil+ }++ content, err := os.ReadFile(n.conf.ChatIDFile)+ if err != nil {+ return 0, errors.WrapInternalf(err, errors.CodeInternal, "could not read %s", n.conf.ChatIDFile)+ }++ chatID, err := strconv.ParseInt(strings.TrimSpace(string(content)), 10, 64)+ if err != nil {+ return 0, errors.WrapInternalf(err, errors.CodeInternal, "could not parse chat_id from %s", n.conf.ChatIDFile)+ }++ return chatID, nil+}++func nonEmpty(parts []string) []string {+ kept := make([]string, 0, len(parts))+ for _, part := range parts {+ if part != "" {+ kept = append(kept, part)+ }+ }++ return kept+}diff --git a/pkg/alertmanager/alertmanagernotify/telegram/telegram_test.go b/pkg/alertmanager/alertmanagernotify/telegram/telegram_test.gonew file mode 100644index 0000000000..bb3c0e0e40--- /dev/null+++ b/pkg/alertmanager/alertmanagernotify/telegram/telegram_test.go@@ -0,0 +1,390 @@+package telegram++import (+ "context"+ "encoding/json"+ "log/slog"+ "net/http"+ "net/http/httptest"+ "net/url"+ "strconv"+ "sync"+ "testing"+ "time"++ test "github.com/SigNoz/signoz/pkg/alertmanager/alertmanagernotify/alertmanagernotifytest"+ "github.com/SigNoz/signoz/pkg/alertmanager/alertmanagertemplate"+ "github.com/SigNoz/signoz/pkg/types/alertmanagertypes"+ "github.com/SigNoz/signoz/pkg/types/ruletypes"+ "github.com/prometheus/alertmanager/config"+ "github.com/prometheus/alertmanager/notify"+ "github.com/prometheus/alertmanager/types"+ commoncfg "github.com/prometheus/common/config"+ "github.com/prometheus/common/model"+ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++// mockBotAPI answers sendMessage the way api.telegram.org does. Every+// parameter is posted as a string.+type mockBotAPI struct {+ srv *httptest.Server+ mu sync.Mutex+ sent []map[string]string+}++func newMockBotAPI(t *testing.T) *mockBotAPI {+ t.Helper()++ return newMockBotAPIWithStatus(t, http.StatusOK)+}++func newMockBotAPIWithStatus(t *testing.T, status int) *mockBotAPI {+ t.Helper()+ mock := &mockBotAPI{}+ mock.srv = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ var params map[string]string+ _ = json.NewDecoder(r.Body).Decode(¶ms)++ mock.mu.Lock()+ mock.sent = append(mock.sent, params)+ mock.mu.Unlock()++ w.Header().Set("Content-Type", "application/json")+ w.WriteHeader(status)+ if status != http.StatusOK {+ _, _ = w.Write([]byte(`{"ok":false,"error_code":` + strconv.Itoa(status) + `,"description":"failed"}`))+ return+ }+ _, _ = w.Write([]byte(`{"ok":true,"result":{"message_id":1,"date":0,"chat":{"id":` + params["chat_id"] + `,"type":"private"}}}`))+ }))+ t.Cleanup(mock.srv.Close)++ return mock+}++func (m *mockBotAPI) only(t *testing.T) map[string]string {+ t.Helper()+ m.mu.Lock()+ defer m.mu.Unlock()+ require.Len(t, m.sent, 1)++ return m.sent[0]+}++func newNotifier(t *testing.T, mock *mockBotAPI) *Notifier {+ t.Helper()++ return newNotifierWithTitle(t, mock, alertmanagertypes.DefaultTelegramTitleTemplate)+}++func newNotifierWithTitle(t *testing.T, mock *mockBotAPI, title string) *Notifier {+ t.Helper()+ tmpl := test.CreateTmpl(t)+ apiURL, err := url.Parse(mock.srv.URL)+ require.NoError(t, err)++ logger := slog.New(slog.DiscardHandler)+ notifier, err := New(&alertmanagertypes.TelegramReceiverConfig{+ HTTPConfig: &commoncfg.HTTPClientConfig{},+ APIUrl: &config.URL{URL: apiURL},+ BotToken: "123456:tok",+ ChatID: -1001234567890,+ ParseMode: "HTML",+ Title: title,+ Message: alertmanagertypes.DefaultTelegramMessageTemplate,+ }, tmpl, logger, alertmanagertemplate.New(tmpl, logger))+ require.NoError(t, err)++ return notifier+}++func newAlert(host string, annotations model.LabelSet) *types.Alert {+ merged := model.LabelSet{"summary": "p99 is 612ms"}+ for name, value := range annotations {+ merged[name] = value+ }++ return &types.Alert{+ Alert: model.Alert{+ Labels: model.LabelSet{"alertname": "checkout-latency-high", "severity": "warning", "host": model.LabelValue(host)},+ Annotations: merged,+ StartsAt: time.Now(),+ EndsAt: time.Now().Add(time.Hour),+ GeneratorURL: "http://am/alerts/overview?ruleId=r1",+ },+ }+}++func TestNotifyBuildsTheMessage(t *testing.T) {+ testCases := []struct {+ name string+ untitledChannel bool+ alerts []*types.Alert+ wantExact string+ wantContains []string+ wantNotContains []string+ }{+ {+ name: "NoRuleTemplates_UsesChannelTemplate",+ alerts: []*types.Alert{newAlert("web-3", nil)},+ wantContains: []string{+ "<b>[FIRING:1] checkout-latency-high</b>\n\n<b>Alert:</b>",+ "<b>Summary:</b> p99 is 612ms",+ `<a href="http://am/alerts/overview?ruleId=r1">View in SigNoz</a>`,+ },+ },+ {+ // Receivers stored before the channel title existed have none.+ name: "UntitledChannel_SendsTheMessageAlone",+ untitledChannel: true,+ alerts: []*types.Alert{newAlert("web-3", nil)},+ wantContains: []string{"<b>Summary:</b> p99 is 612ms"},+ wantNotContains: []string{"[FIRING:1]"},+ },+ {+ name: "TitleAndBody_ReplaceTheChannelTemplate",+ alerts: []*types.Alert{newAlert("web-3", model.LabelSet{+ ruletypes.AnnotationTitleTemplate: "Incident on $labels.host",+ ruletypes.AnnotationBodyTemplate: "$alert.status for $rule.name",+ })},+ wantExact: "<b>Incident on web-3</b>\n\nfiring for checkout-latency-high",+ wantNotContains: []string{"View in SigNoz"},+ },+ {+ // $-refs are template variables, so the braced form is the real+ // syntax and the only one that reaches conditionals. A bare ref in+ // text is rewritten into an action before expansion.+ name: "BracedAndBareRefs_ExpandAlike",+ untitledChannel: true,+ alerts: []*types.Alert{newAlert("web-3", model.LabelSet{+ ruletypes.AnnotationBodyTemplate: "{{ $rule.name }}|$rule.name|{{ if $alert.is_firing }}up{{ end }}",+ })},+ wantExact: "checkout-latency-high|checkout-latency-high|up",+ },+ {+ name: "BodyOnly_KeepsTheChannelTitle",+ alerts: []*types.Alert{newAlert("web-3", model.LabelSet{+ ruletypes.AnnotationBodyTemplate: "$alert.status for $rule.name",+ })},+ wantExact: "<b>[FIRING:1] checkout-latency-high</b>\n\nfiring for checkout-latency-high",+ },+ {+ name: "BodyOnly_UntitledChannel_OmitsTheTitleLine",+ untitledChannel: true,+ alerts: []*types.Alert{newAlert("web-3", model.LabelSet{+ ruletypes.AnnotationBodyTemplate: "$alert.status for $rule.name",+ })},+ wantExact: "firing for checkout-latency-high",+ },+ {+ name: "TitleOnly_ReplacesTheChannelTitle",+ alerts: []*types.Alert{newAlert("web-3", model.LabelSet{+ ruletypes.AnnotationTitleTemplate: "Incident on $labels.host",+ })},+ wantContains: []string{"<b>Incident on web-3</b>\n\n<b>Alert:</b>", "<b>Summary:</b> p99 is 612ms"},+ wantNotContains: []string{"[FIRING:1]"},+ },+ {+ // Rule templates are authored in markdown for every channel, so+ // Telegram converts rather than escaping the markers away.+ name: "RuleTemplateMarkdown_RenderedToTelegramHTML",+ untitledChannel: true,+ alerts: []*types.Alert{newAlert("web-3", model.LabelSet{+ ruletypes.AnnotationBodyTemplate: "**{{ $rule.name }}** on `{{ $labels.host }}` — [open](https://signoz.io/d?a=1&b=2)",+ })},+ wantExact: `<b>checkout-latency-high</b> on <code>web-3</code> — <a href="https://signoz.io/d?a=1&b=2">open</a>`,+ },+ {+ // The templater renders plain text, so anything interpolated from+ // an alert has to be escaped before a parse_mode HTML send.+ name: "RuleTemplateOutput_EscapedForHTML",+ alerts: []*types.Alert{newAlert("web-3", model.LabelSet{+ "summary": "p99 < 2s & rising",+ ruletypes.AnnotationTitleTemplate: "$annotations.summary",+ ruletypes.AnnotationBodyTemplate: "$annotations.summary",+ })},+ wantExact: "<b>p99 < 2s & rising</b>\n\np99 < 2s & rising",+ },+ {+ name: "GroupedAlerts_BodyRenderedPerAlert",+ untitledChannel: true,+ alerts: []*types.Alert{+ newAlert("web-3", model.LabelSet{ruletypes.AnnotationBodyTemplate: "host $labels.host"}),+ newAlert("web-4", model.LabelSet{ruletypes.AnnotationBodyTemplate: "host $labels.host"}),+ },+ wantExact: "host web-3\n\nhost web-4",+ },+ {+ // Picking one rule's template for a mixed group would be arbitrary,+ // so the channel template is used instead.+ name: "GroupedAlerts_DisagreeingTemplates_FallBackToChannel",+ alerts: []*types.Alert{+ newAlert("web-3", model.LabelSet{ruletypes.AnnotationBodyTemplate: "host $labels.host"}),+ newAlert("web-4", model.LabelSet{ruletypes.AnnotationBodyTemplate: "something else"}),+ },+ wantContains: []string{"<b>Summary:</b> p99 is 612ms"},+ },+ }++ for _, testCase := range testCases {+ t.Run(testCase.name, func(t *testing.T) {+ mock := newMockBotAPI(t)++ title := alertmanagertypes.DefaultTelegramTitleTemplate+ if testCase.untitledChannel {+ title = ""+ }++ retry, err := newNotifierWithTitle(t, mock, title).Notify(notify.WithGroupKey(context.Background(), "1"), testCase.alerts...)+ require.NoError(t, err)+ assert.False(t, retry)++ text := mock.only(t)["text"]+ if testCase.wantExact != "" {+ assert.Equal(t, testCase.wantExact, text)+ }+ for _, want := range testCase.wantContains {+ assert.Contains(t, text, want)+ }+ for _, notWant := range testCase.wantNotContains {+ assert.NotContains(t, text, notWant)+ }+ })+ }+}++// A v1-written receiver can carry a mode the v2 spec no longer offers. Nothing+// renders to those, so the send goes out as HTML without touching the receiver.+func TestNewForcesParseModeHTML(t *testing.T) {+ testCases := []struct {+ name string+ parseMode string+ }{+ {"HTML", "HTML"},+ {"MarkdownV2", "MarkdownV2"},+ {"Markdown", "Markdown"},+ {"Empty", ""},+ }++ for _, testCase := range testCases {+ t.Run(testCase.name, func(t *testing.T) {+ mock := newMockBotAPI(t)+ apiURL, err := url.Parse(mock.srv.URL)+ require.NoError(t, err)++ tmpl := test.CreateTmpl(t)+ logger := slog.New(slog.DiscardHandler)+ conf := &alertmanagertypes.TelegramReceiverConfig{+ HTTPConfig: &commoncfg.HTTPClientConfig{},+ APIUrl: &config.URL{URL: apiURL},+ BotToken: "123456:tok",+ ChatID: -1001234567890,+ ParseMode: testCase.parseMode,+ Message: alertmanagertypes.DefaultTelegramMessageTemplate,+ }+ notifier, err := New(conf, tmpl, logger, alertmanagertemplate.New(tmpl, logger))+ require.NoError(t, err)++ _, err = notifier.Notify(notify.WithGroupKey(context.Background(), "1"), newAlert("web-3", nil))+ require.NoError(t, err)++ assert.Equal(t, "HTML", mock.only(t)["parse_mode"])+ assert.Equal(t, testCase.parseMode, conf.ParseMode)+ })+ }+}++func TestNewDefaultsAPIURL(t *testing.T) {+ testCases := []struct {+ name string+ apiURL string+ expected string+ }{+ {"Unset_DefaultsToTelegram", "", "https://api.telegram.org"},+ {"Set_KeepsChannelURL", "http://127.0.0.1:9099", "http://127.0.0.1:9099"},+ }++ for _, testCase := range testCases {+ t.Run(testCase.name, func(t *testing.T) {+ conf := &alertmanagertypes.TelegramReceiverConfig{+ HTTPConfig: &commoncfg.HTTPClientConfig{},+ BotToken: "123456:tok",+ ChatID: -1001234567890,+ ParseMode: "HTML",+ }+ if testCase.apiURL != "" {+ apiURL, err := url.Parse(testCase.apiURL)+ require.NoError(t, err)+ conf.APIUrl = &config.URL{URL: apiURL}+ }++ tmpl := test.CreateTmpl(t)+ logger := slog.New(slog.DiscardHandler)+ notifier, err := New(conf, tmpl, logger, alertmanagertemplate.New(tmpl, logger))+ require.NoError(t, err)++ require.NotNil(t, notifier.conf.APIUrl)+ assert.Equal(t, testCase.expected, notifier.conf.APIUrl.String())+ if testCase.apiURL == "" {+ assert.Nil(t, conf.APIUrl, "the receiver is not modified")+ }+ })+ }+}++func TestNotifySendsTheConfiguredSendOptions(t *testing.T) {+ mock := newMockBotAPI(t)++ _, err := newNotifier(t, mock).Notify(notify.WithGroupKey(context.Background(), "1"), newAlert("web-3", nil))+ require.NoError(t, err)++ sent := mock.only(t)+ assert.Equal(t, "-1001234567890", sent["chat_id"])+ assert.Equal(t, "HTML", sent["parse_mode"])+}++func TestNotifyRetriesOnlyRateLimitAndServerErrors(t *testing.T) {+ testCases := []struct {+ name string+ status int+ wantErr bool+ wantRetry bool+ }{+ {"OK_NoRetry", http.StatusOK, false, false},+ {"TooManyRequests_Retries", http.StatusTooManyRequests, true, true},+ {"InternalServerError_Retries", http.StatusInternalServerError, true, true},+ {"BadGateway_Retries", http.StatusBadGateway, true, true},+ {"BadRequest_DoesNotRetry", http.StatusBadRequest, true, false},+ {"Unauthorized_DoesNotRetry", http.StatusUnauthorized, true, false},+ {"Forbidden_DoesNotRetry", http.StatusForbidden, true, false},+ }++ for _, testCase := range testCases {+ t.Run(testCase.name, func(t *testing.T) {+ mock := newMockBotAPIWithStatus(t, testCase.status)++ retry, err := newNotifier(t, mock).Notify(notify.WithGroupKey(context.Background(), "1"), newAlert("web-3", nil))+ if testCase.wantErr {+ assert.Error(t, err)+ } else {+ assert.NoError(t, err)+ }+ assert.Equal(t, testCase.wantRetry, retry)+ })+ }+}++func TestNotifyPostsToTheBotSendMessageEndpoint(t *testing.T) {+ var gotPath string+ srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ gotPath = r.URL.Path+ _, _ = w.Write([]byte(`{"ok":true}`))+ }))+ t.Cleanup(srv.Close)++ _, err := newNotifier(t, &mockBotAPI{srv: srv}).Notify(notify.WithGroupKey(context.Background(), "1"), newAlert("web-3", nil))+ require.NoError(t, err)++ assert.Equal(t, "/bot123456:tok/sendMessage", gotPath)+}diff --git a/pkg/query-service/rules/base_rule.go b/pkg/query-service/rules/base_rule.goindex db8643c2cc..d57c9c7f28 100644--- a/pkg/query-service/rules/base_rule.go+++ b/pkg/query-service/rules/base_rule.go@@ -12,6 +12,7 @@ import ("github.com/SigNoz/signoz/pkg/modules/rulestatehistory""github.com/SigNoz/signoz/pkg/queryparser""github.com/SigNoz/signoz/pkg/sqlstore"+ "github.com/SigNoz/signoz/pkg/types/alertmanagertypes"qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5""github.com/SigNoz/signoz/pkg/types/rulestatehistorytypes""github.com/SigNoz/signoz/pkg/types/ruletypes"@@ -253,6 +254,24 @@ func (r *BaseRule) GeneratorURL() string {return r.ExternalURL("alerts/overview", params)}+// ExpandAnnotations runs expand over the rule's annotations, leaving private+// ones as they are. Those carry templates the notifier expands against its own+// data model, and the ruler's expander rewrites every $-ref into a label+// lookup, which blanks the ones that are not labels.+func (r *BaseRule) ExpandAnnotations(expand func(string) string) ruletypes.Labels {+ annotations := make(ruletypes.Labels, 0, len(r.annotations.Map()))+ for name, value := range r.annotations.Map() {+ if alertmanagertypes.IsPrivateAnnotation(name) {+ annotations = append(annotations, ruletypes.Label{Name: name, Value: value})+ continue+ }++ annotations = append(annotations, ruletypes.Label{Name: name, Value: expand(value)})+ }++ return annotations+}+func (r *BaseRule) ExternalURL(path string, params url.Values) string {u := r.externalURL.JoinPath(path)if len(params) > 0 {diff --git a/pkg/query-service/rules/base_rule_test.go b/pkg/query-service/rules/base_rule_test.goindex 1512c55e70..8b363d48cf 100644--- a/pkg/query-service/rules/base_rule_test.go+++ b/pkg/query-service/rules/base_rule_test.go@@ -833,3 +833,55 @@ func labelsKey(lbls []*qbtypes.Label) string {}return temp.Labels().String()}++func TestExpandAnnotations(t *testing.T) {+ testCases := []struct {+ name string+ annotations map[string]string+ want map[string]string+ }{+ {+ name: "PublicAnnotation_Expanded",+ annotations: map[string]string{"summary": "observed {{$value}}"},+ want: map[string]string{"summary": "observed 0.35"},+ },+ {+ // The ruler's expander rewrites every $-ref into a label lookup, so+ // expanding these would blank the paths the notifier resolves.+ name: "PrivateAnnotation_LeftAlone",+ annotations: map[string]string{ruletypes.AnnotationTitleTemplate: "{{ $rule.name }} on {{ $labels.host }}"},+ want: map[string]string{ruletypes.AnnotationTitleTemplate: "{{ $rule.name }} on {{ $labels.host }}"},+ },+ {+ name: "MixedAnnotations_OnlyPublicExpanded",+ annotations: map[string]string{+ "summary": "observed {{$value}}",+ ruletypes.AnnotationBodyTemplate: "$alert.status for $rule.name",+ },+ want: map[string]string{+ "summary": "observed 0.35",+ ruletypes.AnnotationBodyTemplate: "$alert.status for $rule.name",+ },+ },+ }++ for _, testCase := range testCases {+ t.Run(testCase.name, func(t *testing.T) {+ rule := &BaseRule{annotations: ruletypes.FromMap(testCase.annotations)}+ expand := func(text string) string {+ tmpl := ruletypes.NewTemplateExpander(+ context.Background(),+ "{{$labels := .Labels}}{{$value := .Value}}{{$threshold := .Threshold}}"+text,+ "__alert_test",+ ruletypes.AlertTemplateData(map[string]string{}, "0.35", "0.32"),+ nil,+ )+ out, err := tmpl.Expand()+ require.NoError(t, err)+ return out+ }++ assert.Equal(t, testCase.want, rule.ExpandAnnotations(expand).Map())+ })+ }+}diff --git a/pkg/query-service/rules/prom_rule.go b/pkg/query-service/rules/prom_rule.goindex 5ac3fcece8..f10f206628 100644--- a/pkg/query-service/rules/prom_rule.go+++ b/pkg/query-service/rules/prom_rule.go@@ -211,10 +211,7 @@ func (r *PromRule) Eval(ctx context.Context, ts time.Time) (int, error) {lb.Set(ruletypes.AlertRuleIDLabel, r.ID())lb.Set(ruletypes.RuleSourceLabel, r.GeneratorURL())- annotations := make(ruletypes.Labels, 0, len(r.annotations.Map()))- for name, value := range r.annotations.Map() {- annotations = append(annotations, ruletypes.Label{Name: name, Value: expand(value)})- }+ annotations := r.ExpandAnnotations(expand)if result.IsMissing {lb.Set(ruletypes.AlertNameLabel, "[No data] "+r.Name())lb.Set(ruletypes.NoDataLabel, "true")diff --git a/pkg/query-service/rules/threshold_rule.go b/pkg/query-service/rules/threshold_rule.goindex b4cb8a274b..5bc0246ada 100644--- a/pkg/query-service/rules/threshold_rule.go+++ b/pkg/query-service/rules/threshold_rule.go@@ -295,10 +295,7 @@ func (r *ThresholdRule) Eval(ctx context.Context, ts time.Time) (int, error) {lb.Set(ruletypes.AlertRuleIDLabel, r.ID())lb.Set(ruletypes.RuleSourceLabel, r.GeneratorURL())- annotations := make(ruletypes.Labels, 0, len(r.annotations.Map()))- for name, value := range r.annotations.Map() {- annotations = append(annotations, ruletypes.Label{Name: name, Value: expand(value)})- }+ annotations := r.ExpandAnnotations(expand)if smpl.IsMissing {lb.Set(ruletypes.AlertNameLabel, "[No data] "+r.Name())lb.Set(ruletypes.NoDataLabel, "true")diff --git a/pkg/signoz/provider.go b/pkg/signoz/provider.goindex fbe276b31b..8ac4d4f543 100644--- a/pkg/signoz/provider.go+++ b/pkg/signoz/provider.go@@ -262,6 +262,7 @@ func NewSQLMigrationProviderFactories(sqlmigration.NewAddRuleViewFactory(sqlstore, sqlschema),sqlmigration.NewAddFieldTuplesFactory(sqlstore),sqlmigration.NewKeepRelevantLLMPricingRulesFactory(),+ sqlmigration.NewBackfillTelegramChannelSpecFactory(),)}diff --git a/pkg/sqlmigration/136_backfill_telegram_channel_spec.go b/pkg/sqlmigration/136_backfill_telegram_channel_spec.gonew file mode 100644index 0000000000..d640f968c6--- /dev/null+++ b/pkg/sqlmigration/136_backfill_telegram_channel_spec.go@@ -0,0 +1,188 @@+package sqlmigration++import (+ "context"+ "encoding/json"+ "log/slog"+ "strings"++ "github.com/SigNoz/signoz/pkg/errors"+ "github.com/SigNoz/signoz/pkg/factory"+ "github.com/uptrace/bun"+ "github.com/uptrace/bun/migrate"+)++type backfillTelegramChannelSpec struct {+ logger *slog.Logger+}++func NewBackfillTelegramChannelSpecFactory() factory.ProviderFactory[SQLMigration, Config] {+ return factory.NewProviderFactory(factory.MustNewName("backfill_telegram_channel_spec"), func(ctx context.Context, ps factory.ProviderSettings, c Config) (SQLMigration, error) {+ return &backfillTelegramChannelSpec{logger: ps.Logger}, nil+ })+}++func (migration *backfillTelegramChannelSpec) Register(migrations *migrate.Migrations) error {+ return migrations.Register(migration.Up, migration.Down)+}++// Up fills the spec of telegram channels add_channel_spec left NULL because v2+// did not model telegram then. parse_mode is not carried: the spec has no field+// for it and every send goes out as HTML. Rows carrying any other notifier are+// left to the repair endpoint.+func (migration *backfillTelegramChannelSpec) Up(ctx context.Context, db *bun.DB) error {+ tx, err := db.BeginTx(ctx, nil)+ if err != nil {+ return err+ }+ defer func() {+ _ = tx.Rollback()+ }()++ rows := make([]*channelSpecBackfillRow, 0)+ if err := tx.NewSelect().Model(&rows).Where("spec IS NULL").OrderExpr("org_id, id").Scan(ctx); err != nil {+ return err+ }++ for _, row := range rows {+ kind, spec, err := telegramChannelSpecFromReceiverJSON(row.Data)+ if kind != "telegram" {+ continue+ }+ if err != nil {+ migration.logger.WarnContext(ctx, "leaving telegram notification channel without a v2 spec", slog.String("org_id", row.OrgID), slog.String("channel_id", row.ID), errors.Attr(err))+ continue+ }++ encoded, err := marshalUnescaped(spec)+ if err != nil {+ return err+ }++ if _, err := tx.NewUpdate().+ Model((*channelSpecBackfillRow)(nil)).+ Set("spec = ?", string(encoded)).+ Set("type = ?", kind).+ Where("id = ?", row.ID).+ Exec(ctx); err != nil {+ return err+ }+ migration.logger.InfoContext(ctx, "filled v2 spec on telegram notification channel", slog.String("org_id", row.OrgID), slog.String("channel_id", row.ID))+ }++ return tx.Commit()+}++func (migration *backfillTelegramChannelSpec) Down(context.Context, *bun.DB) error {+ return nil+}++// telegramChannelSpecFromReceiverJSON reads the kind from the receiver rather+// than the stored type, which v1 could leave empty.+func telegramChannelSpecFromReceiverJSON(data string) (string, map[string]any, error) {+ receiver := map[string]json.RawMessage{}+ if err := json.Unmarshal([]byte(data), &receiver); err != nil {+ return "", nil, nil+ }++ total := 0+ var telegrams []notifierJSON+ for key, raw := range receiver {+ if !strings.HasSuffix(key, "_configs") {+ continue+ }++ var list []notifierJSON+ if err := json.Unmarshal(raw, &list); err != nil {+ if key != "telegram_configs" {+ return "", nil, nil+ }+ return "telegram", nil, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "%s", key)+ }+ total += len(list)+ if key == "telegram_configs" {+ telegrams = list+ }+ }++ if len(telegrams) == 0 {+ return "", nil, nil+ }+ if total > 1 {+ return "telegram", nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "carries %d notifier configurations; only one per channel is supported", total)+ }++ spec, err := convertTelegramNotifierJSON(telegrams[0])+ return "telegram", spec, err+}++func convertTelegramNotifierJSON(notifier notifierJSON) (map[string]any, error) {+ if err := rejectAnyHTTPAuthJSON(notifier); err != nil {+ return nil, err+ }++ for _, key := range []string{"token_file", "chat_file"} {+ value, err := notifier.stringValue(key)+ if err != nil {+ return nil, err+ }+ if value != "" {+ return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "telegram: %s is not supported", key)+ }+ }++ spec := map[string]any{}+ if err := notifier.copyStrings(spec, map[string]string{"token": "botToken"}); err != nil {+ return nil, err+ }+ if err := notifier.copyNonEmptyStrings(spec, map[string]string{"api_url": "apiUrl", "message": "message"}); err != nil {+ return nil, err+ }+ if spec["botToken"] == "" {+ return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "telegram: token is required")+ }++ chatID, err := notifier.int64Value("chat")+ if err != nil {+ return nil, err+ }+ if chatID == 0 {+ return nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "telegram: chat is required")+ }+ spec["chatId"] = chatID++ threadID, err := notifier.int64Value("message_thread_id")+ if err != nil {+ return nil, err+ }+ if threadID != 0 {+ spec["messageThreadId"] = threadID+ }++ disableNotifications, err := notifier.boolValue("disable_notifications")+ if err != nil {+ return nil, err+ }+ if disableNotifications {+ spec["disableNotifications"] = true+ }++ sendResolved, err := notifier.boolValue("send_resolved")+ if err != nil {+ return nil, err+ }+ spec["sendResolved"] = sendResolved++ return spec, nil+}++func (n notifierJSON) int64Value(key string) (int64, error) {+ if !n.has(key) {+ return 0, nil+ }+ var value int64+ if err := json.Unmarshal(n[key], &value); err != nil {+ return 0, errors.WrapInvalidInputf(err, errors.CodeInvalidInput, "%s", key)+ }+ return value, nil+}diff --git a/pkg/templating/markdownrenderer/markdownrenderer.go b/pkg/templating/markdownrenderer/markdownrenderer.goindex 84960c01bc..ff61f91142 100644--- a/pkg/templating/markdownrenderer/markdownrenderer.go+++ b/pkg/templating/markdownrenderer/markdownrenderer.go@@ -8,6 +8,7 @@ import ("github.com/SigNoz/signoz/pkg/templating/markdownrenderer/blockkit""github.com/SigNoz/signoz/pkg/templating/markdownrenderer/mrkdwn""github.com/SigNoz/signoz/pkg/templating/markdownrenderer/plaintext"+ "github.com/SigNoz/signoz/pkg/templating/markdownrenderer/telegram""github.com/yuin/goldmark""github.com/yuin/goldmark/extension")@@ -38,6 +39,11 @@ var (return goldmark.New(goldmark.WithExtensions(plaintext.Extender))},}+ telegramPool = sync.Pool{+ New: func() any {+ return goldmark.New(goldmark.WithExtensions(telegram.Extender))+ },+ })// RenderHTML converts markdown to HTML.@@ -67,6 +73,14 @@ func RenderPlainText(markdown string) (string, error) {return render(md, markdown, "plain text")}+// RenderTelegramHTML converts markdown to the HTML subset Telegram's+// parse_mode HTML accepts, flattening constructs it has no tag for.+func RenderTelegramHTML(markdown string) (string, error) {+ md := telegramPool.Get().(goldmark.Markdown)+ defer telegramPool.Put(md)+ return render(md, markdown, "Telegram HTML")+}+func render(md goldmark.Markdown, markdown string, format string) (string, error) {var buf bytes.Bufferif err := md.Convert([]byte(markdown), &buf); err != nil {diff --git a/pkg/templating/markdownrenderer/telegram/telegram.go b/pkg/templating/markdownrenderer/telegram/telegram.gonew file mode 100644index 0000000000..2f15e5f524--- /dev/null+++ b/pkg/templating/markdownrenderer/telegram/telegram.go@@ -0,0 +1,360 @@+// Package telegram provides a goldmark node renderer that emits the HTML+// subset Telegram's parse_mode HTML accepts. Telegram rejects the whole+// message when it meets a tag outside that set, so constructs with no+// equivalent (headings, lists, tables, images) are flattened to text rather+// than rendered with their usual tags.+// https://core.telegram.org/bots/api#html-style+package telegram++import (+ "bytes"+ "fmt"+ "strings"++ "github.com/yuin/goldmark"+ "github.com/yuin/goldmark/ast"+ "github.com/yuin/goldmark/extension"+ extensionast "github.com/yuin/goldmark/extension/ast"+ "github.com/yuin/goldmark/renderer"+ "github.com/yuin/goldmark/util"+)++// textEscaper covers the three characters Telegram requires as entities in+// message text. attrEscaper additionally covers the quote that would end an+// href value early.+var (+ textEscaper = strings.NewReplacer("&", "&", "<", "<", ">", ">")+ attrEscaper = strings.NewReplacer("&", "&", "<", "<", ">", ">", `"`, """)+)++// Extender registers the Telegram node renderer plus the GFM extensions it+// handles (tables, strikethrough).+var Extender goldmark.Extender = &extender{}++type extender struct{}++func (e *extender) Extend(m goldmark.Markdown) {+ extension.Table.Extend(m)+ extension.Strikethrough.Extend(m)+ m.Renderer().AddOptions(+ renderer.WithNodeRenderers(util.Prioritized(newRenderer(), 1)),+ )+}++// nodeRenderer holds per-document nesting prefixes, so it is not safe for+// concurrent Convert calls; callers pool one instance per goroutine.+type nodeRenderer struct {+ prefixes []string+}++func newRenderer() renderer.NodeRenderer {+ return &nodeRenderer{}+}++func (r *nodeRenderer) RegisterFuncs(reg renderer.NodeRendererFuncRegisterer) {+ // Blocks+ reg.Register(ast.KindDocument, r.renderDocument)+ reg.Register(ast.KindHeading, r.renderHeading)+ reg.Register(ast.KindBlockquote, r.renderBlockquote)+ reg.Register(ast.KindCodeBlock, r.renderCodeBlock)+ reg.Register(ast.KindFencedCodeBlock, r.renderCodeBlock)+ reg.Register(ast.KindHTMLBlock, r.renderRawHTML)+ reg.Register(ast.KindList, r.renderList)+ reg.Register(ast.KindListItem, r.renderListItem)+ reg.Register(ast.KindParagraph, r.renderBlock)+ reg.Register(ast.KindTextBlock, r.renderTextBlock)+ reg.Register(ast.KindThematicBreak, r.renderThematicBreak)++ // Inlines+ reg.Register(ast.KindAutoLink, r.renderAutoLink)+ reg.Register(ast.KindCodeSpan, r.renderCodeSpan)+ reg.Register(ast.KindEmphasis, r.renderEmphasis)+ reg.Register(ast.KindImage, r.renderImage)+ reg.Register(ast.KindLink, r.renderLink)+ reg.Register(ast.KindText, r.renderText)+ reg.Register(ast.KindString, r.renderString)+ reg.Register(ast.KindRawHTML, r.renderRawHTML)++ // Extensions+ reg.Register(extensionast.KindStrikethrough, r.renderStrikethrough)+ reg.Register(extensionast.KindTable, r.renderTable)+}++func (r *nodeRenderer) writePrefix(w util.BufWriter) {+ for _, p := range r.prefixes {+ _, _ = w.WriteString(p)+ }+}++func (r *nodeRenderer) writeLineSeparator(w util.BufWriter) {+ _ = w.WriteByte('\n')+ r.writePrefix(w)+}++func (r *nodeRenderer) writeBlockSeparator(w util.BufWriter) {+ r.writeLineSeparator(w)+ r.writeLineSeparator(w)+}++func (r *nodeRenderer) separateFromPrevious(w util.BufWriter, n ast.Node) {+ if n.PreviousSibling() != nil {+ r.writeBlockSeparator(w)+ }+}++// wrap emits an opening tag on the way in and its closing tag on the way out.+func wrap(w util.BufWriter, tag string, entering bool) (ast.WalkStatus, error) {+ if entering {+ _, _ = w.WriteString("<" + tag + ">")+ } else {+ _, _ = w.WriteString("</" + tag + ">")+ }+ return ast.WalkContinue, nil+}++func (r *nodeRenderer) renderDocument(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {+ if entering {+ r.prefixes = r.prefixes[:0]+ }+ return ast.WalkContinue, nil+}++func (r *nodeRenderer) renderBlock(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {+ if entering {+ r.separateFromPrevious(w, node)+ }+ return ast.WalkContinue, nil+}++// renderHeading emits bold text: Telegram has no heading tag.+func (r *nodeRenderer) renderHeading(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {+ if entering {+ r.separateFromPrevious(w, node)+ }+ return wrap(w, "b", entering)+}++func (r *nodeRenderer) renderBlockquote(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {+ if entering {+ r.separateFromPrevious(w, node)+ }+ return wrap(w, "blockquote", entering)+}++func (r *nodeRenderer) renderEmphasis(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {+ tag := "i"+ if node.(*ast.Emphasis).Level >= 2 {+ tag = "b"+ }+ return wrap(w, tag, entering)+}++func (r *nodeRenderer) renderStrikethrough(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {+ return wrap(w, "s", entering)+}++func (r *nodeRenderer) renderCodeBlock(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {+ if !entering {+ return ast.WalkContinue, nil+ }+ r.separateFromPrevious(w, n)++ var body bytes.Buffer+ for i := 0; i < n.Lines().Len(); i++ {+ line := n.Lines().At(i)+ body.Write(line.Value(source))+ }++ _, _ = w.WriteString("<pre>")+ _, _ = w.WriteString(textEscaper.Replace(strings.TrimRight(body.String(), "\n")))+ _, _ = w.WriteString("</pre>")++ return ast.WalkContinue, nil+}++func (r *nodeRenderer) renderCodeSpan(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {+ if !entering {+ return ast.WalkContinue, nil+ }++ var body bytes.Buffer+ for c := n.FirstChild(); c != nil; c = c.NextSibling() {+ value := c.(*ast.Text).Segment.Value(source)+ if bytes.HasSuffix(value, []byte("\n")) {+ body.Write(value[:len(value)-1])+ body.WriteByte(' ')+ } else {+ body.Write(value)+ }+ }++ _, _ = w.WriteString("<code>" + textEscaper.Replace(body.String()) + "</code>")++ return ast.WalkSkipChildren, nil+}++// renderList and renderListItem mirror the plain-text renderer: Telegram has no+// list tag, so items become prefixed lines.+func (r *nodeRenderer) renderList(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {+ if entering && node.PreviousSibling() != nil {+ r.writeLineSeparator(w)+ if node.Parent() == nil || node.Parent().Kind() != ast.KindListItem {+ r.writeLineSeparator(w)+ }+ }+ return ast.WalkContinue, nil+}++func (r *nodeRenderer) renderListItem(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {+ if !entering {+ r.prefixes = r.prefixes[:len(r.prefixes)-1]+ return ast.WalkContinue, nil+ }++ if n.PreviousSibling() != nil {+ r.writeLineSeparator(w)+ }++ parent := n.Parent().(*ast.List)+ if parent.IsOrdered() {+ index := parent.Start+ for c := parent.FirstChild(); c != nil && c != n; c = c.NextSibling() {+ index+++ }+ _, _ = fmt.Fprintf(w, "%d. ", index)+ } else {+ _, _ = w.WriteString("• ")+ }+ r.prefixes = append(r.prefixes, " ")++ return ast.WalkContinue, nil+}++func (r *nodeRenderer) renderTextBlock(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {+ if entering && n.PreviousSibling() != nil {+ r.writeLineSeparator(w)+ }+ return ast.WalkContinue, nil+}++func (r *nodeRenderer) renderThematicBreak(w util.BufWriter, source []byte, n ast.Node, entering bool) (ast.WalkStatus, error) {+ if entering {+ r.separateFromPrevious(w, n)+ _, _ = w.WriteString("———")+ }+ return ast.WalkContinue, nil+}++func (r *nodeRenderer) renderAutoLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {+ if !entering {+ return ast.WalkContinue, nil+ }++ n := node.(*ast.AutoLink)+ url := string(n.URL(source))+ if n.AutoLinkType == ast.AutoLinkEmail && !strings.HasPrefix(strings.ToLower(url), "mailto:") {+ url = "mailto:" + url+ }+ _, _ = w.WriteString(`<a href="` + attrEscaper.Replace(url) + `">` + textEscaper.Replace(url) + "</a>")++ return ast.WalkContinue, nil+}++func (r *nodeRenderer) renderLink(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {+ n := node.(*ast.Link)+ if entering {+ _, _ = w.WriteString(`<a href="` + attrEscaper.Replace(string(n.Destination)) + `">`)+ } else {+ _, _ = w.WriteString("</a>")+ }+ return ast.WalkContinue, nil+}++// renderImage flattens to "alt (url)": a Telegram text message cannot carry an+// inline image, and <img> is not on the allowlist.+func (r *nodeRenderer) renderImage(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {+ if !entering {+ n := node.(*ast.Image)+ if len(n.Destination) > 0 {+ _, _ = fmt.Fprintf(w, " (%s)", textEscaper.Replace(string(n.Destination)))+ }+ }+ return ast.WalkContinue, nil+}++func (r *nodeRenderer) renderText(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {+ if !entering {+ return ast.WalkContinue, nil+ }++ n := node.(*ast.Text)+ _, _ = w.WriteString(textEscaper.Replace(string(n.Segment.Value(source))))+ if n.HardLineBreak() || n.SoftLineBreak() {+ r.writeLineSeparator(w)+ }++ return ast.WalkContinue, nil+}++func (r *nodeRenderer) renderString(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {+ if entering {+ _, _ = w.WriteString(textEscaper.Replace(string(node.(*ast.String).Value)))+ }+ return ast.WalkContinue, nil+}++// renderRawHTML drops markup the author embedded by hand. Passing it through+// would hand Telegram tags outside the allowlist and fail the whole send.+func (r *nodeRenderer) renderRawHTML(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {+ return ast.WalkSkipChildren, nil+}++// renderTable flattens to "cell | cell" lines: Telegram has no table tag.+func (r *nodeRenderer) renderTable(w util.BufWriter, source []byte, node ast.Node, entering bool) (ast.WalkStatus, error) {+ if !entering {+ return ast.WalkContinue, nil+ }+ r.separateFromPrevious(w, node)++ first := true+ for c := node.FirstChild(); c != nil; c = c.NextSibling() {+ if c.Kind() != extensionast.KindTableHeader && c.Kind() != extensionast.KindTableRow {+ continue+ }+ if !first {+ r.writeLineSeparator(w)+ }+ first = false++ cellFirst := true+ for cc := c.FirstChild(); cc != nil; cc = cc.NextSibling() {+ if cc.Kind() != extensionast.KindTableCell {+ continue+ }+ if !cellFirst {+ _, _ = w.WriteString(" | ")+ }+ cellFirst = false+ _, _ = w.WriteString(textEscaper.Replace(extractPlainText(cc, source)))+ }+ }++ return ast.WalkSkipChildren, nil+}++func extractPlainText(n ast.Node, source []byte) string {+ var buf bytes.Buffer+ _ = ast.Walk(n, func(node ast.Node, entering bool) (ast.WalkStatus, error) {+ if !entering {+ return ast.WalkContinue, nil+ }+ switch t := node.(type) {+ case *ast.Text:+ buf.Write(t.Segment.Value(source))+ case *ast.String:+ buf.Write(t.Value)+ }+ return ast.WalkContinue, nil+ })+ return strings.TrimSpace(buf.String())+}diff --git a/pkg/templating/markdownrenderer/telegram/telegram_test.go b/pkg/templating/markdownrenderer/telegram/telegram_test.gonew file mode 100644index 0000000000..96050e007e--- /dev/null+++ b/pkg/templating/markdownrenderer/telegram/telegram_test.go@@ -0,0 +1,75 @@+package telegram++import (+ "bytes"+ "testing"++ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+ "github.com/yuin/goldmark"+)++func render(t *testing.T, markdown string) string {+ t.Helper()+ var buf bytes.Buffer+ require.NoError(t, goldmark.New(goldmark.WithExtensions(Extender)).Convert([]byte(markdown), &buf))++ return buf.String()+}++func TestRenderEmitsTelegramHTML(t *testing.T) {+ testCases := []struct {+ name string+ markdown string+ want string+ }{+ {"Bold", "**critical**", "<b>critical</b>"},+ {"Italic", "*degraded*", "<i>degraded</i>"},+ {"Strikethrough", "~~resolved~~", "<s>resolved</s>"},+ {"CodeSpan", "use `kubectl get pods`", "use <code>kubectl get pods</code>"},+ {"Link", "[dashboard](https://signoz.io/d?a=1&b=2)", `<a href="https://signoz.io/d?a=1&b=2">dashboard</a>`},+ {"AutoLink", "<https://signoz.io>", `<a href="https://signoz.io">https://signoz.io</a>`},+ {"Blockquote", "> escalate now", "<blockquote>escalate now</blockquote>"},+ // Telegram has no heading, list, table or image tag, so these flatten.+ {"Heading_BecomesBold", "## Incident", "<b>Incident</b>"},+ {"BulletList_BecomesLines", "- one\n- two", "• one\n• two"},+ {"OrderedList_BecomesLines", "1. one\n2. two", "1. one\n2. two"},+ {"Table_BecomesPipedLines", "| a | b |\n|---|---|\n| 1 | 2 |", "a | b\n1 | 2"},+ {"Image_BecomesTextAndURL", "", "graph (https://signoz.io/g.png)"},+ {"ThematicBreak", "a\n\n---\n\nb", "a\n\n———\n\nb"},+ }++ for _, testCase := range testCases {+ t.Run(testCase.name, func(t *testing.T) {+ assert.Equal(t, testCase.want, render(t, testCase.markdown))+ })+ }+}++// Telegram drops the whole message on an unparseable entity, so anything that+// could be read as markup has to leave as an entity.+func TestRenderEscapesEverythingElse(t *testing.T) {+ testCases := []struct {+ name string+ markdown string+ want string+ }{+ {"BareSpecialChars", "p99 < 2s & rising", "p99 < 2s & rising"},+ {"InsideBold", "**a < b**", "<b>a < b</b>"},+ {"InsideCodeSpan", "`if a < b && c`", "<code>if a < b && c</code>"},+ {"InsideCodeBlock", "```\na < b\n```", "<pre>a < b</pre>"},+ {"InsideLinkText", "[a < b](https://signoz.io)", `<a href="https://signoz.io">a < b</a>`},+ {"QuoteInHref", `[x](https://signoz.io/?q=")`, `<a href="https://signoz.io/?q="">x</a>`},+ // Hand-written markup would hand Telegram tags outside the allowlist.+ // The tags go; the text between them stays.+ {"RawHTMLTagsDropped_TextKept", "before <marquee>x</marquee> after", "before x after"},+ }++ for _, testCase := range testCases {+ t.Run(testCase.name, func(t *testing.T) {+ rendered := render(t, testCase.markdown)+ assert.Equal(t, testCase.want, rendered)+ assert.NotContains(t, rendered, "&lt;", "double-escaped")+ })+ }+}diff --git a/pkg/types/alertmanagertypes/channel_telegram.go b/pkg/types/alertmanagertypes/channel_telegram.gonew file mode 100644index 0000000000..b2b529a526--- /dev/null+++ b/pkg/types/alertmanagertypes/channel_telegram.go@@ -0,0 +1,193 @@+package alertmanagertypes++import (+ "github.com/SigNoz/signoz/pkg/errors"+ "github.com/SigNoz/signoz/pkg/valuer"+ "github.com/prometheus/alertmanager/config"+ commoncfg "github.com/prometheus/common/config"+)++// Telegram renders the message with parse_mode HTML, which only accepts a small+// tag set and requires every stray <, > and & to be escaped. Each interpolated+// value is piped through html so the template renders identically under both+// template engines; an unescaped alert annotation would otherwise fail the+// whole send with "can't parse entities".+// https://core.telegram.org/bots/api#html-style+const (+ // DefaultTelegramTitleTemplate is sent in bold above the message.+ DefaultTelegramTitleTemplate = `[{{ .Status | toUpper }}{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{ end }}] {{ .CommonLabels.alertname | html }}`++ DefaultTelegramMessageTemplate = `{{ range .Alerts -}}+<b>Alert:</b> {{ .Labels.alertname | html }}{{ if .Labels.severity }} ({{ .Labels.severity | html }}){{ end }}+{{ if .Annotations.summary }}<b>Summary:</b> {{ .Annotations.summary | html }}+{{ end }}{{ if .Annotations.description }}<b>Description:</b> {{ .Annotations.description | html }}+{{ end }}{{ if .GeneratorURL }}<a href="{{ .GeneratorURL | html }}">View in SigNoz</a>+{{ end }}{{ if .Annotations.related_logs }}<a href="{{ .Annotations.related_logs | html }}">View related logs</a>+{{ end }}{{ if .Annotations.related_traces }}<a href="{{ .Annotations.related_traces | html }}">View related traces</a>+{{ end }}+{{ end }}`+)++// telegramParseMode is the only mode SigNoz renders for. Upstream also accepts+// Markdown, MarkdownV2 and the empty string, but those carry per-mode escaping+// rules that nothing renders to, so the spec does not offer them.+const telegramParseMode = "HTML"++// ChannelTelegramConfig configures delivery to a Telegram chat through a bot.+// ChatID is the numeric chat the bot posts to, negative for groups and channels;+// Telegram's @username form is not accepted upstream.+type ChannelTelegramConfig struct {+ SendResolved *bool `json:"sendResolved,omitempty"`+ BotToken string `json:"botToken" required:"true" format:"password"`+ ChatID int64 `json:"chatId" required:"true"`+ // APIURL points at a self-hosted Bot API server. Left empty, upstream's+ // default (https://api.telegram.org) applies.+ APIURL valuer.UnsetOrNonEmptyString `json:"apiUrl,omitzero"`+ // MessageThreadID targets a topic inside a forum group.+ MessageThreadID int `json:"messageThreadId,omitempty"`+ Title valuer.UnsetOrNonEmptyString `json:"title,omitzero"`+ Message valuer.UnsetOrNonEmptyString `json:"message,omitzero"`+ DisableNotifications bool `json:"disableNotifications,omitempty"`+}++func (c *ChannelTelegramConfig) UnmarshalJSON(data []byte) error {+ type alias ChannelTelegramConfig+ if err := decodeStrict(data, (*alias)(c)); err != nil {+ return err+ }++ fillSendResolved(&c.SendResolved, DefaultTelegramReceiverConfig.VSendResolved)+ c.Title.SetIfUnset(DefaultTelegramTitleTemplate)+ c.Message.SetIfUnset(DefaultTelegramMessageTemplate)++ return c.Validate()+}++// Validate repeats the checks TelegramReceiverConfig.UnmarshalYAML makes, so+// a bad channel fails on the request with a field name rather than as a yaml+// error surfacing out of the config resolve.+func (c ChannelTelegramConfig) Validate() error {+ if c.BotToken == "" {+ return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.botToken is required for a telegram channel")+ }++ if c.ChatID == 0 {+ return errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "config.spec.chatId is required for a telegram channel")+ }++ return nil+}++func (c ChannelTelegramConfig) toUndefaultedReceiver(displayName string) (*Receiver, error) {+ var apiURL *config.URL+ if !c.APIURL.IsZero() {+ parsed, err := parseUpstreamURL(c.APIURL.StringValue())+ if err != nil {+ return nil, err+ }+ apiURL = parsed+ }++ return &Receiver{+ Receiver: &config.Receiver{Name: displayName},+ TelegramConfigs: []*TelegramReceiverConfig{{+ NotifierConfig: config.NotifierConfig{VSendResolved: resolveSendResolved(c.SendResolved, DefaultTelegramReceiverConfig.VSendResolved)},+ APIUrl: apiURL,+ BotToken: config.Secret(c.BotToken),+ ChatID: c.ChatID,+ MessageThreadID: c.MessageThreadID,+ Title: c.Title.StringValue(),+ Message: c.Message.StringValue(),+ ParseMode: telegramParseMode,+ DisableNotifications: c.DisableNotifications,+ }},+ }, nil+}++func newChannelTelegramConfigFromReceiver(name string, receiver *Receiver) (ChannelSpec, error) {+ telegram := receiver.TelegramConfigs[0]+ sendResolved := telegram.VSendResolved++ if err := rejectAnyHTTPAuth(name, telegram.HTTPConfig); err != nil {+ return nil, err+ }++ // Both read a path on the server's filesystem, so they are refused rather+ // than silently dropped on the way back out.+ if telegram.BotTokenFile != "" {+ return nil, errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "channel %q sets bot_token_file, which is not supported", name)+ }++ if telegram.ChatIDFile != "" {+ return nil, errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "channel %q sets chat_id_file, which is not supported", name)+ }++ // Dropping a non-HTML parse_mode on the way out would silently rewrite the+ // channel on the next write, so it is refused instead.+ if telegram.ParseMode != telegramParseMode {+ return nil, errors.NewInvalidInputf(ErrCodeAlertmanagerChannelInvalid, "channel %q sets parse_mode %q, only %s is supported", name, telegram.ParseMode, telegramParseMode)+ }++ return &ChannelTelegramConfig{+ SendResolved: &sendResolved,+ BotToken: string(telegram.BotToken),+ ChatID: telegram.ChatID,+ APIURL: valuer.UnsetIfEmpty(formatUpstreamURL(telegram.APIUrl)),+ MessageThreadID: telegram.MessageThreadID,+ Title: valuer.UnsetIfEmpty(telegram.Title),+ Message: valuer.UnsetIfEmpty(telegram.Message),+ DisableNotifications: telegram.DisableNotifications,+ }, nil+}++// TelegramReceiverConfig is upstream's TelegramConfig with a Title, under the+// same keys so receivers stored as upstream's still decode. Title has no+// default: a receiver without one sends Message alone.+type TelegramReceiverConfig struct {+ config.NotifierConfig `yaml:",inline" json:",inline"`++ HTTPConfig *commoncfg.HTTPClientConfig `yaml:"http_config,omitempty" json:"http_config,omitempty"`++ APIUrl *config.URL `yaml:"api_url" json:"api_url,omitempty"`+ BotToken config.Secret `yaml:"bot_token,omitempty" json:"token,omitempty"`+ BotTokenFile string `yaml:"bot_token_file,omitempty" json:"token_file,omitempty"`+ ChatID int64 `yaml:"chat_id,omitempty" json:"chat,omitempty"`+ ChatIDFile string `yaml:"chat_id_file,omitempty" json:"chat_file,omitempty"`+ MessageThreadID int `yaml:"message_thread_id,omitempty" json:"message_thread_id,omitempty"`+ Title string `yaml:"title,omitempty" json:"title,omitempty"`+ Message string `yaml:"message,omitempty" json:"message,omitempty"`+ DisableNotifications bool `yaml:"disable_notifications,omitempty" json:"disable_notifications,omitempty"`+ ParseMode string `yaml:"parse_mode,omitempty" json:"parse_mode,omitempty"`+}++var DefaultTelegramReceiverConfig = TelegramReceiverConfig{+ NotifierConfig: config.DefaultTelegramConfig.NotifierConfig,+ Message: config.DefaultTelegramConfig.Message,+ DisableNotifications: config.DefaultTelegramConfig.DisableNotifications,+ ParseMode: config.DefaultTelegramConfig.ParseMode,+}++func (c *TelegramReceiverConfig) UnmarshalYAML(unmarshal func(any) error) error {+ *c = DefaultTelegramReceiverConfig+ type plain TelegramReceiverConfig+ if err := unmarshal((*plain)(c)); err != nil {+ return err+ }++ if c.BotToken != "" && c.BotTokenFile != "" {+ return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "at most one of bot_token & bot_token_file must be configured")+ }+ if c.ChatID == 0 && c.ChatIDFile == "" {+ return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "missing chat_id or chat_id_file on telegram_config")+ }+ if c.ChatID != 0 && c.ChatIDFile != "" {+ return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "at most one of chat_id & chat_id_file must be configured")+ }+ switch c.ParseMode {+ case "", "Markdown", "MarkdownV2", "HTML":+ default:+ return errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "unknown parse_mode on telegram_config, must be Markdown, MarkdownV2, HTML or empty string")+ }++ return nil+}diff --git a/pkg/types/alertmanagertypes/channel_telegram_test.go b/pkg/types/alertmanagertypes/channel_telegram_test.gonew file mode 100644index 0000000000..1b79fdd709--- /dev/null+++ b/pkg/types/alertmanagertypes/channel_telegram_test.go@@ -0,0 +1,150 @@+package alertmanagertypes++import (+ "encoding/json"+ "net/url"+ "testing"+ "time"++ "github.com/prometheus/alertmanager/types"+ "github.com/prometheus/common/model"+ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++func TestChannelTelegramConfigDefaults(t *testing.T) {+ var spec ChannelTelegramConfig+ require.NoError(t, json.Unmarshal([]byte(`{"botToken":"123456:tok","chatId":-1001234567890}`), &spec))++ require.NotNil(t, spec.SendResolved)+ assert.True(t, *spec.SendResolved, "upstream defaults telegram send_resolved on")+ assert.Equal(t, DefaultTelegramTitleTemplate, spec.Title.StringValue())+ assert.Equal(t, DefaultTelegramMessageTemplate, spec.Message.StringValue())+ assert.Empty(t, spec.APIURL, "the notifier defaults it when none is given")+}++func TestChannelTelegramConfigValidation(t *testing.T) {+ testCases := []struct {+ name string+ spec string+ }{+ {"BotToken_Missing", `{"chatId":1}`},+ {"ChatID_Missing", `{"botToken":"123456:tok"}`},+ {"ChatID_Username_Rejected", `{"botToken":"123456:tok","chatId":"@signoz"}`},+ {"ParseMode_NotAField", `{"botToken":"123456:tok","chatId":1,"parseMode":"HTML"}`},+ {"BotTokenFile_NotAField", `{"botToken":"123456:tok","chatId":1,"botTokenFile":"/etc/token"}`},+ }++ for _, testCase := range testCases {+ t.Run(testCase.name, func(t *testing.T) {+ var spec ChannelTelegramConfig+ assert.Error(t, json.Unmarshal([]byte(testCase.spec), &spec))+ })+ }+}++// Settings the spec cannot represent would be dropped on read and silently+// rewrite the channel on the next write, so the read fails instead.+func TestDeriveChannelConfigRejectsUnsupportedTelegramSettings(t *testing.T) {+ testCases := []struct {+ name string+ data string+ }{+ {"BotTokenFile", `{"name":"tg","telegram_configs":[{"chat_id":1,"token_file":"/etc/token"}]}`},+ {"ChatIDFile", `{"name":"tg","telegram_configs":[{"token":"123456:tok","chat_file":"/etc/chat"}]}`},+ {"ParseMode_NotHTML", `{"name":"tg","telegram_configs":[{"token":"123456:tok","chat":1,"parse_mode":"MarkdownV2"}]}`},+ }++ for _, testCase := range testCases {+ t.Run(testCase.name, func(t *testing.T) {+ channel := Channel{DisplayName: "tg", Data: testCase.data}+ _, err := channel.deriveChannelConfig()+ assert.Error(t, err)+ })+ }+}++func TestDefaultTelegramTemplatesEscapeAlertContent(t *testing.T) {+ tmpl, err := FromGlobs([]string{})+ require.NoError(t, err)+ tmpl.ExternalURL = &url.URL{Scheme: "http", Host: "localhost:8080"}++ alert := &types.Alert{+ Alert: model.Alert{+ Labels: model.LabelSet{"alertname": "p99 < 2s & rising", "severity": "critical"},+ Annotations: model.LabelSet{"summary": "latency > 2s", "related_logs": "http://localhost:8080/logs?a=1&b=2"},+ GeneratorURL: "http://localhost:8080/alerts?a=1&b=2",+ },+ UpdatedAt: time.Now(),+ }++ data := tmpl.Data("__receiver", model.LabelSet{}, alert)++ // The channel template is rendered with html/template under parse_mode HTML+ // and with text/template otherwise, so it has to escape identically under+ // both. html/template recognises the html pipeline and adds no second pass.+ renderers := map[string]func(string, any) (string, error){+ "Text": tmpl.ExecuteTextString,+ "HTML": tmpl.ExecuteHTMLString,+ }++ for name, render := range renderers {+ t.Run(name, func(t *testing.T) {+ title, err := render(DefaultTelegramTitleTemplate, data)+ require.NoError(t, err)+ assert.Equal(t, "[FIRING:1] p99 < 2s & rising", title)++ rendered, err := render(DefaultTelegramMessageTemplate, data)+ require.NoError(t, err)++ assert.NotContains(t, rendered, "[FIRING:1]", "the title is sent separately")+ assert.Contains(t, rendered, "<b>Summary:</b> latency > 2s")+ assert.Contains(t, rendered, `<a href="http://localhost:8080/alerts?a=1&b=2">View in SigNoz</a>`)+ assert.Contains(t, rendered, `<a href="http://localhost:8080/logs?a=1&b=2">View related logs</a>`)+ assert.NotContains(t, rendered, "&lt;", "double-escaped")+ assert.NotContains(t, rendered, "View related traces")+ })+ }+}++// HTTPConfig is filled from the global rather than the spec, and the notifier+// refuses to start without it. APIUrl stays unset; the notifier defaults it.+func TestTelegramResolvesTheGlobalHTTPConfigAndLeavesAPIURLUnset(t *testing.T) {+ cfg, err := NewDefaultConfig(GlobalConfig{}, RouteConfig{GroupInterval: 1 * time.Minute, GroupWait: 1 * time.Minute, RepeatInterval: 1 * time.Minute}, "org-1")+ require.NoError(t, err)+ require.NoError(t, cfg.SetGlobalConfig(GlobalConfig{}))++ spec := ChannelTelegramConfig{BotToken: "123456:tok", ChatID: -1001234567890}+ receiver, err := spec.toUndefaultedReceiver("tg")+ require.NoError(t, err)+ require.NoError(t, cfg.CreateReceiver(receiver))++ resolved, err := cfg.Resolved()+ require.NoError(t, err)++ resolvedReceiver, err := resolved.GetReceiver("tg")+ require.NoError(t, err)+ require.Len(t, resolvedReceiver.TelegramConfigs, 1)++ telegram := resolvedReceiver.TelegramConfigs[0]+ assert.Nil(t, telegram.APIUrl)+ assert.NotNil(t, telegram.HTTPConfig)++ stored, err := cfg.GetReceiver("tg")+ require.NoError(t, err)+ assert.Nil(t, stored.TelegramConfigs[0].APIUrl, "no default is stored in the receiver")+}++// Receivers stored before the title existed decode without one and keep+// sending their message alone; only the spec fills the default title.+func TestTelegramReceiverWithoutTitleStaysUntitled(t *testing.T) {+ receiver, err := NewReceiver(`{"name":"tg","telegram_configs":[{"token":"123456:tok","chat":1,"message":"hello"}]}`)+ require.NoError(t, err)+ require.Len(t, receiver.TelegramConfigs, 1)+ assert.Empty(t, receiver.TelegramConfigs[0].Title)+ assert.Equal(t, "hello", receiver.TelegramConfigs[0].Message)++ spec, err := newChannelTelegramConfigFromReceiver("tg", receiver)+ require.NoError(t, err)+ assert.True(t, spec.(*ChannelTelegramConfig).Title.IsZero())+}diff --git a/pkg/types/alertmanagertypes/channelconfig.go b/pkg/types/alertmanagertypes/channelconfig.goindex e2e76c5e2e..bacd0b4ea3 100644--- a/pkg/types/alertmanagertypes/channelconfig.go+++ b/pkg/types/alertmanagertypes/channelconfig.go@@ -96,6 +96,7 @@ func (ChannelConfig) JSONSchemaOneOf() []any {ChannelConfigVariant[ChannelJiraConfig]{Kind: ChannelKindJira.StringValue()},ChannelConfigVariant[ChannelJSMOpsConfig]{Kind: ChannelKindJSMOps.StringValue()},ChannelConfigVariant[ChannelIncidentIOConfig]{Kind: ChannelKindIncidentIO.StringValue()},+ ChannelConfigVariant[ChannelTelegramConfig]{Kind: ChannelKindTelegram.StringValue()},}}@@ -113,6 +114,7 @@ func (ChannelConfig) PrepareJSONSchema(s *jsonschema.Schema) error {ChannelKindJira.StringValue(): channelVariantRef("ChannelJiraConfig"),ChannelKindJSMOps.StringValue(): channelVariantRef("ChannelJSMOpsConfig"),ChannelKindIncidentIO.StringValue(): channelVariantRef("ChannelIncidentIOConfig"),+ ChannelKindTelegram.StringValue(): channelVariantRef("ChannelTelegramConfig"),})}diff --git a/pkg/types/alertmanagertypes/channelconvertors_test.go b/pkg/types/alertmanagertypes/channelconvertors_test.goindex 36ca862c1e..fbf9b0e485 100644--- a/pkg/types/alertmanagertypes/channelconvertors_test.go+++ b/pkg/types/alertmanagertypes/channelconvertors_test.go@@ -258,6 +258,28 @@ func TestDeriveChannelConfigRoundTripsEveryFieldOfEveryKind(t *testing.T) {Metadata: map[string]string{"team": "platform"},},},+ {+ description: "telegram",+ kind: ChannelKindTelegram,+ spec: &ChannelTelegramConfig{+ SendResolved: &sendResolved,+ BotToken: "123456:bot-token",+ ChatID: -1001234567890,+ APIURL: valuer.MustNewUnsetOrNonEmptyString("https://bot-api.example.com"),+ MessageThreadID: 42,+ Message: valuer.MustNewUnsetOrNonEmptyString("telegram message"),+ DisableNotifications: true,+ },+ expectedRoundTrip: &ChannelTelegramConfig{+ SendResolved: &sendResolved,+ BotToken: "123456:bot-token",+ ChatID: -1001234567890,+ APIURL: valuer.MustNewUnsetOrNonEmptyString("https://bot-api.example.com"),+ MessageThreadID: 42,+ Message: valuer.MustNewUnsetOrNonEmptyString("telegram message"),+ DisableNotifications: true,+ },+ },}for _, testCase := range testCases {@@ -396,8 +418,8 @@ func TestDeriveChannelConfigRejectsUnrepresentableChannels(t *testing.T) {{description: "notifier kind outside the supported set",channel: Channel{- DisplayName: "tg",- Data: `{"name":"tg","telegram_configs":[{"chat_id":1}]}`,+ DisplayName: "dc",+ Data: `{"name":"dc","discord_configs":[{"webhook_url":"https://discord.com/api/webhooks/1/x"}]}`,},},{diff --git a/pkg/types/alertmanagertypes/channelkind.go b/pkg/types/alertmanagertypes/channelkind.goindex e4bb26a782..2b1fa12968 100644--- a/pkg/types/alertmanagertypes/channelkind.go+++ b/pkg/types/alertmanagertypes/channelkind.go@@ -29,6 +29,7 @@ var (ChannelKindJira = ChannelKind{valuer.NewString("jira")}ChannelKindJSMOps = ChannelKind{valuer.NewString("jsmops")}ChannelKindIncidentIO = ChannelKind{valuer.NewString("incidentio")}+ ChannelKindTelegram = ChannelKind{valuer.NewString("telegram")})func (ChannelKind) Enum() []any {diff --git a/pkg/types/alertmanagertypes/channelkindregistry.go b/pkg/types/alertmanagertypes/channelkindregistry.goindex 261605b689..feee4c958f 100644--- a/pkg/types/alertmanagertypes/channelkindregistry.go+++ b/pkg/types/alertmanagertypes/channelkindregistry.go@@ -74,6 +74,12 @@ var channelKinds = []channelKindEntry{countConfigs: func(receiver *Receiver) int { return len(receiver.IncidentIOConfigs) },extractSpec: newChannelIncidentIOConfigFromReceiver,},+ {+ kind: ChannelKindTelegram,+ newEmptySpec: func() ChannelSpec { return new(ChannelTelegramConfig) },+ countConfigs: func(receiver *Receiver) int { return len(receiver.TelegramConfigs) },+ extractSpec: newChannelTelegramConfigFromReceiver,+ },}func buildEmptyChannelSpecForKind(kind ChannelKind) (ChannelSpec, bool) {diff --git a/pkg/types/alertmanagertypes/channellist_test.go b/pkg/types/alertmanagertypes/channellist_test.goindex ae3b12ef64..de95fdbfaa 100644--- a/pkg/types/alertmanagertypes/channellist_test.go+++ b/pkg/types/alertmanagertypes/channellist_test.go@@ -43,13 +43,13 @@ func TestListChannelsParamsValidateRejectsALongQuery(t *testing.T) {// possible until they are migrated. One of them must not fail the whole list.func TestChannelToListedChannelLeavesUnmodelledKindsEmpty(t *testing.T) {channel := Channel{- DisplayName: "tg",- Name: "tg",- Type: "telegram",- Data: `{"name":"tg","telegram_configs":[{"chat_id":1}]}`,+ DisplayName: "dc",+ Name: "dc",+ Type: "discord",+ Data: `{"name":"dc","discord_configs":[{"webhook_url":"https://discord.com/api/webhooks/1/x"}]}`,}listed := channel.ToListedNotificationChannel()- assert.Equal(t, "tg", listed.Name)+ assert.Equal(t, "dc", listed.Name)assert.True(t, listed.Kind.IsZero())}diff --git a/pkg/types/alertmanagertypes/config.go b/pkg/types/alertmanagertypes/config.goindex 2d2ed1f481..105f24ed91 100644--- a/pkg/types/alertmanagertypes/config.go+++ b/pkg/types/alertmanagertypes/config.go@@ -73,10 +73,11 @@ type customReceiverConfigs struct {Jira []*JiraReceiverConfigJSMOps []*JSMOpsReceiverConfigIncidentIO []*IncidentIOReceiverConfig+ Telegram []*TelegramReceiverConfig}func (c customReceiverConfigs) isEmpty() bool {- return len(c.GoogleChat) == 0 && len(c.Jira) == 0 && len(c.JSMOps) == 0 && len(c.IncidentIO) == 0+ return len(c.GoogleChat) == 0 && len(c.Jira) == 0 && len(c.JSMOps) == 0 && len(c.IncidentIO) == 0 && len(c.Telegram) == 0}func customConfigsOf(receiver *Receiver) customReceiverConfigs {@@ -85,6 +86,7 @@ func customConfigsOf(receiver *Receiver) customReceiverConfigs {Jira: receiver.JiraConfigs,JSMOps: receiver.JSMOpsConfigs,IncidentIO: receiver.IncidentIOConfigs,+ Telegram: receiver.TelegramConfigs,}}@@ -196,6 +198,7 @@ func extendedReceivers(c *config.Config, customConfigs map[string]customReceiverJiraConfigs: custom.Jira,JSMOpsConfigs: custom.JSMOps,IncidentIOConfigs: custom.IncidentIO,+ TelegramConfigs: custom.Telegram,}}@@ -394,6 +397,7 @@ func (c *Config) GetReceiver(name string) (*Receiver, error) {JiraConfigs: custom.Jira,JSMOpsConfigs: custom.JSMOps,IncidentIOConfigs: custom.IncidentIO,+ TelegramConfigs: custom.Telegram,}, nil}}@@ -488,6 +492,11 @@ func (c *Config) applyNativeDefaults() {ic.HTTPConfig = httpDefault}}+ for _, tc := range custom.Telegram {+ if tc.HTTPConfig == nil {+ tc.HTTPConfig = httpDefault+ }+ }}}diff --git a/pkg/types/alertmanagertypes/receiver.go b/pkg/types/alertmanagertypes/receiver.goindex 8f429da4c4..6da07596ba 100644--- a/pkg/types/alertmanagertypes/receiver.go+++ b/pkg/types/alertmanagertypes/receiver.go@@ -31,6 +31,8 @@ type Receiver struct {// Shadows upstream's incidentio_configs so our custom notifier (templater,// group-key dedup, label metadata) handles it instead of upstream's.IncidentIOConfigs []*IncidentIOReceiverConfig `json:"incidentio_configs,omitempty" yaml:"incidentio_configs,omitempty"`+ // Shadows upstream's telegram_configs to carry a title alongside the message.+ TelegramConfigs []*TelegramReceiverConfig `json:"telegram_configs,omitempty" yaml:"telegram_configs,omitempty"`}// NewReceiver builds a Receiver from its JSON input, applying each notifier@@ -87,6 +89,14 @@ func newDefaultedReceiver(receiver *Receiver) (*Receiver, error) {receiver.IncidentIOConfigs[i] = defaulted}+ for i, tc := range receiver.TelegramConfigs {+ defaulted, err := defaultedNotifierConfig(tc)+ if err != nil {+ return nil, err+ }+ receiver.TelegramConfigs[i] = defaulted+ }+return receiver, nil}diff --git a/tests/fixtures/notification_channel.py b/tests/fixtures/notification_channel.pyindex 84db1e8474..c5580b6041 100644--- a/tests/fixtures/notification_channel.py+++ b/tests/fixtures/notification_channel.py@@ -306,6 +306,82 @@ def incidentio_event_subset(alertname: str, links: list[tuple[str, str]]) -> dic}+TELEGRAM_CHAT_ID = -1001234567890+++def telegram_bot_token(bot: str) -> str:+ return f"123456:{bot}"+++def telegram_path(bot: str) -> str:+ return f"/bot{telegram_bot_token(bot)}/sendMessage"+++def telegram_channel(name: str, bot: str, notification_channel: types.TestContainerDocker) -> dict:+ """The bot token keys the WireMock path. v2 only: v1 keeps upstream's+ default message template instead of SigNoz's."""+ return {+ "name": name,+ "config": {+ "kind": "telegram",+ "spec": {+ "botToken": telegram_bot_token(bot),+ "chatId": TELEGRAM_CHAT_ID,+ "apiUrl": notification_channel.container_configs["8080"].base(),+ },+ },+ }+++# telebot parses result.chat.id as int64, so it must be a number here; a string+# fails the unmarshal and the send is retried forever.+TELEGRAM_OK_BODY = {"ok": True, "result": {"message_id": 1, "date": 0, "chat": {"id": TELEGRAM_CHAT_ID, "type": "supergroup"}}}+++def telegram_ok_mappings(path: str) -> list[Mapping]:+ return [+ Mapping(+ request=MappingRequest(method=HttpMethods.POST, url_path=path),+ response=MappingResponse(status=200, json_body=TELEGRAM_OK_BODY),+ )+ ]+++def telegram_retry_mappings(path: str) -> list[Mapping]:+ """429 on the first call then 200, via a wiremock scenario transition."""+ scenario = f"telegram-retry-{path}"+ return [+ Mapping(+ request=MappingRequest(method=HttpMethods.POST, url_path=path),+ response=MappingResponse(status=429, json_body={"ok": False, "error_code": 429, "description": "Too Many Requests: retry after 1", "parameters": {"retry_after": 1}}),+ scenario_name=scenario,+ required_scenario_state="Started",+ new_scenario_state="ok",+ ),+ Mapping(+ request=MappingRequest(method=HttpMethods.POST, url_path=path),+ response=MappingResponse(status=200, json_body=TELEGRAM_OK_BODY),+ scenario_name=scenario,+ required_scenario_state="ok",+ ),+ ]+++def telegram_message_subset(alertname: str, links: list[tuple[str, str]]) -> dict:+ """links: (text, href_regex) pairs in default-template order (View in+ SigNoz -> related logs -> related traces). telebot sends every param as a+ string."""+ text = "(?s)" + re.escape(f"<b>[FIRING:1] {alertname}</b>") + ".*" + re.escape(f"<b>Alert:</b> {alertname}")+ for label, href in links:+ text += rf".*<a href=\"[^\"]*{href}[^\"]*\">{re.escape(label)}</a>"+ return {+ "chat_id": str(TELEGRAM_CHAT_ID),+ "parse_mode": "HTML",+ "disable_web_page_preview": "true",+ "text": re.compile(text),+ }++JIRA_TEST_EMAIL = "[email protected]"JIRA_SA_EMAIL = "[email protected]"JIRA_TEST_TOKEN = "jira-test-token" # noqa: S105diff --git a/tests/integration/tests/alertmanager/05_notification_channel_repair.py b/tests/integration/tests/alertmanager/05_notification_channel_repair.pyindex 2c8950188e..87c218d563 100644--- a/tests/integration/tests/alertmanager/05_notification_channel_repair.py+++ b/tests/integration/tests/alertmanager/05_notification_channel_repair.py@@ -57,7 +57,7 @@ def test_repair_deletes_a_legacy_channel_of_an_unmodelled_kind(cleanup_notification_channels: list[str],) -> None:token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)- name = f"legacy-telegram-{uuid.uuid4().hex[:8]}"+ name = f"legacy-pushover-{uuid.uuid4().hex[:8]}"response = requests.post(signoz.self.host_configs["8080"].get(V2_BASE_URL),@@ -68,7 +68,7 @@ def test_repair_deletes_a_legacy_channel_of_an_unmodelled_kind(assert response.status_code == HTTPStatus.CREATED, response.textchannel_id = response.json()["data"]["id"]cleanup_notification_channels.append(channel_id)- rewrite_channel_as_legacy_receiver(signoz, channel_id, {"name": name, "telegram_configs": [{"chat": 12345, "token": "telegram-bot-token"}]})+ rewrite_channel_as_legacy_receiver(signoz, channel_id, {"name": name, "pushover_configs": [{"user_key": "pushover-user-key", "token": "pushover-token"}]})# v2 lists the row with an empty kind and refuses to read it.response = requests.get(@@ -241,7 +241,7 @@ def test_repair_splits_off_an_unmodelled_notifier_for_its_own_delete({"name": name,"slack_configs": [{"api_url": "https://hooks.slack.test/services/T/B/X", "channel": "#alerts"}],- "telegram_configs": [{"chat": 12345, "token": "telegram-bot-token"}],+ "pushover_configs": [{"user_key": "pushover-user-key", "token": "pushover-token"}],},)@@ -257,8 +257,8 @@ def test_repair_splits_off_an_unmodelled_notifier_for_its_own_delete(assert repair["applied"] is Trueassert [channel["displayName"] for channel in repair["channels"]] == [name, f"{name} (2)"]assert [channel["kind"] for channel in repair["channels"]] == ["slack", ""]- telegram_id = repair["channels"][1]["id"]- cleanup_notification_channels.append(telegram_id)+ pushover_id = repair["channels"][1]["id"]+ cleanup_notification_channels.append(pushover_id)response = requests.get(signoz.self.host_configs["8080"].get(f"{V2_BASE_URL}/{channel_id}"),@@ -269,7 +269,7 @@ def test_repair_splits_off_an_unmodelled_notifier_for_its_own_delete(assert response.json()["data"]["config"]["kind"] == "slack"response = requests.post(- signoz.self.host_configs["8080"].get(f"{V2_BASE_URL}/{telegram_id}/repair"),+ signoz.self.host_configs["8080"].get(f"{V2_BASE_URL}/{pushover_id}/repair"),headers={"Authorization": f"Bearer {token}"},timeout=TIMEOUT,)diff --git a/tests/integration/tests/alertmanager/07_notification_channels_v2_rejections.py b/tests/integration/tests/alertmanager/07_notification_channels_v2_rejections.pyindex 6d587ca1a3..c3e372e996 100644--- a/tests/integration/tests/alertmanager/07_notification_channels_v2_rejections.py+++ b/tests/integration/tests/alertmanager/07_notification_channels_v2_rejections.py@@ -427,7 +427,7 @@ def test_create_rejects_invalid_bodies([pytest.param({"sort": "data"}, id="sort_outside_the_enum"),pytest.param({"order": "sideways"}, id="order_outside_the_enum"),- pytest.param({"kind": "telegram"}, id="kind_outside_the_enum"),+ pytest.param({"kind": "pushover"}, id="kind_outside_the_enum"),pytest.param({"limit": -1}, id="negative_limit"),pytest.param({"offset": -1}, id="negative_offset"),],diff --git a/tests/integration/tests/alertmanager/08_notification_channels_v1_v2.py b/tests/integration/tests/alertmanager/08_notification_channels_v1_v2.pyindex 4ec336c82b..50f3ce514c 100644--- a/tests/integration/tests/alertmanager/08_notification_channels_v1_v2.py+++ b/tests/integration/tests/alertmanager/08_notification_channels_v1_v2.py@@ -75,7 +75,7 @@ def test_get_reflects_a_v2_update_after_a_v1_create("receiver",[pytest.param(- {"telegram_configs": [{"chat": 12345, "token": "telegram-bot-token"}]},+ {"pushover_configs": [{"user_key": "pushover-user-key", "token": "pushover-token"}]},id="kind_v2_does_not_model",),pytest.param(@@ -115,7 +115,7 @@ def test_update_retypes_a_legacy_channel_of_an_unmodelled_kind(cleanup_notification_channels: list[str],) -> None:token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)- name = f"legacy-telegram-{uuid.uuid4().hex[:8]}"+ name = f"legacy-pushover-{uuid.uuid4().hex[:8]}"response = requests.post(signoz.self.host_configs["8080"].get(V2_BASE_URL),@@ -126,7 +126,7 @@ def test_update_retypes_a_legacy_channel_of_an_unmodelled_kind(assert response.status_code == HTTPStatus.CREATED, response.textchannel_id = response.json()["data"]["id"]cleanup_notification_channels.append(channel_id)- rewrite_channel_as_legacy_receiver(signoz, channel_id, {"name": name, "telegram_configs": [{"chat": 12345, "token": "telegram-bot-token"}]})+ rewrite_channel_as_legacy_receiver(signoz, channel_id, {"name": name, "pushover_configs": [{"user_key": "pushover-user-key", "token": "pushover-token"}]})response = requests.get(signoz.self.host_configs["8080"].get(f"{V2_BASE_URL}/{channel_id}"),diff --git a/tests/integration/tests/alertmanager/17_telegram.py b/tests/integration/tests/alertmanager/17_telegram.pynew file mode 100644index 0000000000..663f08b5bf--- /dev/null+++ b/tests/integration/tests/alertmanager/17_telegram.py@@ -0,0 +1,204 @@+import json+import uuid+from collections.abc import Callable+from datetime import UTC, datetime, timedelta+from http import HTTPStatus++import pytest+import requests+from wiremock.resources.mappings import Mapping++from fixtures import types+from fixtures.alerts import (+ get_testdata_file_path,+ update_rule_channel_name,+ verify_notification_expectation,+)+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD+from fixtures.notification_channel import (+ telegram_channel,+ telegram_message_subset,+ telegram_ok_mappings,+ telegram_path,+ telegram_retry_mappings,+ wait_for_alertmanager_sync,+)++V2_BASE_URL = "/api/v2/notification_channels"++METRICS_DATA = "ruler/test_scenarios/threshold_above_at_least_once/alert_data.jsonl"+METRICS_RULE = "ruler/test_scenarios/threshold_above_at_least_once/rule.json"+LOGS_DATA = "ruler/test_scenarios/threshold_below_at_least_once/alert_data.jsonl"+LOGS_RULE = "ruler/test_scenarios/threshold_below_at_least_once/rule.json"+TRACES_DATA = "ruler/test_scenarios/threshold_above_average/alert_data.jsonl"+TRACES_RULE = "ruler/test_scenarios/threshold_above_average/rule.json"+++# channel_config holds the bot name; the v2 body is built at runtime since it+# needs the WireMock host.+TELEGRAM_CASES = [+ types.AlertManagerNotificationTestCase(+ name="telegram_default_metrics_firing",+ rule_path=METRICS_RULE,+ alert_data=[types.AlertData(type="metrics", data_path=METRICS_DATA)],+ channel_config={"bot": "tg-metrics"},+ notification_expectation=types.AMNotificationExpectation(+ should_notify=True,+ wait_time_seconds=60,+ notification_validations=[+ types.NotificationValidation(+ destination_type="webhook",+ validation_data={+ "path": telegram_path("tg-metrics"),+ "count": 1,+ "json_body": telegram_message_subset("threshold_above_at_least_once", [("View in SigNoz", r"/alerts/overview\?ruleId=")]),+ },+ ),+ ],+ ),+ ),+ types.AlertManagerNotificationTestCase(+ name="telegram_rich_message_logs",+ rule_path=LOGS_RULE,+ alert_data=[types.AlertData(type="logs", data_path=LOGS_DATA)],+ channel_config={"bot": "tg-logs"},+ notification_expectation=types.AMNotificationExpectation(+ should_notify=True,+ wait_time_seconds=60,+ notification_validations=[+ types.NotificationValidation(+ destination_type="webhook",+ validation_data={+ "path": telegram_path("tg-logs"),+ "count": 1,+ "json_body": telegram_message_subset(+ "threshold_below_at_least_once",+ [("View in SigNoz", r"/alerts/overview\?ruleId="), ("View related logs", r"/logs/logs-explorer\?")],+ ),+ },+ ),+ ],+ ),+ ),+ types.AlertManagerNotificationTestCase(+ name="telegram_rich_message_traces",+ rule_path=TRACES_RULE,+ alert_data=[types.AlertData(type="traces", data_path=TRACES_DATA)],+ channel_config={"bot": "tg-traces"},+ notification_expectation=types.AMNotificationExpectation(+ should_notify=True,+ wait_time_seconds=60,+ notification_validations=[+ types.NotificationValidation(+ destination_type="webhook",+ validation_data={+ "path": telegram_path("tg-traces"),+ "count": 1,+ "json_body": telegram_message_subset(+ "threshold_above_average",+ [("View in SigNoz", r"/alerts/overview\?ruleId="), ("View related traces", r"traces-explorer\?")],+ ),+ },+ ),+ ],+ ),+ ),+]+++ "telegram_test_case",+ TELEGRAM_CASES,+ ids=lambda c: c.name,+)+def test_telegram_notifier( # pylint: disable=too-many-arguments,too-many-positional-arguments+ signoz: types.SigNoz,+ get_token: Callable[[str, str], str],+ create_user_admin: None, # pylint: disable=unused-argument+ notification_channel: types.TestContainerDocker,+ make_http_mocks: Callable[[types.TestContainerDocker, list[Mapping]], None],+ cleanup_notification_channels: list[str],+ create_alert_rule: Callable[[dict], str],+ insert_alert_data: Callable[[list[types.AlertData], datetime], None],+ maildev: types.TestContainerDocker,+ telegram_test_case: types.AlertManagerNotificationTestCase,+) -> None:+ channel_name = str(uuid.uuid4())+ path = telegram_test_case.notification_expectation.notification_validations[0].validation_data["path"]+ admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)++ make_http_mocks(notification_channel, telegram_ok_mappings(path))++ response = requests.post(+ signoz.self.host_configs["8080"].get(V2_BASE_URL),+ json=telegram_channel(channel_name, telegram_test_case.channel_config["bot"], notification_channel),+ headers={"Authorization": f"Bearer {admin_token}"},+ timeout=10,+ )+ assert response.status_code == HTTPStatus.CREATED, response.text+ cleanup_notification_channels.append(response.json()["data"]["id"])+ wait_for_alertmanager_sync(signoz, admin_token, notification_channel)++ insert_alert_data(telegram_test_case.alert_data, base_time=datetime.now(tz=UTC) - timedelta(minutes=5))++ with open(get_testdata_file_path(telegram_test_case.rule_path), encoding="utf-8") as f:+ rule_data = json.loads(f.read())+ update_rule_channel_name(rule_data, channel_name)+ create_alert_rule(rule_data)++ verify_notification_expectation(notification_channel, maildev, telegram_test_case.notification_expectation)+++def test_telegram_retry_429_then_200( # pylint: disable=too-many-arguments,too-many-positional-arguments+ signoz: types.SigNoz,+ get_token: Callable[[str, str], str],+ create_user_admin: None, # pylint: disable=unused-argument+ notification_channel: types.TestContainerDocker,+ make_http_mocks: Callable[[types.TestContainerDocker, list[Mapping]], None],+ cleanup_notification_channels: list[str],+ create_alert_rule: Callable[[dict], str],+ insert_alert_data: Callable[[list[types.AlertData], datetime], None],+ maildev: types.TestContainerDocker,+) -> None:+ channel_name = str(uuid.uuid4())+ path = telegram_path("tg-retry")+ admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)++ make_http_mocks(notification_channel, telegram_retry_mappings(path))++ response = requests.post(+ signoz.self.host_configs["8080"].get(V2_BASE_URL),+ json=telegram_channel(channel_name, "tg-retry", notification_channel),+ headers={"Authorization": f"Bearer {admin_token}"},+ timeout=10,+ )+ assert response.status_code == HTTPStatus.CREATED, response.text+ cleanup_notification_channels.append(response.json()["data"]["id"])+ wait_for_alertmanager_sync(signoz, admin_token, notification_channel)++ insert_alert_data([types.AlertData(type="metrics", data_path=METRICS_DATA)], base_time=datetime.now(tz=UTC) - timedelta(minutes=5))++ with open(get_testdata_file_path(METRICS_RULE), encoding="utf-8") as f:+ rule_data = json.loads(f.read())+ update_rule_channel_name(rule_data, channel_name)+ create_alert_rule(rule_data)++ verify_notification_expectation(+ notification_channel,+ maildev,+ types.AMNotificationExpectation(+ should_notify=True,+ wait_time_seconds=60,+ notification_validations=[+ types.NotificationValidation(+ destination_type="webhook",+ validation_data={+ # a retryable 429 is followed by a successful re-POST => >=2 hits+ "path": path,+ "min_count": 2,+ "json_body": {"parse_mode": "HTML"},+ },+ ),+ ],+ ),+ )diff --git a/tests/integration/tests/alertmanager/18_telegram_test_channel.py b/tests/integration/tests/alertmanager/18_telegram_test_channel.pynew file mode 100644index 0000000000..516812ede2--- /dev/null+++ b/tests/integration/tests/alertmanager/18_telegram_test_channel.py@@ -0,0 +1,101 @@+import base64+import json+import re+import uuid+from collections.abc import Callable+from http import HTTPStatus+from typing import NamedTuple++import pytest+import requests+from wiremock.resources.mappings import HttpMethods, Mapping, MappingRequest, MappingResponse++from fixtures import types+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD+from fixtures.notification_channel import TELEGRAM_CHAT_ID, TELEGRAM_OK_BODY, telegram_channel, telegram_path, wait_for_alertmanager_sync+++# channel test (POST /api/v2/notification_channels/test) drives the notifier once,+# synchronously, with a hardcoded test alert and no retry — the deterministic place+# to assert permanent-failure behaviour. Rich messages + retry are covered in+# alertmanager/17_telegram.py. Error bodies are the Bot API's {ok, error_code, description}.+class TestChannelCase(NamedTuple):+ __test__ = False+ name: str+ bot: str+ status: int # stub status+ body: dict # stub body+ expected_error: str | None # the notifier's error text, None when delivered+++TEST_CHANNEL_CASES = [+ TestChannelCase("success", "tg-tc-ok", 200, TELEGRAM_OK_BODY, None),+ TestChannelCase("chat_not_found_400", "tg-tc-400", 400, {"ok": False, "error_code": 400, "description": "Bad Request: chat not found"}, "unexpected status code 400"),+ TestChannelCase("unauthorized_401", "tg-tc-401", 401, {"ok": False, "error_code": 401, "description": "Unauthorized"}, "unexpected status code 401"),+]+++ "case",+ TEST_CHANNEL_CASES,+ ids=lambda c: c.name,+)+def test_telegram_test_channel( # pylint: disable=too-many-arguments,too-many-positional-arguments+ signoz: types.SigNoz,+ get_token: Callable[[str, str], str],+ create_user_admin: None, # pylint: disable=unused-argument+ notification_channel: types.TestContainerDocker,+ make_http_mocks: Callable[[types.TestContainerDocker, list[Mapping]], None],+ case: TestChannelCase,+) -> None:+ path = telegram_path(case.bot)+ make_http_mocks(+ notification_channel,+ [+ Mapping(+ request=MappingRequest(method=HttpMethods.POST, url_path=path),+ response=MappingResponse(status=case.status, json_body=case.body),+ )+ ],+ )++ admin_token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)+ wait_for_alertmanager_sync(signoz, admin_token, notification_channel)++ response = requests.post(+ signoz.self.host_configs["8080"].get("/api/v2/notification_channels/test"),+ json={"config": telegram_channel(str(uuid.uuid4()), case.bot, notification_channel)["config"]},+ headers={"Authorization": f"Bearer {admin_token}"},+ timeout=30,+ )++ if case.expected_error is None:+ assert response.status_code == HTTPStatus.NO_CONTENT, f"expected 204, got {response.status_code}: {response.text}"+ else:+ # a Bot API error surfaces as a 500 (untyped notify error) whose body+ # carries the status code and the Bot API's description+ assert response.status_code == HTTPStatus.INTERNAL_SERVER_ERROR, f"expected 500, got {response.status_code}: {response.text}"+ assert case.expected_error in response.text, f"expected {case.expected_error!r} in error body: {response.text}"+ assert case.body["description"] in response.text, f"expected {case.body['description']!r} in error body: {response.text}"++ # exactly one delivery attempt either way (testChannel never retries)+ count = requests.post(+ notification_channel.host_configs["8080"].get("/__admin/requests/count"),+ json={"method": "POST", "urlPath": path},+ timeout=10,+ )+ assert count.json()["count"] == 1, f"expected exactly 1 request (no retry), got {count.text}"++ find = requests.post(+ notification_channel.host_configs["8080"].get("/__admin/requests/find"),+ json={"method": "POST", "urlPath": path},+ timeout=10,+ )+ req = find.json()["requests"][0]+ # the bot token travels in the path, appended to the configured api url+ assert req["url"] == path, f"expected {path}, got {req['url']}"++ message = json.loads(base64.b64decode(req["bodyAsBase64"]).decode("utf-8"))+ assert message["chat_id"] == str(TELEGRAM_CHAT_ID)+ assert message["parse_mode"] == "HTML"+ assert re.search(r"<b>\[FIRING:1\] Test Alert \(", message["text"]), f"unexpected text: {message['text']}"