@casual-simulation/aux-records 3.3.6 → 3.3.7-alpha.9747723960

package/RecordsServer.js

@@ -1,3 +1,9 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -42,6 +48,9 @@ import { WebsocketEventTypes, websocketEventSchema, websocketRequestMessageSchem
 import { DEFAULT_BRANCH_NAME } from '@casual-simulation/aux-common';
 import { getStatusCode, } from '@casual-simulation/aux-common';
 import { COM_ID_CONFIG_SCHEMA, COM_ID_PLAYER_CONFIG } from './ComIdConfig';
+import { SpanKind, trace } from '@opentelemetry/api';
+import { traceHttpResponse, traced } from './tracing/TracingDecorators';
+import { SEMATTRS_ENDUSER_ID, SEMATTRS_HTTP_CLIENT_IP, SEMATTRS_HTTP_HOST, SEMATTRS_HTTP_METHOD, SEMATTRS_HTTP_TARGET, SEMATTRS_HTTP_URL, SEMATTRS_HTTP_USER_AGENT, } from '@opentelemetry/semantic-conventions';
 export const NOT_LOGGED_IN_RESULT = {
     success: false,
     errorCode: 'not_logged_in',
@@ -362,6 +371,7 @@ export class RecordsServer {
         this._websocketController = websocketController;
         this._moderationController = moderationController;
         this._loomController = loomController;
+        this._tracer = trace.getTracer('RecordsServer', typeof GIT_TAG === 'undefined' ? undefined : GIT_TAG);
         this._procedures = this._createProcedures();
         this._setupRoutes();
     }
@@ -1583,6 +1593,48 @@ export class RecordsServer {
                 });
                 return result;
             })),
+            createSloydModel: procedure()
+                .origins('api')
+                .http('POST', '/api/v2/ai/sloyd/model')
+                .inputs(z.object({
+                recordName: RECORD_NAME_VALIDATION.optional(),
+                outputMimeType: z
+                    .enum(['model/gltf+json', 'model/gltf-binary'])
+                    .default('model/gltf+json'),
+                prompt: z.string().min(1),
+                levelOfDetail: z.number().min(0.01).max(1).optional(),
+                baseModelId: z.string().optional(),
+                thumbnail: z
+                    .object({
+                    type: z.literal('image/png'),
+                    width: z.number().int().min(1),
+                    height: z.number().int().min(1),
+                })
+                    .optional(),
+            }))
+                .handler(({ recordName, outputMimeType, prompt, levelOfDetail, baseModelId, thumbnail, }, context) => __awaiter(this, void 0, void 0, function* () {
+                if (!this._aiController) {
+                    return AI_NOT_SUPPORTED_RESULT;
+                }
+                const sessionKeyValidation = yield this._validateSessionKey(context.sessionKey);
+                if (sessionKeyValidation.success === false) {
+                    if (sessionKeyValidation.errorCode ===
+                        'no_session_key') {
+                        return NOT_LOGGED_IN_RESULT;
+                    }
+                    return sessionKeyValidation;
+                }
+                const result = yield this._aiController.sloydGenerateModel({
+                    userId: sessionKeyValidation.userId,
+                    recordName: recordName !== null && recordName !== void 0 ? recordName : sessionKeyValidation.userId,
+                    outputMimeType,
+                    prompt,
+                    levelOfDetail,
+                    baseModelId,
+                    thumbnail: thumbnail,
+                });
+                return result;
+            })),
             getLoomAccessToken: procedure()
                 .origins('api')
                 .http('GET', '/api/v2/loom/token')
@@ -2169,7 +2221,7 @@ export class RecordsServer {
             if (procs.hasOwnProperty(procedureName)) {
                 const procedure = procs[procedureName];
                 if (procedure.http) {
-                    this._addProcedureRoute(procedure);
+                    this._addProcedureRoute(procedure, procedureName);
                 }
             }
         }
@@ -2190,6 +2242,11 @@ export class RecordsServer {
                         errorMessage: `Unable to find procedure: ${procedure}`,
                     });
                 }
+                const span = trace.getActiveSpan();
+                if (span) {
+                    span.updateName(`http:${procedure}`);
+                    span.setAttribute('request.procedure', procedure);
+                }
                 const origins = proc.allowedOrigins === 'account'
                     ? this._allowedAccountOrigins
                     : proc.allowedOrigins === 'api'
@@ -2221,6 +2278,7 @@ export class RecordsServer {
         this.addRoute({
             method: 'POST',
             path: '/api/stripeWebhook',
+            name: 'stripeWebhook',
             allowedOrigins: true,
             handler: (request) => this._stripeWebhook(request),
         });
@@ -2236,7 +2294,7 @@ export class RecordsServer {
         }
         this._procedures[name] = procedure;
         if (procedure.http) {
-            this._addProcedureRoute(procedure);
+            this._addProcedureRoute(procedure, name);
         }
     }
     /**
@@ -2252,7 +2310,7 @@ export class RecordsServer {
      * Adds the given procedural route to the server.
      * @param route The route that should be added.
      */
-    _addProcedureRoute(procedure) {
+    _addProcedureRoute(procedure, name) {
         if (!procedure.http) {
             throw new Error('Procedure must have an http route defined.');
         }
@@ -2261,6 +2319,7 @@ export class RecordsServer {
             method: route.method,
             path: route.path,
             schema: procedure.schema,
+            name: name,
             handler: (request, data) => __awaiter(this, void 0, void 0, function* () {
                 var _a;
                 const context = {
@@ -2301,6 +2360,19 @@ export class RecordsServer {
     handleHttpRequest(request) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            const span = trace.getActiveSpan();
+            if (span) {
+                const url = new URL(request.path, `http://${request.headers.host}`);
+                span.setAttributes({
+                    [SEMATTRS_HTTP_METHOD]: request.method,
+                    [SEMATTRS_HTTP_URL]: url.href,
+                    [SEMATTRS_HTTP_TARGET]: request.path,
+                    [SEMATTRS_HTTP_CLIENT_IP]: request.ipAddress,
+                    [SEMATTRS_HTTP_HOST]: request.headers.host,
+                    [SEMATTRS_HTTP_USER_AGENT]: request.headers['user-agent'],
+                    ['http.origin']: request.headers.origin,
+                });
+            }
             let skipRateLimitCheck = false;
             if (!this._rateLimit) {
                 skipRateLimitCheck = true;
@@ -2309,6 +2381,9 @@ export class RecordsServer {
                 request.path === '/api/stripeWebhook') {
                 skipRateLimitCheck = true;
             }
+            if (skipRateLimitCheck && span) {
+                span.setAttribute('request.rateLimitCheck', 'skipped');
+            }
             if (!skipRateLimitCheck) {
                 const response = yield this._rateLimit.checkRateLimit({
                     ipAddress: request.ipAddress,
@@ -2355,6 +2430,9 @@ export class RecordsServer {
             }
             const route = this._routes.get(`${request.method}:${request.path}`);
             if (route) {
+                if (span && route.name) {
+                    span.updateName(`http:${route.name}`);
+                }
                 const origins = route.allowedOrigins === 'account'
                     ? this._allowedAccountOrigins
                     : route.allowedOrigins === 'api'
@@ -2423,6 +2501,15 @@ export class RecordsServer {
             if (!this._websocketController) {
                 return;
             }
+            const span = trace.getActiveSpan();
+            if (span) {
+                span.setAttributes({
+                    [SEMATTRS_HTTP_CLIENT_IP]: request.ipAddress,
+                    ['http.origin']: request.origin,
+                    ['websocket.type']: request.type,
+                    ['request.connectionId']: request.connectionId,
+                });
+            }
             let skipRateLimitCheck = false;
             if (!this._websocketRateLimit) {
                 skipRateLimitCheck = true;
@@ -2444,6 +2531,9 @@ export class RecordsServer {
                     }
                 }
             }
+            if (skipRateLimitCheck && span) {
+                span.setAttribute('request.rateLimitCheck', 'skipped');
+            }
             if (request.type === 'connect') {
                 console.log(`[RecordsServer] Connection recieved: `, request.connectionId);
             }
@@ -2496,12 +2586,15 @@ export class RecordsServer {
     }
     _processWebsocketMessage(request, requestId, message) {
         return __awaiter(this, void 0, void 0, function* () {
+            const span = trace.getActiveSpan();
             const messageResult = websocketRequestMessageSchema.safeParse(message);
             if (messageResult.success === false) {
+                span === null || span === void 0 ? void 0 : span.setAttribute('request.messageType', 'invalid');
                 yield this._sendWebsocketZodError(request.connectionId, requestId, messageResult.error);
                 return;
             }
             const data = messageResult.data;
+            span === null || span === void 0 ? void 0 : span.setAttribute('request.messageType', data.type);
             if (data.type === 'login') {
                 yield this._websocketController.login(request.connectionId, requestId, data);
             }
@@ -5124,17 +5217,72 @@ export class RecordsServer {
                     errorMessage: 'A session key was not provided, but it is required for this operation.',
                 };
             }
-            return yield this._auth.validateSessionKey(sessionKey);
+            const result = yield this._auth.validateSessionKey(sessionKey);
+            if (result.success === true) {
+                const span = trace.getActiveSpan();
+                if (span) {
+                    span.setAttributes({
+                        [SEMATTRS_ENDUSER_ID]: result.userId,
+                        ['request.userId']: result.userId,
+                        ['request.userRole']: result.role,
+                        ['request.sessionId']: result.sessionId,
+                        ['request.subscriptionId']: result.subscriptionId,
+                        ['request.subscriptionTier']: result.subscriptionTier,
+                    });
+                }
+            }
+            return result;
         });
     }
 }
+__decorate([
+    traced('RecordsServer', {
+        kind: SpanKind.SERVER,
+        root: true,
+    }),
+    traceHttpResponse()
+], RecordsServer.prototype, "handleHttpRequest", null);
+__decorate([
+    traced('RecordsServer', {
+        kind: SpanKind.SERVER,
+    })
+], RecordsServer.prototype, "handleWebsocketRequest", null);
+__decorate([
+    traced('RecordsServer')
+], RecordsServer.prototype, "_processWebsocketMessage", null);
+__decorate([
+    traced('RecordsServer')
+], RecordsServer.prototype, "_processWebsocketDownload", null);
+__decorate([
+    traced('RecordsServer')
+], RecordsServer.prototype, "_processWebsocketUploadRequest", null);
 export function returnResult(result) {
+    const span = trace.getActiveSpan();
+    if (span) {
+        if (result.success === false) {
+            span.setAttributes({
+                ['result.errorCode']: result.errorCode,
+                ['result.errorMessage']: result.errorMessage,
+            });
+            if (result.reason) {
+                for (let prop in result.reason) {
+                    span.setAttribute(`result.reason.${prop}`, result.reason[prop]);
+                }
+            }
+        }
+    }
     return {
         statusCode: getStatusCode(result),
         body: JSON.stringify(result),
     };
 }
 export function returnProcedureOutputStream(result) {
+    const span = trace.getActiveSpan();
+    if (span) {
+        span.setAttributes({
+            ['result.stream']: true,
+        });
+    }
     function generateBody() {
         return __asyncGenerator(this, arguments, function* generateBody_1() {
             while (true) {