Don't append strings for error logging

api/_apimeta/auth.go

@@ -21,7 +21,7 @@ func GetRequestUserAdminStatus(r *http.Request, rctx rcontext.RequestContext, us
 	isLocalAdmin, err := matrix.IsUserAdmin(rctx, r.Host, user.AccessToken, r.RemoteAddr)
 	if err != nil {
 		sentry.CaptureException(err)
-		rctx.Log.Error("Error verifying local admin: " + err.Error())
+		rctx.Log.Error("Error verifying local admin: ", err)
 		return isGlobalAdmin, false
 	}
 

api/custom/exports.go

@@ -99,7 +99,7 @@ func ExportServerData(r *http.Request, rctx rcontext.RequestContext, user _apime
 
 		isLocalAdmin, err := matrix.IsUserAdmin(rctx, serverName, user.AccessToken, r.RemoteAddr)
 		if err != nil {
-			rctx.Log.Error("Error verifying local admin: " + err.Error())
+			rctx.Log.Error("Error verifying local admin: ", err)
 			isLocalAdmin = false
 		}
 		if !isLocalAdmin {

api/custom/purge.go

@@ -41,7 +41,7 @@ func PurgeRemoteMedia(r *http.Request, rctx rcontext.RequestContext, user _apime
 	// We don't bother clearing the cache because it's still probably useful there
 	removed, err := maintenance_controller.PurgeRemoteMediaBefore(beforeTs, rctx)
 	if err != nil {
-		rctx.Log.Error("Error purging remote media: " + err.Error())
+		rctx.Log.Error("Error purging remote media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("Error purging remote media")
 	}
@@ -78,7 +78,7 @@ func PurgeIndividualRecord(r *http.Request, rctx rcontext.RequestContext, user _
 				return _responses.NotFoundError()
 			}
 			if err != nil {
-				rctx.Log.Error("Error checking ownership of media: " + err.Error())
+				rctx.Log.Error("Error checking ownership of media: ", err)
 				sentry.CaptureException(err)
 				return _responses.InternalServerError("error checking media ownership")
 			}
@@ -93,7 +93,7 @@ func PurgeIndividualRecord(r *http.Request, rctx rcontext.RequestContext, user _
 		return _responses.NotFoundError()
 	}
 	if err != nil {
-		rctx.Log.Error("Error purging media: " + err.Error())
+		rctx.Log.Error("Error purging media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("error purging media")
 	}
@@ -117,7 +117,7 @@ func PurgeQuarantined(r *http.Request, rctx rcontext.RequestContext, user _apime
 	}
 
 	if err != nil {
-		rctx.Log.Error("Error purging media: " + err.Error())
+		rctx.Log.Error("Error purging media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("error purging media")
 	}
@@ -158,7 +158,7 @@ func PurgeOldMedia(r *http.Request, rctx rcontext.RequestContext, user _apimeta.
 	affected, err := maintenance_controller.PurgeOldMedia(beforeTs, includeLocal, rctx)
 
 	if err != nil {
-		rctx.Log.Error("Error purging media: " + err.Error())
+		rctx.Log.Error("Error purging media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("error purging media")
 	}
@@ -196,7 +196,7 @@ func PurgeUserMedia(r *http.Request, rctx rcontext.RequestContext, user _apimeta
 
 	_, userDomain, err := util.SplitUserId(userId)
 	if err != nil {
-		rctx.Log.Error("Error parsing user ID (" + userId + "): " + err.Error())
+		rctx.Log.Error("Error parsing user ID ("+userId+"): ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("error parsing user ID")
 	}
@@ -208,7 +208,7 @@ func PurgeUserMedia(r *http.Request, rctx rcontext.RequestContext, user _apimeta
 	affected, err := maintenance_controller.PurgeUserMedia(userId, beforeTs, rctx)
 
 	if err != nil {
-		rctx.Log.Error("Error purging media: " + err.Error())
+		rctx.Log.Error("Error purging media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("error purging media")
 	}
@@ -246,7 +246,7 @@ func PurgeRoomMedia(r *http.Request, rctx rcontext.RequestContext, user _apimeta
 
 	allMedia, err := matrix.ListMedia(rctx, r.Host, user.AccessToken, roomId, r.RemoteAddr)
 	if err != nil {
-		rctx.Log.Error("Error while listing media in the room: " + err.Error())
+		rctx.Log.Error("Error while listing media in the room: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("error retrieving media in room")
 	}
@@ -286,7 +286,7 @@ func PurgeRoomMedia(r *http.Request, rctx rcontext.RequestContext, user _apimeta
 	affected, err := maintenance_controller.PurgeRoomMedia(mxcs, beforeTs, rctx)
 
 	if err != nil {
-		rctx.Log.Error("Error purging media: " + err.Error())
+		rctx.Log.Error("Error purging media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("error purging media")
 	}
@@ -333,7 +333,7 @@ func PurgeDomainMedia(r *http.Request, rctx rcontext.RequestContext, user _apime
 	affected, err := maintenance_controller.PurgeDomainMedia(serverName, beforeTs, rctx)
 
 	if err != nil {
-		rctx.Log.Error("Error purging media: " + err.Error())
+		rctx.Log.Error("Error purging media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("error purging media")
 	}

api/custom/quarantine.go

@@ -40,7 +40,7 @@ func QuarantineRoomMedia(r *http.Request, rctx rcontext.RequestContext, user _ap
 
 	allMedia, err := matrix.ListMedia(rctx, r.Host, user.AccessToken, roomId, r.RemoteAddr)
 	if err != nil {
-		rctx.Log.Error("Error while listing media in the room: " + err.Error())
+		rctx.Log.Error("Error while listing media in the room: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("error retrieving media in room")
 	}
@@ -53,7 +53,7 @@ func QuarantineRoomMedia(r *http.Request, rctx rcontext.RequestContext, user _ap
 	for _, mxc := range mxcs {
 		server, mediaId, err := util.SplitMxc(mxc)
 		if err != nil {
-			rctx.Log.Error("Error parsing MXC URI (" + mxc + "): " + err.Error())
+			rctx.Log.Error("Error parsing MXC URI ("+mxc+"): ", err)
 			sentry.CaptureException(err)
 			return _responses.InternalServerError("error parsing mxc uri")
 		}
@@ -89,7 +89,7 @@ func QuarantineUserMedia(r *http.Request, rctx rcontext.RequestContext, user _ap
 
 	_, userDomain, err := util.SplitUserId(userId)
 	if err != nil {
-		rctx.Log.Error("Error parsing user ID (" + userId + "): " + err.Error())
+		rctx.Log.Error("Error parsing user ID ("+userId+"): ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("error parsing user ID")
 	}
@@ -101,7 +101,7 @@ func QuarantineUserMedia(r *http.Request, rctx rcontext.RequestContext, user _ap
 	db := storage.GetDatabase().GetMediaStore(rctx)
 	userMedia, err := db.GetMediaByUser(userId)
 	if err != nil {
-		rctx.Log.Error("Error while listing media for the user: " + err.Error())
+		rctx.Log.Error("Error while listing media for the user: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("error retrieving media for user")
 	}
@@ -143,7 +143,7 @@ func QuarantineDomainMedia(r *http.Request, rctx rcontext.RequestContext, user _
 	db := storage.GetDatabase().GetMediaStore(rctx)
 	userMedia, err := db.GetAllMediaForServer(serverName)
 	if err != nil {
-		rctx.Log.Error("Error while listing media for the server: " + err.Error())
+		rctx.Log.Error("Error while listing media for the server: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("error retrieving media for server")
 	}
@@ -197,7 +197,7 @@ func doQuarantine(ctx rcontext.RequestContext, origin string, mediaId string, al
 			return &MediaQuarantinedResponse{0}, true
 		}
 
-		ctx.Log.Error("Error fetching media: " + err.Error())
+		ctx.Log.Error("Error fetching media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("error quarantining media"), false
 	}
@@ -210,7 +210,7 @@ func doQuarantineOn(media *types.Media, allowOtherHosts bool, ctx rcontext.Reque
 	attrDb := storage.GetDatabase().GetMediaAttributesStore(ctx)
 	attr, err := attrDb.GetAttributesDefaulted(media.Origin, media.MediaId)
 	if err != nil {
-		ctx.Log.Error("Error while getting attributes for media: " + err.Error())
+		ctx.Log.Error("Error while getting attributes for media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("Error quarantining media"), false
 	}
@@ -225,7 +225,7 @@ func doQuarantineOn(media *types.Media, allowOtherHosts bool, ctx rcontext.Reque
 
 	num, err := setMediaQuarantined(media, true, allowOtherHosts, ctx)
 	if err != nil {
-		ctx.Log.Error("Error quarantining media: " + err.Error())
+		ctx.Log.Error("Error quarantining media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("Error quarantining media"), false
 	}
@@ -271,7 +271,7 @@ func getQuarantineRequestInfo(r *http.Request, rctx rcontext.RequestContext, use
 			isLocalAdmin, err = matrix.IsUserAdmin(rctx, r.Host, user.AccessToken, r.RemoteAddr)
 			if err != nil {
 				sentry.CaptureException(err)
-				rctx.Log.Error("Error verifying local admin: " + err.Error())
+				rctx.Log.Error("Error verifying local admin: ", err)
 				canQuarantine = false
 				return canQuarantine, allowOtherHosts, isLocalAdmin
 			}

api/r0/download.go

@@ -83,7 +83,7 @@ func DownloadMedia(r *http.Request, rctx rcontext.RequestContext, user _apimeta.
 		} else if err == common.ErrMediaNotYetUploaded {
 			return _responses.NotYetUploaded()
 		}
-		rctx.Log.Error("Unexpected error locating media: " + err.Error())
+		rctx.Log.Error("Unexpected error locating media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("Unexpected Error")
 	}

api/r0/preview_url.go

@@ -44,7 +44,7 @@ func PreviewUrl(r *http.Request, rctx rcontext.RequestContext, user _apimeta.Use
 	if tsStr != "" {
 		ts, err = strconv.ParseInt(tsStr, 10, 64)
 		if err != nil {
-			rctx.Log.Error("Error parsing ts: " + err.Error())
+			rctx.Log.Error("Error parsing ts: ", err)
 			return _responses.BadRequest(err.Error())
 		}
 	}

api/r0/thumbnail.go

@@ -132,7 +132,7 @@ func ThumbnailMedia(r *http.Request, rctx rcontext.RequestContext, user _apimeta
 		} else if err == common.ErrMediaNotYetUploaded {
 			return _responses.NotYetUploaded()
 		}
-		rctx.Log.Error("Unexpected error locating media: " + err.Error())
+		rctx.Log.Error("Unexpected error locating media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("Unexpected Error")
 	}

api/r0/upload_async.go

@@ -68,14 +68,14 @@ func UploadMediaAsync(r *http.Request, rctx rcontext.RequestContext, user _apime
 				InternalCode: common.ErrCodeNotFound,
 			}
 		}
-		rctx.Log.Error("Unexpected error uploading media: " + err.Error())
+		rctx.Log.Error("Unexpected error uploading media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("Unexpected Error")
 	}
 
 	blurhash, err := database.GetInstance().Blurhashes.Prepare(rctx).Get(media.Sha256Hash)
 	if err != nil {
-		rctx.Log.Warn("Unexpected error getting media's blurhash from DB: " + err.Error())
+		rctx.Log.Warn("Unexpected error getting media's blurhash from DB: ", err)
 		sentry.CaptureException(err)
 	}
 

api/r0/upload_sync.go

@@ -45,14 +45,14 @@ func UploadMediaSync(r *http.Request, rctx rcontext.RequestContext, user _apimet
 		if err == common.ErrQuotaExceeded {
 			return _responses.QuotaExceeded()
 		}
-		rctx.Log.Error("Unexpected error uploading media: " + err.Error())
+		rctx.Log.Error("Unexpected error uploading media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("Unexpected Error")
 	}
 
 	blurhash, err := database.GetInstance().Blurhashes.Prepare(rctx).Get(media.Sha256Hash)
 	if err != nil {
-		rctx.Log.Warn("Unexpected error getting media's blurhash from DB: " + err.Error())
+		rctx.Log.Warn("Unexpected error getting media's blurhash from DB: ", err)
 		sentry.CaptureException(err)
 	}
 

api/unstable/info.go

@@ -88,15 +88,15 @@ func MediaInfo(r *http.Request, rctx rcontext.RequestContext, user _apimeta.User
 		} else if err == common.ErrMediaQuarantined {
 			return _responses.NotFoundError() // We lie for security
 		}
-		rctx.Log.Error("Unexpected error locating media: " + err.Error())
+		rctx.Log.Error("Unexpected error locating media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("Unexpected Error")
 	}
 	defer stream_util.DumpAndCloseStream(streamedMedia.Stream)
 
 	b, err := io.ReadAll(streamedMedia.Stream)
 	if err != nil {
-		rctx.Log.Error("Unexpected error processing media: " + err.Error())
+		rctx.Log.Error("Unexpected error processing media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("Unexpected Error")
 	}
@@ -119,7 +119,7 @@ func MediaInfo(r *http.Request, rctx rcontext.RequestContext, user _apimeta.User
 	thumbsDb := storage.GetDatabase().GetThumbnailStore(rctx)
 	thumbs, err := thumbsDb.GetAllForMedia(streamedMedia.KnownMedia.Origin, streamedMedia.KnownMedia.MediaId)
 	if err != nil && err != sql.ErrNoRows {
-		rctx.Log.Error("Unexpected error locating media: " + err.Error())
+		rctx.Log.Error("Unexpected error locating media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("Unexpected Error")
 	}

api/unstable/local_copy.go

@@ -59,7 +59,7 @@ func LocalCopy(r *http.Request, rctx rcontext.RequestContext, user _apimeta.User
 		} else if err == common.ErrMediaQuarantined {
 			return _responses.NotFoundError() // We lie for security
 		}
-		rctx.Log.Error("Unexpected error locating media: " + err.Error())
+		rctx.Log.Error("Unexpected error locating media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("Unexpected Error")
 	}
@@ -72,7 +72,7 @@ func LocalCopy(r *http.Request, rctx rcontext.RequestContext, user _apimeta.User
 
 	newMedia, err := upload_controller.UploadMedia(streamedMedia.Stream, streamedMedia.KnownMedia.SizeBytes, streamedMedia.KnownMedia.ContentType, streamedMedia.KnownMedia.UploadName, user.UserId, r.Host, rctx)
 	if err != nil {
-		rctx.Log.Error("Unexpected error storing media: " + err.Error())
+		rctx.Log.Error("Unexpected error storing media: ", err)
 		sentry.CaptureException(err)
 		return _responses.InternalServerError("Unexpected Error")
 	}

controllers/maintenance_controller/maintainance_controller.go

@@ -3,9 +3,10 @@ package maintenance_controller
 import (
 	"database/sql"
 	"fmt"
-	"github.com/getsentry/sentry-go"
 	"os"
 
+	"github.com/getsentry/sentry-go"
+
 	"github.com/sirupsen/logrus"
 	"github.com/turt2live/matrix-media-repo/common/rcontext"
 	"github.com/turt2live/matrix-media-repo/controllers/download_controller"
@@ -194,15 +195,15 @@ func PurgeRemoteMediaBefore(beforeTs int64, ctx rcontext.RequestContext) (int, e
 
 		ds, err := datastore.LocateDatastore(ctx, media.DatastoreId)
 		if err != nil {
-			ctx.Log.Error("Error finding datastore for media " + media.Origin + "/" + media.MediaId + " because: " + err.Error())
+			ctx.Log.Error("Error finding datastore for media "+media.Origin+"/"+media.MediaId+" because: ", err)
 			sentry.CaptureException(err)
 			continue
 		}
 
 		// Delete the file first
 		err = ds.DeleteObject(media.Location)
 		if err != nil {
-			ctx.Log.Warn("Cannot remove media " + media.Origin + "/" + media.MediaId + " because: " + err.Error())
+			ctx.Log.Warn("Cannot remove media "+media.Origin+"/"+media.MediaId+" because: ", err)
 			sentry.CaptureException(err)
 		} else {
 			removed++
@@ -212,36 +213,36 @@ func PurgeRemoteMediaBefore(beforeTs int64, ctx rcontext.RequestContext) (int, e
 		// Try to remove the record from the database now
 		err = db.Delete(media.Origin, media.MediaId)
 		if err != nil {
-			ctx.Log.Warn("Error removing media " + media.Origin + "/" + media.MediaId + " from database: " + err.Error())
+			ctx.Log.Warn("Error removing media "+media.Origin+"/"+media.MediaId+" from database: ", err)
 			sentry.CaptureException(err)
 		}
 
 		// Delete the thumbnails too
 		thumbs, err := thumbsDb.GetAllForMedia(media.Origin, media.MediaId)
 		if err != nil {
-			ctx.Log.Warn("Error getting thumbnails for media " + media.Origin + "/" + media.MediaId + " from database: " + err.Error())
+			ctx.Log.Warn("Error getting thumbnails for media "+media.Origin+"/"+media.MediaId+" from database: ", err)
 			sentry.CaptureException(err)
 			continue
 		}
 		for _, thumb := range thumbs {
 			ctx.Log.Info("Deleting thumbnail with hash: ", thumb.Sha256Hash)
 			ds, err := datastore.LocateDatastore(ctx, thumb.DatastoreId)
 			if err != nil {
-				ctx.Log.Warn("Error removing thumbnail for media " + media.Origin + "/" + media.MediaId + " from database: " + err.Error())
+				ctx.Log.Warn("Error removing thumbnail for media "+media.Origin+"/"+media.MediaId+" from database: ", err)
 				sentry.CaptureException(err)
 				continue
 			}
 
 			err = ds.DeleteObject(thumb.Location)
 			if err != nil {
-				ctx.Log.Warn("Error removing thumbnail for media " + media.Origin + "/" + media.MediaId + " from database: " + err.Error())
+				ctx.Log.Warn("Error removing thumbnail for media "+media.Origin+"/"+media.MediaId+" from database: ", err)
 				sentry.CaptureException(err)
 				continue
 			}
 		}
 		err = thumbsDb.DeleteAllForMedia(media.Origin, media.MediaId)
 		if err != nil {
-			ctx.Log.Warn("Error removing thumbnails for media " + media.Origin + "/" + media.MediaId + " from database: " + err.Error())
+			ctx.Log.Warn("Error removing thumbnails for media "+media.Origin+"/"+media.MediaId+" from database: ", err)
 			sentry.CaptureException(err)
 		}
 	}

controllers/preview_controller/preview_resource_handler.go

@@ -135,18 +135,18 @@ func urlPreviewWorkFn(request *resource_handler.WorkRequest) (resp *urlPreviewRe
 		// UploadMedia will close the read stream for the thumbnail and dedupe the image
 		media, err := upload_controller.UploadMedia(preview.Image.Data, contentLength, preview.Image.ContentType, preview.Image.Filename, info.forUserId, info.onHost, ctx)
 		if err != nil {
-			ctx.Log.Warn("Non-fatal error storing preview thumbnail: " + err.Error())
+			ctx.Log.Warn("Non-fatal error storing preview thumbnail: ", err)
 			sentry.CaptureException(err)
 		} else {
 			mediaStream, err := datastore.DownloadStream(ctx, media.DatastoreId, media.Location)
 			if err != nil {
-				ctx.Log.Warn("Non-fatal error streaming datastore file: " + err.Error())
+				ctx.Log.Warn("Non-fatal error streaming datastore file: ", err)
 				sentry.CaptureException(err)
 			} else {
 				defer stream_util.DumpAndCloseStream(mediaStream)
 				img, err := imaging.Decode(mediaStream)
 				if err != nil {
-					ctx.Log.Warn("Non-fatal error getting thumbnail dimensions: " + err.Error())
+					ctx.Log.Warn("Non-fatal error getting thumbnail dimensions: ", err)
 					sentry.CaptureException(err)
 				} else {
 					result.ImageMxc = media.MxcUri()
@@ -167,7 +167,7 @@ func urlPreviewWorkFn(request *resource_handler.WorkRequest) (resp *urlPreviewRe
 	}
 	err = db.InsertPreview(dbRecord)
 	if err != nil {
-		ctx.Log.Warn("Error caching URL preview: " + err.Error())
+		ctx.Log.Warn("Error caching URL preview: ", err)
 		sentry.CaptureException(err)
 		// Non-fatal: Just report it and move on. The worst that happens is we re-cache it.
 	}