Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

fix(channels): propagate delivery errors without exposing credentials (#22033)

Sbaaoui Idrisscf4d0cc450cf
diff --git a/internal/channels/telegram.go b/internal/channels/telegram.go
index c923ff15e2..905ca6016b 100644
--- a/internal/channels/telegram.go
+++ b/internal/channels/telegram.go
@@ -203,8 +203,7 @@ func (c *telegramChannel) Stop(ctx context.Context) error {
func (c *telegramChannel) Send(ctx context.Context, msg core.OutgoingMessage) error {
chatID, err := strconv.ParseInt(strings.TrimSpace(msg.ChatID), 10, 64)
if err != nil {
- common.Warn("telegram: invalid chat_id", zap.String("account_id", c.account.AccountID), zap.String("chat_id", msg.ChatID), zap.Error(err))
- return nil
+ return fmt.Errorf("telegram: invalid chat_id: %w", err)
}
payload := map[string]any{
@@ -219,10 +218,7 @@ func (c *telegramChannel) Send(ctx context.Context, msg core.OutgoingMessage) er
}
}
}
- if err := c.callAPI(ctx, "sendMessage", payload, nil); err != nil {
- common.Error("telegram: send failed", err, zap.String("account_id", c.account.AccountID))
- }
- return nil
+ return c.callAPI(ctx, "sendMessage", payload, nil)
}
// run drops queued updates and consumes Telegram updates until stopped.
diff --git a/internal/channels/telegram_test.go b/internal/channels/telegram_test.go
index f1f67bcea8..1fcb377e6a 100644
--- a/internal/channels/telegram_test.go
+++ b/internal/channels/telegram_test.go
@@ -195,10 +195,26 @@ func TestTelegramSendUsesReplyParameters(t *testing.T) {
}
}
-func TestTelegramSendIgnoresInvalidChatID(t *testing.T) {
+func TestTelegramSendRejectsInvalidChatID(t *testing.T) {
ch := newTelegramChannel(telegramAccount{AccountID: "account-1", Token: "token"})
- if err := ch.Send(context.Background(), core.OutgoingMessage{ChatID: "invalid", Text: "answer"}); err != nil {
- t.Fatalf("Send() error = %v, want nil", err)
+ if err := ch.Send(t.Context(), core.OutgoingMessage{ChatID: "invalid", Text: "answer"}); err == nil {
+ t.Fatal("Send() succeeded with an invalid chat ID")
+ }
+}
+
+func TestTelegramSendReturnsTransportError(t *testing.T) {
+ const token = "sensitive-bot-token"
+ transportErr := errors.New("connection refused")
+ ch := newTelegramChannel(telegramAccount{AccountID: "account-1", Token: token})
+ ch.client = &http.Client{Transport: telegramRoundTripperFunc(func(*http.Request) (*http.Response, error) {
+ return nil, transportErr
+ })}
+ err := ch.Send(t.Context(), core.OutgoingMessage{ChatID: "42", Text: "answer"})
+ if !errors.Is(err, transportErr) {
+ t.Fatalf("Send() error = %v, want transport failure", err)
+ }
+ if strings.Contains(err.Error(), token) {
+ t.Fatalf("Send() exposed token: %v", err)
}
}
diff --git a/internal/channels/wecom.go b/internal/channels/wecom.go
index a3a5e347af..2f04db1f33 100644
--- a/internal/channels/wecom.go
+++ b/internal/channels/wecom.go
@@ -317,15 +317,9 @@ func (c *wecomChannel) Stop(ctx context.Context) error {
// Send sends an application message or a WebSocket bot message.
func (c *wecomChannel) Send(ctx context.Context, msg core.OutgoingMessage) error {
if c.account.ConnectionType == "websocket" {
- if err := c.sendWebSocketMessage(msg); err != nil {
- common.Error("wecom: websocket send failed", err, zap.String("account_id", c.account.AccountID))
- }
- return nil
+ return c.sendWebSocketMessage(msg)
}
- if err := c.sendApplicationMessage(ctx, msg); err != nil {
- common.Error("wecom: application send failed", redactURLError(err), zap.String("account_id", c.account.AccountID))
- }
- return nil
+ return redactURLError(c.sendApplicationMessage(ctx, msg))
}
func (c *wecomChannel) runWebSocket(ctx context.Context) {
@@ -659,7 +653,7 @@ func redactURLError(err error) error {
return urlErr
}
parsed.RawQuery = ""
- return &url.Error{Op: urlErr.Op, URL: parsed.String(), Err: urlErr.Err}
+ return &url.Error{Op: urlErr.Op, URL: parsed.String(), Err: redactURLError(urlErr.Err)}
}
func (c *wecomChannel) handleTextMessage(ctx context.Context, chatID, senderID, messageID, text, chatType string, raw map[string]any) {
diff --git a/internal/channels/wecom_test.go b/internal/channels/wecom_test.go
index a3f3aa569d..dd0686ecc1 100644
--- a/internal/channels/wecom_test.go
+++ b/internal/channels/wecom_test.go
@@ -479,7 +479,7 @@ func TestWeComWebSocketMessagePreservesWhitespaceAndFallsBackToSender(t *testing
}
}
-func TestWeComSendIgnoresTransportErrors(t *testing.T) {
+func TestWeComSendReturnsTransportErrors(t *testing.T) {
channel, err := newWeComChannel(wecomAccount{
AccountID: "account-1",
ConnectionType: "websocket",
@@ -489,8 +489,31 @@ func TestWeComSendIgnoresTransportErrors(t *testing.T) {
if err != nil {
t.Fatalf("newWeComChannel() error = %v", err)
}
- if err := channel.Send(context.Background(), core.OutgoingMessage{ChatID: "chat-1", Text: "answer"}); err != nil {
- t.Fatalf("Send() error = %v, want nil", err)
+ if err := channel.Send(t.Context(), core.OutgoingMessage{ChatID: "chat-1", Text: "answer"}); err == nil {
+ t.Fatal("Send() succeeded without a websocket connection")
+ }
+}
+
+func TestWeComSendRedactsApplicationTransportError(t *testing.T) {
+ aesKey, _ := testWeComAESKey()
+ channel, err := newWeComChannel(wecomAccount{
+ AccountID: "account-1", CorpID: "corp", AgentID: 1, Secret: "secret",
+ Token: "token", AESKey: aesKey,
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+ channel.accessToken = "sensitive-access-token"
+ channel.tokenExpiry = time.Now().Add(time.Hour)
+ channel.client = &http.Client{Transport: telegramRoundTripperFunc(func(req *http.Request) (*http.Response, error) {
+ return nil, &url.Error{Op: "Post", URL: req.URL.String(), Err: net.ErrClosed}
+ })}
+ err = channel.Send(t.Context(), core.OutgoingMessage{ChatID: "user-1", Text: "answer"})
+ if err == nil {
+ t.Fatal("Send() succeeded after a transport failure")
+ }
+ if strings.Contains(err.Error(), channel.accessToken) {
+ t.Fatalf("Send() exposed access token: %v", err)
}
}