@malloydata/malloy 0.0.295 → 0.0.297

package/dist/api/asynchronous.js

@@ -45,16 +45,20 @@ exports.compileQuery = compileQuery;
 exports.runQuery = runQuery;
 const Core = __importStar(require("./core"));
 const util_1 = require("./util");
+const timing_1 = require("../timing");
 async function fetchNeeds(needs, fetchers) {
     var _a, _b, _c, _d, _e, _f, _g;
     var _h, _j;
+    const timer = new timing_1.Timer('fetch_needs');
     if (needs === undefined) {
         throw new Error("Expected compiler to have needs because it didn't return a result");
     }
     const result = {};
     if (needs.connections) {
         for (const connection of needs.connections) {
+            const t = new timing_1.Timer('lookup_connection');
             const info = await fetchers.connections.lookupConnection(connection.name);
+            timer.contribute([t.stop()]);
             (_a = result.connections) !== null && _a !== void 0 ? _a : (result.connections = []);
             result.connections.push({
                 ...connection,
@@ -65,7 +69,9 @@ async function fetchNeeds(needs, fetchers) {
     if (needs.files) {
         for (const file of needs.files) {
             // TODO handle checking if the cache has the file...
+            const t = new timing_1.Timer('read_url');
             const info = await fetchers.urls.readURL(new URL(file.url));
+            timer.contribute([t.stop()]);
             (_b = result.files) !== null && _b !== void 0 ? _b : (result.files = []);
             if (typeof info === 'string') {
                 result.files.push({
@@ -89,12 +95,16 @@ async function fetchNeeds(needs, fetchers) {
             tableSchemasByConnection[tableSchema.connection_name].push(tableSchema);
         }
         for (const connectionName in tableSchemasByConnection) {
+            const t1 = new timing_1.Timer('lookup_connection');
             const connection = await fetchers.connections.lookupConnection(connectionName);
+            timer.contribute([t1.stop()]);
             const tableNames = tableSchemasByConnection[connectionName].map(t => t.name);
+            const t2 = new timing_1.Timer('fetch_table_schemas');
             const schemas = await Promise.all(tableNames.map(async (tableName) => ({
                 name: tableName,
                 schema: await connection.fetchSchemaForTable(tableName),
             })));
+            timer.contribute([t2.stop()]);
             (_e = result.table_schemas) !== null && _e !== void 0 ? _e : (result.table_schemas = []);
             for (const schema of schemas) {
                 result.table_schemas.push({
@@ -112,12 +122,16 @@ async function fetchNeeds(needs, fetchers) {
             sqlSchemasByConnectionName[sqlSchema.connection_name].push(sqlSchema);
         }
         for (const connectionName in sqlSchemasByConnectionName) {
+            const t1 = new timing_1.Timer('lookup_connection');
             const connection = await fetchers.connections.lookupConnection(connectionName);
+            timer.contribute([t1.stop()]);
             const sqlQueries = sqlSchemasByConnectionName[connectionName].map(t => t.sql);
+            const t2 = new timing_1.Timer('lookup_sql_schemas');
             const schemas = await Promise.all(sqlQueries.map(async (sql) => ({
                 sql,
                 schema: await connection.fetchSchemaForSQLQuery(sql),
             })));
+            timer.contribute([t2.stop()]);
             (_g = result.sql_schemas) !== null && _g !== void 0 ? _g : (result.sql_schemas = []);
             for (const schema of schemas) {
                 result.sql_schemas.push({
@@ -128,49 +142,60 @@ async function fetchNeeds(needs, fetchers) {
             }
         }
     }
-    return result;
+    return { needs: result, timingInfo: timer.stop() };
 }
 async function compileModel(request, fetchers) {
+    const timer = new timing_1.Timer('compile_model');
     const state = Core.newCompileModelState(request);
     // eslint-disable-next-line no-constant-condition
     while (true) {
         const result = Core.statedCompileModel(state);
+        timer.incorporate(result.timing_info);
         if (result.model || Core.hasErrors(result.logs)) {
-            return result;
+            return { ...result, timing_info: timer.stop() };
         }
-        const needs = await fetchNeeds(result.compiler_needs, fetchers);
+        const { needs, timingInfo } = await fetchNeeds(result.compiler_needs, fetchers);
+        timer.incorporate(timingInfo);
         Core.updateCompileModelState(state, needs);
     }
 }
 async function compileSource(request, fetchers) {
+    const timer = new timing_1.Timer('compile_source');
     const state = Core.newCompileSourceState(request);
     // eslint-disable-next-line no-constant-condition
     while (true) {
         const result = Core.statedCompileSource(state, request.name);
+        timer.incorporate(result.timing_info);
         if (result.source || Core.hasErrors(result.logs)) {
-            return result;
+            return { ...result, timing_info: timer.stop() };
         }
-        const needs = await fetchNeeds(result.compiler_needs, fetchers);
+        const { needs, timingInfo } = await fetchNeeds(result.compiler_needs, fetchers);
+        timer.incorporate(timingInfo);
         Core.updateCompileModelState(state, needs);
     }
 }
 async function compileQuery(request, fetchers) {
+    const timer = new timing_1.Timer('compile_query');
     const state = Core.newCompileQueryState(request);
     // eslint-disable-next-line no-constant-condition
     while (true) {
         const result = Core.statedCompileQuery(state);
+        timer.incorporate(result.timing_info);
         if (result.result || Core.hasErrors(result.logs)) {
-            return result;
+            return { ...result, timing_info: timer.stop() };
         }
-        const needs = await fetchNeeds(result.compiler_needs, fetchers);
+        const { needs, timingInfo } = await fetchNeeds(result.compiler_needs, fetchers);
+        timer.incorporate(timingInfo);
         Core.updateCompileModelState(state, needs);
     }
 }
 async function runQuery(request, fetchers) {
     var _a, _b;
+    const timer = new timing_1.Timer('run_query');
     const compiled = await compileQuery(request, fetchers);
+    timer.incorporate(compiled.timing_info);
     if (compiled.result === undefined) {
-        return compiled;
+        return { ...compiled, timing_info: timer.stop() };
     }
     const defaultURL = request.model_url;
     if (compiled.result.sql === undefined) {
@@ -187,14 +212,19 @@ async function runQuery(request, fetchers) {
         };
     }
     try {
+        const t1 = new timing_1.Timer('lookup_connection');
         const connection = await fetchers.connections.lookupConnection(compiled.result.connection_name);
+        timer.contribute([t1.stop()]);
+        const t2 = new timing_1.Timer('run_sql');
         const data = await connection.runSQL(compiled.result.sql, compiled.result.schema);
+        timer.contribute([t2.stop()]);
         return {
             ...compiled,
             result: {
                 ...compiled.result,
                 data,
             },
+            timing_info: timer.stop(),
         };
     }
     catch (error) {
@@ -209,6 +239,7 @@ async function runQuery(request, fetchers) {
                     range: util_1.DEFAULT_LOG_RANGE,
                 },
             ],
+            timing_info: timer.stop(),
         };
     }
 }

package/dist/api/core.d.ts

@@ -7,16 +7,19 @@ export type CompileResponse = {
     modelDef: ModelDef;
     compilerNeeds?: undefined;
     logs?: LogMessage[];
+    timingInfo: Malloy.TimingInfo;
 } | {
     model?: undefined;
     modelDef?: undefined;
     compilerNeeds: Malloy.CompilerNeeds;
     logs?: LogMessage[];
+    timingInfo: Malloy.TimingInfo;
 } | {
     model?: undefined;
     modelDef?: undefined;
     compilerNeeds?: undefined;
     logs: LogMessage[];
+    timingInfo: Malloy.TimingInfo;
 };
 export declare function compileQuery(request: Malloy.CompileQueryRequest, state?: CompileQueryState): Malloy.CompileQueryResponse;
 export interface CompileModelState {

package/dist/api/core.js

@@ -59,6 +59,7 @@ const sql_block_1 = require("../model/sql_block");
 const annotation_1 = require("../annotation");
 const malloy_tag_1 = require("@malloydata/malloy-tag");
 const util_1 = require("./util");
+const timing_1 = require("../timing");
 // TODO find where this should go...
 function tableKey(connectionName, tablePath) {
     return `${connectionName}:${tablePath}`;
@@ -299,12 +300,15 @@ function statedCompileSource(state, name) {
     return extractSource(_statedCompileModel(state), name, state.translator.sourceURL);
 }
 function _statedCompileModel(state) {
+    const timer = new timing_1.Timer('compile_model');
     let extendingModel = undefined;
+    let extendingResult = undefined;
     if (state.extending) {
         if (!state.extending.done) {
-            const extendingResult = _statedCompileModel(state.extending);
+            extendingResult = _statedCompileModel(state.extending);
+            timer.contribute([extendingResult.timingInfo]);
             if (!state.extending.done) {
-                return extendingResult;
+                return { ...extendingResult, timingInfo: timer.stop() };
             }
         }
         extendingModel = state.extending.translator.modelDef;
@@ -312,15 +316,20 @@ function _statedCompileModel(state) {
     if (!state.hasSource) {
         return {
             compilerNeeds: convertCompilerNeeds(undefined, [state.translator.sourceURL], undefined),
+            timingInfo: timer.stop(),
         };
     }
     const result = state.translator.translate(extendingModel);
+    timer.incorporate(result.timingInfo);
     if (result.final) {
         state.done = true;
+        const timingInfo = timer.stop();
         if (result.modelDef) {
+            const model = (0, to_stable_1.modelDefToModelInfo)(result.modelDef);
             return {
-                model: (0, to_stable_1.modelDefToModelInfo)(result.modelDef),
+                model,
                 modelDef: result.modelDef,
+                timingInfo,
             };
         }
         else {
@@ -329,18 +338,24 @@ function _statedCompileModel(state) {
             }
             return {
                 logs: result.problems,
+                timingInfo,
             };
         }
     }
     else {
         const compilerNeeds = convertCompilerNeeds(result.compileSQL, result.urls, result.tables);
-        return { compilerNeeds, logs: result.problems };
+        const timingInfo = timer.stop();
+        return { compilerNeeds, logs: result.problems, timingInfo };
     }
 }
 function wrapResponse(response, defaultURL) {
     const logs = response.logs ? (0, util_1.mapLogs)(response.logs, defaultURL) : undefined;
     if (response.compilerNeeds) {
-        return { compiler_needs: response.compilerNeeds, logs };
+        return {
+            compiler_needs: response.compilerNeeds,
+            logs,
+            timing_info: response.timingInfo,
+        };
     }
     else {
         let translations = undefined;
@@ -352,7 +367,12 @@ function wrapResponse(response, defaultURL) {
                 },
             ];
         }
-        return { model: response.model, logs, translations };
+        return {
+            model: response.model,
+            logs,
+            translations,
+            timing_info: response.timingInfo,
+        };
     }
 }
 function _compileModel(modelURL, compilerNeeds, extendURL, state) {
@@ -383,12 +403,17 @@ function extractSource(result, name, defaultURL) {
                         range: util_1.DEFAULT_LOG_RANGE,
                     },
                 ],
+                timing_info: result.timingInfo,
             };
         }
-        return { source, logs };
+        return { source, logs, timing_info: result.timingInfo };
     }
     else {
-        return { compiler_needs: result.compilerNeeds, logs };
+        return {
+            compiler_needs: result.compilerNeeds,
+            logs,
+            timing_info: result.timingInfo,
+        };
     }
 }
 function hasErrors(log) {
@@ -416,7 +441,9 @@ function newCompileQueryState(request) {
 }
 function statedCompileQuery(state) {
     var _a, _b;
+    const timer = new timing_1.Timer('compile_query');
     const result = _statedCompileModel(state);
+    timer.incorporate(result.timingInfo);
     // TODO this can expose the internal URL... is there a better way to handle URL-less errors from the compiler?
     const defaultURL = state.translator.sourceURL;
     const logs = result.logs ? (0, util_1.mapLogs)(result.logs, defaultURL) : undefined;
@@ -424,6 +451,7 @@ function statedCompileQuery(state) {
         const queries = result.modelDef.queryList;
         if (queries.length === 0) {
             return {
+                timing_info: timer.stop(),
                 logs: [
                     ...(logs !== null && logs !== void 0 ? logs : []),
                     {
@@ -440,10 +468,12 @@ function statedCompileQuery(state) {
         const schema = result.model.anonymous_queries[index].schema;
         const annotations = (_a = result.model.anonymous_queries[index].annotations) !== null && _a !== void 0 ? _a : [];
         try {
+            const sqlTimer = new timing_1.Timer('generate_sql');
             const queryModel = new model_1.QueryModel(result.modelDef);
             const translatedQuery = queryModel.compileQuery(query, {
                 defaultRowLimit: state.defaultRowLimit,
             });
+            timer.contribute([sqlTimer.stop()]);
             const modelAnnotations = (0, annotation_1.annotationToTaglines)(result.modelDef.annotation).map(l => ({
                 value: l,
             }));
@@ -486,6 +516,7 @@ function statedCompileQuery(state) {
                         .toString(),
                 });
             }
+            const timingInfo = timer.stop();
             return {
                 result: {
                     sql: translatedQuery.sql,
@@ -497,9 +528,11 @@ function statedCompileQuery(state) {
                     source_annotations: annotationsOrUndefined(sourceAnnotations),
                 },
                 default_row_limit_added: translatedQuery.defaultRowLimitAdded,
+                timing_info: timingInfo,
             };
         }
         catch (error) {
+            const timingInfo = timer.stop();
             return {
                 logs: [
                     ...(logs !== null && logs !== void 0 ? logs : []),
@@ -510,11 +543,16 @@ function statedCompileQuery(state) {
                         range: util_1.DEFAULT_LOG_RANGE,
                     },
                 ],
+                timing_info: timingInfo,
             };
         }
     }
     else {
-        return { compiler_needs: result.compilerNeeds, logs };
+        return {
+            compiler_needs: result.compilerNeeds,
+            logs,
+            timing_info: timer.stop(),
+        };
     }
 }
 function annotationsOrUndefined(annotations) {

package/dist/api/sessioned.js

@@ -45,6 +45,7 @@ exports.compileQuery = compileQuery;
 const Malloy = __importStar(require("@malloydata/malloy-interfaces"));
 const Core = __importStar(require("./core"));
 const uuid_1 = require("uuid");
+const timing_1 = require("../timing");
 function sessionInfosMatch(a, b) {
     if (a.type === 'compile_model') {
         if (b.type !== 'compile_model')
@@ -109,6 +110,7 @@ class SessionManager {
             state,
             expires,
             sessionId: this.newSessionId(),
+            timer: new timing_1.Timer('compile_model'),
         };
     }
     newCompileSourceSession(request, sessionInfo, options) {
@@ -120,6 +122,7 @@ class SessionManager {
             state,
             expires,
             sessionId: this.newSessionId(),
+            timer: new timing_1.Timer('compile_source'),
         };
     }
     newCompileQuerySession(request, sessionInfo, options) {
@@ -131,6 +134,7 @@ class SessionManager {
             state,
             expires,
             sessionId: this.newSessionId(),
+            timer: new timing_1.Timer('compile_query'),
         };
     }
     findCompileModelSession(sessionId, sessionInfo) {
@@ -155,6 +159,10 @@ class SessionManager {
             this.findCompileModelSession(options.session_id, sessionInfo);
         this.purgeExpired({ except: options === null || options === void 0 ? void 0 : options.session_id });
         if (session) {
+            if (session.waitingTimer) {
+                session.timer.contribute([session.waitingTimer.stop()]);
+                session.waitingTimer = undefined;
+            }
             if (options === null || options === void 0 ? void 0 : options.ttl) {
                 session.expires = this.getExpires(options.ttl);
             }
@@ -165,10 +173,21 @@ class SessionManager {
             this.sessions.set(session.sessionId, session);
         }
         const result = Core.statedCompileModel(session.state);
-        if (result.model || this.hasErrors(result.logs)) {
+        session.timer.incorporate(result.timing_info);
+        const done = result.model || this.hasErrors(result.logs);
+        if (done) {
             this.killSession(session.sessionId);
         }
-        return { ...result, session_id: session.sessionId };
+        // TODO not really using it as "stop", but more like "current"
+        const timingInfo = session.timer.stop();
+        if (!done) {
+            session.waitingTimer = new timing_1.Timer('session_wait');
+        }
+        return {
+            ...result,
+            session_id: session.sessionId,
+            timing_info: timingInfo,
+        };
     }
     findCompileSourceSession(sessionId, sessionInfo) {
         const session = this.findSession(sessionId, sessionInfo);
@@ -187,6 +206,10 @@ class SessionManager {
             this.findCompileSourceSession(options.session_id, sessionInfo);
         this.purgeExpired({ except: options === null || options === void 0 ? void 0 : options.session_id });
         if (session) {
+            if (session.waitingTimer) {
+                session.timer.contribute([session.waitingTimer.stop()]);
+                session.waitingTimer = undefined;
+            }
             if (options === null || options === void 0 ? void 0 : options.ttl) {
                 session.expires = this.getExpires(options.ttl);
             }
@@ -197,10 +220,20 @@ class SessionManager {
             this.sessions.set(session.sessionId, session);
         }
         const result = Core.statedCompileSource(session.state, request.name);
-        if (result.source || this.hasErrors(result.logs)) {
+        session.timer.incorporate(result.timing_info);
+        const done = result.source || this.hasErrors(result.logs);
+        if (done) {
             this.killSession(session.sessionId);
         }
-        return { ...result, session_id: session.sessionId };
+        const timingInfo = session.timer.stop();
+        if (!done) {
+            session.waitingTimer = new timing_1.Timer('session_wait');
+        }
+        return {
+            ...result,
+            session_id: session.sessionId,
+            timing_info: timingInfo,
+        };
     }
     findCompileQuerySession(sessionId, sessionInfo) {
         const session = this.findSession(sessionId, sessionInfo);
@@ -220,6 +253,10 @@ class SessionManager {
             this.findCompileQuerySession(options.session_id, sessionInfo);
         this.purgeExpired({ except: options === null || options === void 0 ? void 0 : options.session_id });
         if (session) {
+            if (session.waitingTimer) {
+                session.timer.contribute([session.waitingTimer.stop()]);
+                session.waitingTimer = undefined;
+            }
             if (options === null || options === void 0 ? void 0 : options.ttl) {
                 session.expires = this.getExpires(options.ttl);
             }
@@ -230,10 +267,20 @@ class SessionManager {
             this.sessions.set(session.sessionId, session);
         }
         const result = Core.statedCompileQuery(session.state);
-        if (result.result || this.hasErrors(result.logs)) {
+        session.timer.incorporate(result.timing_info);
+        const done = result.result || this.hasErrors(result.logs);
+        if (done) {
             this.killSession(session.sessionId);
         }
-        return { ...result, session_id: session.sessionId };
+        const timingInfo = session.timer.stop();
+        if (!done) {
+            session.waitingTimer = new timing_1.Timer('session_wait');
+        }
+        return {
+            ...result,
+            session_id: session.sessionId,
+            timing_info: timingInfo,
+        };
     }
 }
 const SESSION_MANAGER = new SessionManager();