Unfurling Discord Message Links

.env.example

@@ -19,6 +19,8 @@ export SLACK_TEAM_ID="__SLACK_TEAM_ID__"
 export SLACK_REDIRECT_URI="__SLACK_REDIRECT_URI__"
 export SLACK_BOT_USER_OAUTH_TOKEN="__SLACK_BOT_USER_OAUTH_TOKEN__"
 
+export DISCORD_BOT_TOKEN="__DISCORD_BOT_TOKEN__"
+
 export SENTRY_BACKEND_DSN="__SENTRY_BACKEND_DSN__"
 export SENTRY_FRONTEND_DSN="__SENTRY_BACKEND_DSN__"
 export SENTRY_POTAL_DSN="__SENTRY_POTAL_DSN__"

docker-compose.yml

@@ -22,6 +22,7 @@ services:
         - SLACK_TEAM_ID
         - SLACK_REDIRECT_URI
         - SLACK_BOT_USER_OAUTH_TOKEN
+        - DISCORD_BOT_TOKEN
         - SENTRY_BACKEND_DSN
         - SENTRY_FRONTEND_DSN
         - SENTRY_AUTH_TOKEN

docker/backend/Dockerfile

@@ -1,4 +1,4 @@
-FROM ubuntu:22.04 as php-local
+FROM ubuntu:22.04 AS php-local
 
 ENV DEBIAN_FRONTEND=noninteractive
 
@@ -58,7 +58,7 @@ EXPOSE 8080
 
 CMD [ "/bin/bash", "/run.sh" ]
 
-FROM node:18-bullseye as js-build
+FROM node:18-bullseye AS js-build
 
 WORKDIR /app
 

potal/handler.go

@@ -223,6 +223,32 @@ func EventsHandler(w http.ResponseWriter, r *http.Request, _ httprouter.Params)
 					return
 				}
 
+				txn.Status = sentry.SpanStatusOK
+			}()
+		case *slackevents.LinkSharedEvent:
+			go event.ProcessLinkSharedEvent(r.Context(), ev)
+			go func() {
+				hub := sentry.CurrentHub().Clone()
+				ctx := sentry.SetHubOnContext(context.Background(), hub)
+
+				options := []sentry.SpanOption{
+					sentry.WithOpName("event.handler"),
+					sentry.WithTransactionSource(sentry.SourceTask),
+					sentry.ContinueFromHeaders(transaction.ToSentryTrace(), transaction.ToBaggage()),
+				}
+				txn := sentry.StartTransaction(ctx, "EVENT link_shared", options...)
+				defer txn.Finish()
+
+				processedEvent := event.ProcessLinkSharedEvent(txn.Context(), ev)
+				if processedEvent == nil {
+					return
+				}
+				err := potalhttp.SendRequest(txn.Context(), processedEvent)
+				if err != nil {
+					txn.Status = sentry.SpanStatusInternalError
+					return
+				}
+
 				txn.Status = sentry.SpanStatusOK
 			}()
 		}

potal/internal/event/event.go

@@ -14,6 +14,7 @@ const (
 	appHomeOpened       PotalEventType = "app_home_opened"
 	slashCommand        PotalEventType = "slash_command"
 	interactionCallback PotalEventType = "interaction_callback"
+	linkShared          PotalEventType = "link_shared"
 )
 
 func (e PotalEventType) String() string {

potal/internal/event/linkshared.go

@@ -0,0 +1,68 @@
+package event
+
+import (
+	"context"
+
+	"github.com/getsentry/sentry-go"
+	"github.com/slack-go/slack/slackevents"
+)
+
+type LinkSharedEvent struct {
+	Type             PotalEventType `json:"type"`
+	User             string         `json:"user"`
+	TimeStamp        string         `json:"ts"`
+	Channel          string         `json:"channel"`
+	MessageTimeStamp string         `json:"message_ts"`
+	ThreadTimeStamp  string         `json:"thread_ts"`
+	Links            []Link         `json:"links"`
+	EventTimestamp   string         `json:"event_ts"`
+}
+
+type Link struct {
+	Domain string `json:"domain"`
+	URL    string `json:"url"`
+}
+
+func (e LinkSharedEvent) isValid() bool {
+	// App unfurl domains are configured in the Slack's app settings,
+	// so we don't need validate the domain here.
+	return len(e.Links) > 0
+}
+
+func ProcessLinkSharedEvent(ctx context.Context, e *slackevents.LinkSharedEvent) *LinkSharedEvent {
+	hub := sentry.GetHubFromContext(ctx)
+	txn := sentry.TransactionFromContext(ctx)
+
+	span := txn.StartChild("event.process", sentry.WithDescription("Process LinkShared Event"))
+	defer span.Finish()
+
+	links := make([]Link, len(e.Links))
+	for i, link := range e.Links {
+		links[i] = Link{
+			Domain: link.Domain,
+			URL:    link.URL,
+		}
+	}
+
+	linkSharedEvent := LinkSharedEvent{
+		Type:             linkShared,
+		User:             e.User,
+		TimeStamp:        e.TimeStamp,
+		Channel:          e.Channel,
+		MessageTimeStamp: e.MessageTimeStamp,
+		ThreadTimeStamp:  e.ThreadTimeStamp,
+		Links:            links,
+		EventTimestamp:   e.EventTimestamp,
+	}
+
+	if !linkSharedEvent.isValid() {
+		span.Status = sentry.SpanStatusInvalidArgument
+		return nil
+	}
+	span.Status = sentry.SpanStatusOK
+
+	hub.Scope().SetExtra("event", linkSharedEvent)
+	hub.Scope().SetTag("event_type", linkShared.String())
+
+	return &linkSharedEvent
+}

src/Event/AbstractEvent.php

@@ -3,6 +3,7 @@
 
 namespace App\Event;
 
+use App\Http\DiscordClient;
 use App\Http\SlackClient;
 use Cake\ORM\Locator\LocatorAwareTrait;
 
@@ -17,8 +18,10 @@ abstract class AbstractEvent
     public const TYPE_APP_MENTION = 'app_mention';
     public const TYPE_SLASH_COMMAND = 'slash_command';
     public const TYPE_INTERACTIONS_CALLBACK = 'interaction_callback';
+    public const TYPE_LINK_SHARED = 'link_shared';
 
     protected SlackClient $slackClient;
+    protected DiscordClient $discordClient;
 
     public string $type;
     public string $eventTimestamp;
@@ -29,6 +32,7 @@ abstract class AbstractEvent
     public function __construct()
     {
         $this->slackClient = new SlackClient();
+        $this->discordClient = new DiscordClient();
     }
 
     /**

src/Event/EventFactory.php

@@ -28,23 +28,16 @@
             SentrySdk::getCurrentHub()->getTransaction()->getName() . ' - ' . $eventType
         );
 
-        switch ($eventType) {
-            case AbstractEvent::TYPE_MESSAGE:
-                return new MessageEvent($data);
-            case AbstractEvent::TYPE_DIRECT_MESSAGE:
-                return new DirectMessageEvent($data);
-            case AbstractEvent::TYPE_REACTION_ADDED:
-                return new ReactionAddedEvent($data);
-            case AbstractEvent::TYPE_APP_MENTION:
-                return new AppMentionEvent($data);
-            case AbstractEvent::TYPE_APP_HOME_OPENED:
-                return new AppHomeOpenedEvent($data);
-            case AbstractEvent::TYPE_SLASH_COMMAND:
-                return new SlashCommandEvent($data);
-            case AbstractEvent::TYPE_INTERACTIONS_CALLBACK:
-                return new InteractionsCallbackEvent($data);
-            default:
-                throw new Exception('Unknown event type');
-        }
+        return match ($eventType) {
+            AbstractEvent::TYPE_MESSAGE => new MessageEvent($data),
+            AbstractEvent::TYPE_DIRECT_MESSAGE => new DirectMessageEvent($data),
+            AbstractEvent::TYPE_REACTION_ADDED => new ReactionAddedEvent($data),
+            AbstractEvent::TYPE_APP_MENTION => new AppMentionEvent($data),
+            AbstractEvent::TYPE_APP_HOME_OPENED => new AppHomeOpenedEvent($data),
+            AbstractEvent::TYPE_SLASH_COMMAND => new SlashCommandEvent($data),
+            AbstractEvent::TYPE_INTERACTIONS_CALLBACK => new InteractionsCallbackEvent($data),
+            AbstractEvent::TYPE_LINK_SHARED => new LinkSharedEvent($data),
+            default => throw new Exception('Unknown event type'),
+        };
     }
 }

src/Event/LinkSharedEvent.php

@@ -0,0 +1,82 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Event;
+
+class LinkSharedEvent extends AbstractEvent
+{
+    public string $user;
+    public string $timestamp;
+    public string $channel;
+    public string $messageTimeStamp;
+    public string $threadTimeStamp;
+    public array $links;
+    public string $eventTimestamp;
+
+    /**
+     * Constructor
+     *
+     * @param array $event Event data.
+     */
+    public function __construct(array $event)
+    {
+        parent::__construct();
+
+        $this->type = self::TYPE_LINK_SHARED;
+        $this->user = $event['user'];
+        $this->timestamp = $event['ts'];
+        $this->channel = $event['channel'];
+        $this->messageTimeStamp = $event['message_ts'];
+        $this->threadTimeStamp = $event['thread_ts'];
+        $this->eventTimestamp = $event['event_ts'];
+        $this->links = $event['links'];
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function process(): void
+    {
+        foreach ($this->links as $link) {
+            $message = $this->fetchDiscordMessage($link['url']);
+            if ($message !== null) {
+                $this->slackClient->unfurl(
+                    channel: $this->channel,
+                    timestamp: $this->messageTimeStamp,
+                    unfurls: [
+                        $link['url'] => [
+                            'blocks' => [
+                                [
+                                    'type' => 'section',
+                                    'text' => [
+                                        'type' => 'mrkdwn',
+                                        'text' => $message,
+                                    ],
+                                ],
+                            ],
+                        ],
+                    ],
+                );
+            }
+        }
+    }
+
+    /**
+     * @param string $url The Discord message URL
+     * @return string|null The message content
+     */
+    private function fetchDiscordMessage(string $url): ?string
+    {
+        if (!preg_match('#^https://discord\.com/channels/\d+/\d+/\d+$#', $url)) {
+            return null;
+        }
+
+        $parts = explode('/', $url);
+        $channelId = $parts[5];
+        $messageId = $parts[6];
+
+        $message = $this->discordClient->getMessage($channelId, $messageId);
+
+        return $message;
+    }
+}

src/Http/DiscordClient.php

@@ -0,0 +1,58 @@
+<?php
+declare(strict_types=1);
+
+namespace App\Http;
+
+use function Cake\Core\env;
+use function Sentry\captureMessage;
+use function Sentry\withScope;
+
+class DiscordClient
+{
+    protected const DISCORD_API_URL = 'discord.com/api/v10';
+
+    protected Client $client;
+
+    /**
+     * Constructor.
+     */
+    public function __construct()
+    {
+        $this->client = new Client([
+            'host' => self::DISCORD_API_URL,
+            'scheme' => 'https',
+            'headers' => [
+                'Authorization' => 'Bot ' . env('DISCORD_BOT_TOKEN'),
+                'Content-Type' => 'application/json',
+            ],
+        ]);
+    }
+
+    /**
+     * @param string $channelId The channel ID
+     * @param string $messageId The message ID
+     * @return string|null The message content
+     * @see https://discord.com/developers/docs/resources/message#get-channel-message
+     */
+    public function getMessage(string $channelId, string $messageId): ?string
+    {
+        $response = $this->client->get("channels/{$channelId}/messages/{$messageId}");
+
+        if ($response->isSuccess()) {
+            $json = $response->getJson();
+
+            return $json['content'] ?? null;
+        }
+
+        withScope(function ($scope) use ($response, $channelId, $messageId): void {
+            $scope->setContext('Discord API', [
+                'channel_id' => $channelId,
+                'message_id' => $messageId,
+                'discord_response' => $response->getJson(),
+            ]);
+            captureMessage('Discord API error: Failed to fetch message');
+        });
+
+        return null;
+    }
+}