Skip to content

The only tool you need to know what is happening and how to fix it.

progress w custom sourcemap resolver

ddux12893380292e
diff --git a/.gitignore b/.gitignore
index 9c06b91a..87573e29 100644
--- a/.gitignore
+++ b/.gitignore
@@ -38,3 +38,4 @@ backend/static/dist/
/testing/devtesting-nestjs/node_modules
/testing/devtesting-nestjs/dist
/backend/storage/recordings
+/backend/storage
diff --git a/backend/app/cache/project_cache.go b/backend/app/cache/project_cache.go
index 9f2b79c3..1abbd5fe 100644
--- a/backend/app/cache/project_cache.go
+++ b/backend/app/cache/project_cache.go
@@ -14,15 +14,17 @@ import (
)
type projectCache struct {
- projects map[string]*models.Project // key: token
- projectsById map[uuid.UUID]*models.Project // key: id
- mu sync.RWMutex
- lastRefresh time.Time
+ projects map[string]*models.Project // key: token
+ projectsById map[uuid.UUID]*models.Project // key: id
+ projectsBySourceMapToken map[string]*models.Project // key: source_map_token
+ mu sync.RWMutex
+ lastRefresh time.Time
}
var ProjectCache = &projectCache{
- projects: make(map[string]*models.Project),
- projectsById: make(map[uuid.UUID]*models.Project),
+ projects: make(map[string]*models.Project),
+ projectsById: make(map[uuid.UUID]*models.Project),
+ projectsBySourceMapToken: make(map[string]*models.Project),
}
func (c *projectCache) Init(ctx context.Context) error {
@@ -42,11 +44,15 @@ func (c *projectCache) Refresh(ctx context.Context) error {
c.projects = make(map[string]*models.Project)
c.projectsById = make(map[uuid.UUID]*models.Project)
+ c.projectsBySourceMapToken = make(map[string]*models.Project)
for i := range projects {
proj := projects[i]
c.projects[proj.Token] = proj
c.projectsById[proj.Id] = proj
+ if proj.SourceMapToken != nil {
+ c.projectsBySourceMapToken[*proj.SourceMapToken] = proj
+ }
}
c.lastRefresh = time.Now()
@@ -86,6 +92,29 @@ func (c *projectCache) AddProject(proj *models.Project) {
defer c.mu.Unlock()
c.projects[proj.Token] = proj
c.projectsById[proj.Id] = proj
+ if proj.SourceMapToken != nil {
+ c.projectsBySourceMapToken[*proj.SourceMapToken] = proj
+ }
+}
+
+func (c *projectCache) GetBySourceMapToken(token string) *models.Project {
+ c.mu.RLock()
+ defer c.mu.RUnlock()
+ return c.projectsBySourceMapToken[token]
+}
+
+func (c *projectCache) UpdateSourceMapToken(projectId uuid.UUID, token string) {
+ c.mu.Lock()
+ defer c.mu.Unlock()
+ proj, ok := c.projectsById[projectId]
+ if !ok {
+ return
+ }
+ if proj.SourceMapToken != nil {
+ delete(c.projectsBySourceMapToken, *proj.SourceMapToken)
+ }
+ proj.SourceMapToken = &token
+ c.projectsBySourceMapToken[token] = proj
}
func (c *projectCache) LastRefresh() time.Time {
diff --git a/backend/app/cache/sourcemap_cache.go b/backend/app/cache/sourcemap_cache.go
new file mode 100644
index 00000000..2ef1bd56
--- /dev/null
+++ b/backend/app/cache/sourcemap_cache.go
@@ -0,0 +1,71 @@
+package cache
+
+import (
+ "container/list"
+ "sync"
+)
+
+type sourceMapCacheEntry struct {
+ key string
+ data []byte
+}
+
+type sourceMapCache struct {
+ maxCount int
+ maxBytes int64
+ mu sync.Mutex
+ items map[string]*list.Element
+ order *list.List
+ curBytes int64
+}
+
+var SourceMapCache *sourceMapCache
+
+func InitSourceMapCache(maxCount int, maxBytes int64) {
+ SourceMapCache = &sourceMapCache{
+ maxCount: maxCount,
+ maxBytes: maxBytes,
+ items: make(map[string]*list.Element),
+ order: list.New(),
+ }
+}
+
+func (c *sourceMapCache) Get(key string) ([]byte, bool) {
+ c.mu.Lock()
+ defer c.mu.Unlock()
+
+ if el, ok := c.items[key]; ok {
+ c.order.MoveToFront(el)
+ return el.Value.(*sourceMapCacheEntry).data, true
+ }
+ return nil, false
+}
+
+func (c *sourceMapCache) Put(key string, data []byte) {
+ c.mu.Lock()
+ defer c.mu.Unlock()
+
+ dataSize := int64(len(data))
+
+ if el, ok := c.items[key]; ok {
+ c.curBytes -= int64(len(el.Value.(*sourceMapCacheEntry).data))
+ el.Value.(*sourceMapCacheEntry).data = data
+ c.curBytes += dataSize
+ c.order.MoveToFront(el)
+ } else {
+ entry := &sourceMapCacheEntry{key: key, data: data}
+ el := c.order.PushFront(entry)
+ c.items[key] = el
+ c.curBytes += dataSize
+ }
+
+ for c.order.Len() > c.maxCount || c.curBytes > c.maxBytes {
+ back := c.order.Back()
+ if back == nil {
+ break
+ }
+ evicted := c.order.Remove(back).(*sourceMapCacheEntry)
+ delete(c.items, evicted.key)
+ c.curBytes -= int64(len(evicted.data))
+ }
+}
diff --git a/backend/app/controllers/clientcontrollers/client.controller.go b/backend/app/controllers/clientcontrollers/client.controller.go
index bd061005..64836768 100644
--- a/backend/app/controllers/clientcontrollers/client.controller.go
+++ b/backend/app/controllers/clientcontrollers/client.controller.go
@@ -6,6 +6,7 @@ import (
"backend/app/models"
"backend/app/models/clientmodels"
"backend/app/repositories"
+ "backend/app/services"
"backend/app/storage"
"context"
"crypto/sha256"
@@ -89,7 +90,14 @@ func (e clientController) Report(c *gin.Context) {
}
for _, cst := range cf.StackTraces {
- est := cst.ToExceptionStackTrace(computeExceptionHash(cst.StackTrace, cst.IsMessage), request.AppVersion, request.ServerName)
+ resolvedStackTrace := cst.StackTrace
+ if project, exists := c.Get(middleware.ProjectContextKey); exists {
+ if p, ok := project.(*models.Project); ok && isJsFramework(p.Framework) {
+ resolvedStackTrace = services.ResolveStackTrace(c, projectId, request.AppVersion, cst.StackTrace)
+ }
+ }
+ est := cst.ToExceptionStackTrace(computeExceptionHash(resolvedStackTrace, cst.IsMessage), request.AppVersion, request.ServerName)
+ est.StackTrace = resolvedStackTrace
est.Id = uuid.New()
est.ProjectId = projectId
if cst.SessionRecordingId != nil {
@@ -233,4 +241,18 @@ func computeExceptionHash(stackTrace string, isMessage bool) string {
return hex.EncodeToString(hash[:])[:16]
}
+var jsFrameworks = map[string]bool{
+ "react": true,
+ "svelte": true,
+ "vuejs": true,
+ "nextjs": true,
+ "nestjs": true,
+ "express": true,
+ "remix": true,
+}
+
+func isJsFramework(framework string) bool {
+ return jsFrameworks[framework]
+}
+
var ClientController = clientController{}
diff --git a/backend/app/controllers/project.controller.go b/backend/app/controllers/project.controller.go
index f9eb0044..8db037de 100644
--- a/backend/app/controllers/project.controller.go
+++ b/backend/app/controllers/project.controller.go
@@ -110,4 +110,24 @@ func (p projectController) CreateProject(c *gin.Context) {
c.JSON(http.StatusCreated, project.ToProjectWithBackendUrl())
}
+func (p projectController) GenerateSourceMapToken(c *gin.Context) {
+ projectId, err := middleware.GetProjectId(c)
+ if err != nil {
+ c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("RequireProjectAccess middleware must be applied: %w", err))
+ return
+ }
+
+ token, err := pgdb.ExecuteTransaction(func(tx *sql.Tx) (string, error) {
+ return repositories.ProjectRepository.GenerateSourceMapToken(tx, projectId)
+ })
+ if err != nil {
+ c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to generate source map token: %w", err))
+ return
+ }
+
+ cache.ProjectCache.UpdateSourceMapToken(projectId, token)
+
+ c.JSON(http.StatusOK, gin.H{"sourceMapToken": token})
+}
+
var ProjectController = projectController{}
diff --git a/backend/app/controllers/routes.go b/backend/app/controllers/routes.go
index bfceaf5d..c97141da 100644
--- a/backend/app/controllers/routes.go
+++ b/backend/app/controllers/routes.go
@@ -99,6 +99,10 @@ func RegisterControllers(router *gin.RouterGroup) {
router.POST("/invitations/:token/accept", middleware.Transactional, InvitationController.AcceptInvitation)
router.POST("/invitations/:token/accept-existing", middleware.UseAppAuth, middleware.Transactional, InvitationController.AcceptExistingUser)
+ // Source map management
+ router.POST("/projects/source-map-token", middleware.UseAppAuth, middleware.RequireProjectAccess, middleware.RequireWriteAccess, ProjectController.GenerateSourceMapToken)
+ router.POST("/sourcemaps/upload", middleware.UseSourceMapAuth, SourceMapController.Upload)
+
for _, register := range ExtensionRoutes {
register(router)
}
diff --git a/backend/app/controllers/sourcemap.controller.go b/backend/app/controllers/sourcemap.controller.go
new file mode 100644
index 00000000..0c7a2eea
--- /dev/null
+++ b/backend/app/controllers/sourcemap.controller.go
@@ -0,0 +1,107 @@
+package controllers
+
+import (
+ "backend/app/middleware"
+ "backend/app/models"
+ "backend/app/pgdb"
+ "backend/app/repositories"
+ "backend/app/storage"
+ "database/sql"
+ "fmt"
+ "io"
+ "net/http"
+ "strings"
+ "time"
+
+ "github.com/gin-gonic/gin"
+ traceway "go.tracewayapp.com"
+)
+
+type sourceMapController struct{}
+
+func (s sourceMapController) Upload(c *gin.Context) {
+ projectId, err := middleware.GetProjectId(c)
+ if err != nil {
+ c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("UseSourceMapAuth middleware must be applied: %w", err))
+ return
+ }
+
+ if err := c.Request.ParseMultipartForm(50 << 20); err != nil {
+ c.JSON(http.StatusBadRequest, gin.H{"error": "Failed to parse multipart form"})
+ return
+ }
+
+ version := c.Request.FormValue("version")
+ if version == "" {
+ c.JSON(http.StatusBadRequest, gin.H{"error": "version is required"})
+ return
+ }
+
+ files := c.Request.MultipartForm.File["files"]
+ if len(files) == 0 {
+ c.JSON(http.StatusBadRequest, gin.H{"error": "No files uploaded"})
+ return
+ }
+
+ uploaded := 0
+ for _, fileHeader := range files {
+ if !strings.HasSuffix(fileHeader.Filename, ".map") {
+ continue
+ }
+
+ if fileHeader.Size > 50<<20 {
+ c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("File %s exceeds 50MB limit", fileHeader.Filename)})
+ return
+ }
+
+ f, err := fileHeader.Open()
+ if err != nil {
+ c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to open uploaded file %s: %w", fileHeader.Filename, err))
+ return
+ }
+
+ data, err := io.ReadAll(f)
+ f.Close()
+ if err != nil {
+ c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to read uploaded file %s: %w", fileHeader.Filename, err))
+ return
+ }
+
+ storageKey := fmt.Sprintf("sourcemaps/%s/%s/%s", projectId, version, fileHeader.Filename)
+
+ if err := storage.Store.Write(c, storageKey, data); err != nil {
+ c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to write source map to storage: %w", err))
+ return
+ }
+
+ _, err = pgdb.ExecuteTransaction(func(tx *sql.Tx) (*models.SourceMap, error) {
+ existing, err := repositories.SourceMapRepository.FindByProjectVersionAndFileName(tx, projectId, version, fileHeader.Filename)
+ if err != nil {
+ return nil, err
+ }
+ if existing != nil {
+ existing.StorageKey = storageKey
+ existing.FileSize = fileHeader.Size
+ existing.UploadedAt = time.Now().UTC()
+ return existing, repositories.SourceMapRepository.Update(tx, existing)
+ }
+ return repositories.SourceMapRepository.Create(tx, &models.SourceMap{
+ ProjectId: projectId,
+ Version: version,
+ FileName: fileHeader.Filename,
+ StorageKey: storageKey,
+ FileSize: fileHeader.Size,
+ })
+ })
+ if err != nil {
+ c.AbortWithError(http.StatusInternalServerError, traceway.NewStackTraceErrorf("failed to upsert source map metadata: %w", err))
+ return
+ }
+
+ uploaded++
+ }
+
+ c.JSON(http.StatusOK, gin.H{"uploaded": uploaded})
+}
+
+var SourceMapController = sourceMapController{}
diff --git a/backend/app/middleware/use_source_map_auth.middleware.go b/backend/app/middleware/use_source_map_auth.middleware.go
new file mode 100644
index 00000000..e9ced511
--- /dev/null
+++ b/backend/app/middleware/use_source_map_auth.middleware.go
@@ -0,0 +1,35 @@
+package middleware
+
+import (
+ "backend/app/cache"
+ "net/http"
+ "strings"
+
+ "github.com/gin-gonic/gin"
+)
+
+var UseSourceMapAuth func(c *gin.Context)
+
+func InitUseSourceMapAuth() {
+ UseSourceMapAuth = func(c *gin.Context) {
+ authHeader := c.GetHeader("Authorization")
+
+ if !strings.HasPrefix(authHeader, "Bearer ") {
+ c.AbortWithStatus(http.StatusUnauthorized)
+ return
+ }
+
+ token := strings.TrimPrefix(authHeader, "Bearer ")
+
+ project := cache.ProjectCache.GetBySourceMapToken(token)
+ if project == nil {
+ c.AbortWithStatus(http.StatusUnauthorized)
+ return
+ }
+
+ c.Set(ProjectContextKey, project)
+ c.Set(ProjectIdContextKey, project.Id)
+
+ c.Next()
+ }
+}
diff --git a/backend/app/migrations/pg/0013_add_source_map_token_to_projects.up.sql b/backend/app/migrations/pg/0013_add_source_map_token_to_projects.up.sql
new file mode 100644
index 00000000..59a9a417
--- /dev/null
+++ b/backend/app/migrations/pg/0013_add_source_map_token_to_projects.up.sql
@@ -0,0 +1 @@
+ALTER TABLE projects ADD COLUMN source_map_token VARCHAR(64)
diff --git a/backend/app/migrations/pg/0014_create_source_maps_table.up.sql b/backend/app/migrations/pg/0014_create_source_maps_table.up.sql
new file mode 100644
index 00000000..6c017201
--- /dev/null
+++ b/backend/app/migrations/pg/0014_create_source_maps_table.up.sql
@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS source_maps (
+ id SERIAL PRIMARY KEY,
+ project_id UUID NOT NULL REFERENCES projects(id),
+ version VARCHAR(255) NOT NULL,
+ file_name VARCHAR(500) NOT NULL,
+ storage_key VARCHAR(1000) NOT NULL,
+ file_size BIGINT NOT NULL,
+ uploaded_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
+ UNIQUE(project_id, version, file_name)
+)
diff --git a/backend/app/migrations/pg/0015_create_source_maps_project_version_index.up.sql b/backend/app/migrations/pg/0015_create_source_maps_project_version_index.up.sql
new file mode 100644
index 00000000..f8ce5699
--- /dev/null
+++ b/backend/app/migrations/pg/0015_create_source_maps_project_version_index.up.sql
@@ -0,0 +1 @@
+CREATE INDEX idx_source_maps_project_version ON source_maps(project_id, version)
diff --git a/backend/app/models/models.go b/backend/app/models/models.go
index 376e44d3..002893e0 100644
--- a/backend/app/models/models.go
+++ b/backend/app/models/models.go
@@ -16,6 +16,7 @@ func Init() {
lit.RegisterModel[InvitationWithInviter](lit.PostgreSQL)
lit.RegisterModel[UserOrganizationResponse](lit.PostgreSQL)
lit.RegisterModel[CountResult](lit.PostgreSQL)
+ lit.RegisterModel[SourceMap](lit.PostgreSQL)
for _, register := range ExtensionModelRegistrations {
register()
diff --git a/backend/app/models/project.model.go b/backend/app/models/project.model.go
index 32950f0f..2e6275eb 100644
--- a/backend/app/models/project.model.go
+++ b/backend/app/models/project.model.go
@@ -14,6 +14,7 @@ type Project struct {
Framework string `json:"framework"`
OrganizationId *int `json:"organizationId"`
CreatedAt time.Time `json:"createdAt"`
+ SourceMapToken *string `json:"sourceMapToken,omitempty"`
}
func (p Project) ToProjectWithBackendUrl() *ProjectWithBackendUrl {
diff --git a/backend/app/models/source_map.model.go b/backend/app/models/source_map.model.go
new file mode 100644
index 00000000..6f13345f
--- /dev/null
+++ b/backend/app/models/source_map.model.go
@@ -0,0 +1,17 @@
+package models
+
+import (
+ "time"
+
+ "github.com/google/uuid"
+)
+
+type SourceMap struct {
+ Id int `json:"id"`
+ ProjectId uuid.UUID `json:"projectId"`
+ Version string `json:"version"`
+ FileName string `json:"fileName"`
+ StorageKey string `json:"storageKey"`
+ FileSize int64 `json:"fileSize"`
+ UploadedAt time.Time `json:"uploadedAt"`
+}
diff --git a/backend/app/repositories/project.repository.go b/backend/app/repositories/project.repository.go
index 1462efb4..eb8a3320 100644
--- a/backend/app/repositories/project.repository.go
+++ b/backend/app/repositories/project.repository.go
@@ -3,6 +3,7 @@ package repositories
import (
"backend/app/models"
"database/sql"
+ "fmt"
"strings"
"time"
@@ -19,6 +20,7 @@ type projectWithRole struct {
Framework string `lit:"framework"`
OrganizationId *int `lit:"organization_id"`
CreatedAt time.Time `lit:"created_at"`
+ SourceMapToken *string `lit:"source_map_token"`
Role string `lit:"role"`
}
@@ -29,7 +31,7 @@ func init() {
func (p *projectRepository) FindAllWithBackendUrlByUserId(tx *sql.Tx, userId int) ([]*models.ProjectWithBackendUrl, error) {
rows, err := lit.Select[projectWithRole](
tx,
- `SELECT DISTINCT p.id, p.name, p.token, p.framework, p.organization_id, p.created_at, ou.role
+ `SELECT DISTINCT p.id, p.name, p.token, p.framework, p.organization_id, p.created_at, p.source_map_token, ou.role
FROM projects p
INNER JOIN organization_users ou ON p.organization_id = ou.organization_id
WHERE ou.user_id = $1
@@ -43,8 +45,10 @@ func (p *projectRepository) FindAllWithBackendUrlByUserId(tx *sql.Tx, userId int
result := make([]*models.ProjectWithBackendUrl, 0, len(rows))
for _, row := range rows {
token := row.Token
+ sourceMapToken := row.SourceMapToken
if row.Role == "readonly" {
token = "read-only-hidden-token"
+ sourceMapToken = nil
}
project := models.Project{
@@ -54,6 +58,7 @@ func (p *projectRepository) FindAllWithBackendUrlByUserId(tx *sql.Tx, userId int
Framework: row.Framework,
OrganizationId: row.OrganizationId,
CreatedAt: row.CreatedAt,
+ SourceMapToken: sourceMapToken,
}
result = append(result, project.ToProjectWithBackendUrl())
}
@@ -64,14 +69,14 @@ func (p *projectRepository) FindAllWithBackendUrlByUserId(tx *sql.Tx, userId int
func (p *projectRepository) FindAll(tx *sql.Tx) ([]*models.Project, error) {
return lit.Select[models.Project](
tx,
- "SELECT id, name, token, framework, organization_id, created_at FROM projects ORDER BY created_at ASC",
+ "SELECT id, name, token, framework, organization_id, created_at, source_map_token FROM projects ORDER BY created_at ASC",
)
}
func (p *projectRepository) FindByToken(tx *sql.Tx, token string) (*models.Project, error) {
return lit.SelectSingle[models.Project](
tx,
- "SELECT id, name, token, framework, organization_id, created_at FROM projects WHERE token = $1",
+ "SELECT id, name, token, framework, organization_id, created_at, source_map_token FROM projects WHERE token = $1",
token,
)
}
@@ -79,7 +84,7 @@ func (p *projectRepository) FindByToken(tx *sql.Tx, token string) (*models.Proje
func (p *projectRepository) FindById(tx *sql.Tx, id uuid.UUID) (*models.Project, error) {
return lit.SelectSingle[models.Project](
tx,
- "SELECT id, name, token, framework, organization_id, created_at FROM projects WHERE id = $1",
+ "SELECT id, name, token, framework, organization_id, created_at, source_map_token FROM projects WHERE id = $1",
id,
)
}
@@ -122,7 +127,7 @@ func (p *projectRepository) CreateWithOrganization(tx *sql.Tx, name string, fram
func (p *projectRepository) FindByOrganizationId(tx *sql.Tx, organizationId int) ([]*models.Project, error) {
return lit.Select[models.Project](
tx,
- "SELECT id, name, token, framework, organization_id, created_at FROM projects WHERE organization_id = $1 ORDER BY created_at ASC",
+ "SELECT id, name, token, framework, organization_id, created_at, source_map_token FROM projects WHERE organization_id = $1 ORDER BY created_at ASC",
organizationId,
)
}
@@ -131,7 +136,7 @@ func (p *projectRepository) FindByOrganizationId(tx *sql.Tx, organizationId int)
func (p *projectRepository) FindByUserId(tx *sql.Tx, userId int) ([]*models.Project, error) {
return lit.Select[models.Project](
tx,
- `SELECT DISTINCT p.id, p.name, p.token, p.framework, p.organization_id, p.created_at
+ `SELECT DISTINCT p.id, p.name, p.token, p.framework, p.organization_id, p.created_at, p.source_map_token
FROM projects p
INNER JOIN organization_users ou ON p.organization_id = ou.organization_id
WHERE ou.user_id = $1
@@ -159,6 +164,32 @@ func (p *projectRepository) UserHasAccess(tx *sql.Tx, projectId uuid.UUID, userI
return result.Count > 0, nil
}
+func (p *projectRepository) GenerateSourceMapToken(tx *sql.Tx, projectId uuid.UUID) (string, error) {
+ project, err := p.FindById(tx, projectId)
+ if err != nil {
+ return "", err
+ }
+ if project == nil {
+ return "", fmt.Errorf("project not found: %s", projectId)
+ }
+
+ token := generateSecureToken()
+ project.SourceMapToken = &token
+ err = lit.Update[models.Project](tx, project, "id = $1", projectId)
+ if err != nil {
+ return "", err
+ }
+ return token, nil
+}
+
+func (p *projectRepository) FindBySourceMapToken(tx *sql.Tx, token string) (*models.Project, error) {
+ return lit.SelectSingle[models.Project](
+ tx,
+ "SELECT id, name, token, framework, organization_id, created_at, source_map_token FROM projects WHERE source_map_token = $1",
+ token,
+ )
+}
+
func generateSecureToken() string {
id := uuid.New()
return strings.ReplaceAll(id.String(), "-", "")
diff --git a/backend/app/repositories/source_map.repository.go b/backend/app/repositories/source_map.repository.go
new file mode 100644
index 00000000..e33203b3
--- /dev/null
+++ b/backend/app/repositories/source_map.repository.go
@@ -0,0 +1,55 @@
+package repositories
+
+import (
+ "backend/app/models"
+ "database/sql"
+ "time"
+
+ "github.com/google/uuid"
+ "github.com/tracewayapp/go-lightning/lit"
+)
+
+type sourceMapRepository struct{}
+
+func (s *sourceMapRepository) Create(tx *sql.Tx, sm *models.SourceMap) (*models.SourceMap, error) {
+ sm.UploadedAt = time.Now().UTC()
+ id, err := lit.Insert(tx, sm)
+ if err != nil {
+ return nil, err
+ }
+ sm.Id = id
+ return sm, nil
+}
+
+func (s *sourceMapRepository) Update(tx *sql.Tx, sm *models.SourceMap) error {
+ return lit.Update[models.SourceMap](tx, sm, "id = $1", sm.Id)
+}
+
+func (s *sourceMapRepository) FindByProjectAndVersion(tx *sql.Tx, projectId uuid.UUID, version string) ([]*models.SourceMap, error) {
+ return lit.Select[models.SourceMap](
+ tx,
+ "SELECT * FROM source_maps WHERE project_id = $1 AND version = $2",
+ projectId,
+ version,
+ )
+}
+
+func (s *sourceMapRepository) FindLatestByProject(tx *sql.Tx, projectId uuid.UUID) ([]*models.SourceMap, error) {
+ return lit.Select[models.SourceMap](
+ tx,
+ "SELECT * FROM source_maps WHERE project_id = $1 AND version = (SELECT version FROM source_maps WHERE project_id = $1 ORDER BY uploaded_at DESC LIMIT 1)",
+ projectId,
+ )
+}
+
+func (s *sourceMapRepository) FindByProjectVersionAndFileName(tx *sql.Tx, projectId uuid.UUID, version, fileName string) (*models.SourceMap, error) {
+ return lit.SelectSingle[models.SourceMap](
+ tx,
+ "SELECT * FROM source_maps WHERE project_id = $1 AND version = $2 AND file_name = $3",
+ projectId,
+ version,
+ fileName,
+ )
+}
+
+var SourceMapRepository = sourceMapRepository{}
diff --git a/backend/app/services/sourcemap_resolver.go b/backend/app/services/sourcemap_resolver.go
new file mode 100644
index 00000000..e726e59b
--- /dev/null
+++ b/backend/app/services/sourcemap_resolver.go
@@ -0,0 +1,168 @@
+package services
+
+import (
+ "backend/app/cache"
+ "backend/app/models"
+ "backend/app/pgdb"
+ "backend/app/repositories"
+ "backend/app/storage"
+ "context"
+ "database/sql"
+ "fmt"
+ "path/filepath"
+ "regexp"
+ "strconv"
+ "strings"
+
+ "github.com/go-sourcemap/sourcemap"
+ "github.com/google/uuid"
+ traceway "go.tracewayapp.com"
+)
+
+var stackFrameRe = regexp.MustCompile(`^(\s{4})(.+):(\d+):(\d+)$`)
+var jsFuncDeclRe = regexp.MustCompile(`(?:function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=|^\s*(?:async\s+)?(\w+)\s*\()`)
+
+func ResolveStackTrace(ctx context.Context, projectId uuid.UUID, appVersion string, stackTrace string) string {
+ sourceMaps, err := pgdb.ExecuteTransaction(func(tx *sql.Tx) ([]*models.SourceMap, error) {
+ if appVersion != "" {
+ return repositories.SourceMapRepository.FindByProjectAndVersion(tx, projectId, appVersion)
+ }
+ return repositories.SourceMapRepository.FindLatestByProject(tx, projectId)
+ })
+ if err != nil || len(sourceMaps) == 0 {
+ return stackTrace
+ }
+
+ // Build lookup: basename of source map's file_name (without .map) -> source map
+ // Also keep a map of file_name -> storage_key for direct lookup
+ smByBasename := make(map[string]*models.SourceMap)
+ for _, sm := range sourceMaps {
+ smByBasename[sm.FileName] = sm
+ // Also index by basename
+ base := filepath.Base(sm.FileName)
+ smByBasename[base] = sm
+ }
+
+ lines := strings.Split(stackTrace, "\n")
+ resolved := make([]string, 0, len(lines))
+ framesResolved := 0
+ maxFrames := 50
+
+ for _, line := range lines {
+ if framesResolved >= maxFrames {
+ resolved = append(resolved, line)
+ continue
+ }
+
+ matches := stackFrameRe.FindStringSubmatch(line)
+ if matches == nil {
+ resolved = append(resolved, line)
+ continue
+ }
+
+ indent := matches[1]
+ fileName := matches[2]
+ lineNum, _ := strconv.Atoi(matches[3])
+ colNum, _ := strconv.Atoi(matches[4])
+
+ sm := findSourceMap(fileName, smByBasename)
+ if sm == nil {
+ resolved = append(resolved, line)
+ continue
+ }
+
+ data, err := getSourceMapData(ctx, sm.StorageKey)
+ if err != nil {
+ resolved = append(resolved, line)
+ continue
+ }
+
+ consumer, err := sourcemap.Parse("", data)
+ if err != nil {
+ resolved = append(resolved, line)
+ continue
+ }
+
+ origFile, origName, origLine, origCol, ok := consumer.Source(lineNum, colNum)
+ if !ok || origFile == "" {
+ resolved = append(resolved, line)
+ continue
+ }
+
+ if origName == "" {
+ if content := consumer.SourceContent(origFile); content != "" {
+ origName = extractFunctionName(content, origLine)
+ }
+ }
+
+ resolved = append(resolved, fmt.Sprintf("%s%s:%d:%d", indent, origFile, origLine, origCol))
+ framesResolved++
+
+ if origName != "" && len(resolved) >= 2 {
+ prev := resolved[len(resolved)-2]
+ if strings.HasSuffix(strings.TrimSpace(prev), "()") {
+ trimmed := strings.TrimSpace(prev)
+ indent := prev[:len(prev)-len(trimmed)]
+ resolved[len(resolved)-2] = indent + origName + "()"
+ }
+ }
+ }
+
+ return strings.Join(resolved, "\n")
+}
+
+func findSourceMap(stackFile string, smByBasename map[string]*models.SourceMap) *models.SourceMap {
+ // Try file.map directly
+ mapName := stackFile + ".map"
+ if sm, ok := smByBasename[mapName]; ok {
+ return sm
+ }
+
+ // Try basename.map
+ base := filepath.Base(stackFile) + ".map"
+ if sm, ok := smByBasename[base]; ok {
+ return sm
+ }
+
+ // Try without query params
+ cleanName := stackFile
+ if idx := strings.IndexAny(cleanName, "?#"); idx != -1 {
+ cleanName = cleanName[:idx]
+ }
+ mapName = filepath.Base(cleanName) + ".map"
+ if sm, ok := smByBasename[mapName]; ok {
+ return sm
+ }
+
+ return nil
+}
+
+func getSourceMapData(ctx context.Context, storageKey string) ([]byte, error) {
+ if data, ok := cache.SourceMapCache.Get(storageKey); ok {
+ return data, nil
+ }
+
+ data, err := storage.Store.Read(ctx, storageKey)
+ if err != nil {
+ traceway.CaptureException(fmt.Errorf("failed to read source map from storage (key=%s): %w", storageKey, err))
+ return nil, err
+ }
+
+ cache.SourceMapCache.Put(storageKey, data)
+ return data, nil
+}
+
+func extractFunctionName(sourceContent string, line int) string {
+ lines := strings.Split(sourceContent, "\n")
+ for i := line - 1; i >= 0 && i >= line-50; i-- {
+ matches := jsFuncDeclRe.FindStringSubmatch(lines[i])
+ if matches != nil {
+ for _, m := range matches[1:] {
+ if m != "" {
+ return m
+ }
+ }
+ }
+ }
+ return ""
+}
diff --git a/backend/cmd/run.go b/backend/cmd/run.go
index 74110fd8..b00ee383 100644
--- a/backend/cmd/run.go
+++ b/backend/cmd/run.go
@@ -60,12 +60,14 @@ func Run() {
if err := cache.ProjectCache.Init(ctx); err != nil {
panic(fmt.Errorf("projects cache could not be initialized: %w", err))
}
+ cache.InitSourceMapCache(200, 500*1024*1024)
middleware.InitUseClientAuth()
middleware.InitUseAppAuth()
middleware.InitRequireWriteAccess()
middleware.InitRequireProjectAccess()
middleware.InitRequireAdminAccess()
+ middleware.InitUseSourceMapAuth()
services.InitEmail()
diff --git a/backend/go.mod b/backend/go.mod
index 91fbb802..59688199 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -44,6 +44,7 @@ require (
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-playground/validator/v10 v10.27.0 // indirect
+ github.com/go-sourcemap/sourcemap v2.1.4+incompatible // indirect
github.com/goccy/go-json v0.10.2 // indirect
github.com/goccy/go-yaml v1.18.0 // indirect
github.com/json-iterator/go v1.1.12 // indirect
diff --git a/backend/go.sum b/backend/go.sum
index 6b6b1b6b..8794915e 100644
--- a/backend/go.sum
+++ b/backend/go.sum
@@ -105,6 +105,8 @@ github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJn
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.27.0 h1:w8+XrWVMhGkxOaaowyKH35gFydVHOvC0/uWoy2Fzwn4=
github.com/go-playground/validator/v10 v10.27.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo=
+github.com/go-sourcemap/sourcemap v2.1.4+incompatible h1:a+iTbH5auLKxaNwQFg0B+TCYl6lbukKPc7b5x0n1s6Q=
+github.com/go-sourcemap/sourcemap v2.1.4+incompatible/go.mod h1:F8jJfvm2KbVjc5NqelyYJmf/v5J0dwNLS2mL4sNA1Jg=
github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
diff --git a/frontend/src/lib/state/projects.svelte.ts b/frontend/src/lib/state/projects.svelte.ts
index fd1ed68b..1e3c66ee 100644
--- a/frontend/src/lib/state/projects.svelte.ts
+++ b/frontend/src/lib/state/projects.svelte.ts
@@ -41,6 +41,7 @@ export interface Project {
framework: Framework;
organizationId: number | null;
createdAt: string;
+ sourceMapToken: string | null;
backendUrl: string;
}
@@ -124,6 +125,14 @@ class ProjectsState {
return response;
}
+ async generateSourceMapToken(): Promise<string> {
+ const resp = await api.post('/projects/source-map-token', {}, {
+ projectId: this.currentProjectId ?? undefined
+ });
+ await this.loadProjects();
+ return resp.sourceMapToken;
+ }
+
selectProject(projectId: string) {
this.currentProjectId = projectId;
}
diff --git a/frontend/src/routes/connection/+page.svelte b/frontend/src/routes/connection/+page.svelte
index d4dd069f..bb06cb2c 100644
--- a/frontend/src/routes/connection/+page.svelte
+++ b/frontend/src/routes/connection/+page.svelte
@@ -7,7 +7,7 @@
CardTitle
} from '$lib/components/ui/card';
import { Button } from '$lib/components/ui/button';
- import { Copy, Check } from 'lucide-svelte';
+ import { Copy, Check, KeyRound } from 'lucide-svelte';
import { projectsState, type ProjectWithToken, isJsFramework } from '$lib/state/projects.svelte';
import { LoadingCircle } from '$lib/components/ui/loading-circle';
import FrameworkIcon from '$lib/components/framework-icon.svelte';
@@ -20,13 +20,15 @@
import {
getFrameworkCode,
getInstallCommand,
- getFrameworkLabel,
- getCodeLanguage
+ getFrameworkLabel
} from '$lib/utils/framework-code';
let projectWithToken = $derived(projectsState.currentProject);
let copiedCode = $state(false);
let copiedInstall = $state(false);
+ let copiedToken = $state(false);
+ let copiedCommand = $state(false);
+ let generatingToken = $state(false);
const sdkCode = $derived(
projectWithToken
@@ -47,6 +49,13 @@
);
const isJs = $derived(projectWithToken ? isJsFramework(projectWithToken.framework) : false);
+ const sourceMapToken = $derived(projectWithToken?.sourceMapToken ?? null);
+
+ const uploadCommand = $derived(
+ projectWithToken && sourceMapToken
+ ? `npx @tracewayapp/sourcemap-upload --url ${projectWithToken.backendUrl} --token ${sourceMapToken} --version YOUR_VERSION --directory dist/assets`
+ : ''
+ );
async function copyCode() {
await navigator.clipboard.writeText(sdkCode);
@@ -59,6 +68,28 @@
copiedInstall = true;
setTimeout(() => (copiedInstall = false), 2000);
}
+
+ async function generateToken() {
+ generatingToken = true;
+ try {
+ await projectsState.generateSourceMapToken();
+ } finally {
+ generatingToken = false;
+ }
+ }
+
+ async function copyToken() {
+ if (!sourceMapToken) return;
+ await navigator.clipboard.writeText(sourceMapToken);
+ copiedToken = true;
+ setTimeout(() => (copiedToken = false), 2000);
+ }
+
+ async function copyUploadCommand() {
+ await navigator.clipboard.writeText(uploadCommand);
+ copiedCommand = true;
+ setTimeout(() => (copiedCommand = false), 2000);
+ }
</script>
<div class="space-y-4">
@@ -132,6 +163,79 @@
</div>
</CardContent>
</Card>
+ {#if isJs}
+ <Card>
+ <CardHeader>
+ <CardTitle class="flex items-center gap-2">
+ <KeyRound class="h-5 w-5" />
+ Source Map Upload
+ </CardTitle>
+ <CardDescription>
+ Upload source maps to see original file names and line numbers in stack traces
+ from minified code.
+ </CardDescription>
+ </CardHeader>
+ <CardContent>
+ {#if sourceMapToken}
+ <div class="space-y-4">
+ <div>
+ <p class="text-sm font-medium mb-2">Upload Token</p>
+ <div class="flex items-center gap-2">
+ <code
+ class="flex-1 rounded-md bg-muted px-3 py-2 text-sm font-mono break-all"
+ >{sourceMapToken}</code
+ >
+ <Button variant="outline" size="sm" onclick={copyToken}>
+ {#if copiedToken}
+ <Check class="h-4 w-4 text-green-500" />
+ {:else}
+ <Copy class="h-4 w-4" />
+ {/if}
+ </Button>
+ </div>
+ </div>
+ <div>
+ <p class="text-sm font-medium mb-2">Usage</p>
+ <div class="relative">
+ <div class="absolute top-2 right-2 z-10">
+ <Button variant="outline" size="sm" onclick={copyUploadCommand}>
+ {#if copiedCommand}
+ <Check class="mr-2 h-4 w-4 text-green-500" />
+ Copied!
+ {:else}
+ <Copy class="mr-2 h-4 w-4" />
+ Copy
+ {/if}
+ </Button>
+ </div>
+ <div
+ class="overflow-x-auto rounded-lg text-sm {themeState.isDark
+ ? 'dark-code'
+ : 'light-code'}"
+ >
+ <Highlight language={bash} code={uploadCommand} />
+ </div>
+ </div>
+ </div>
+ </div>
+ {:else}
+ <p class="text-sm text-muted-foreground mb-4">
+ Generate an upload token to start uploading source maps as part of your build
+ process.
+ </p>
+ <Button onclick={generateToken} disabled={generatingToken}>
+ {#if generatingToken}
+ <LoadingCircle class="mr-2 h-4 w-4" />
+ Generating...
+ {:else}
+ <KeyRound class="mr-2 h-4 w-4" />
+ Generate Upload Token
+ {/if}
+ </Button>
+ {/if}
+ </CardContent>
+ </Card>
+ {/if}
{:else}
<Card>
<CardContent class="p-6 text-center">