@blaxel/core 0.2.4 → 0.2.6-dev.74

package/dist/authentication/clientcredentials.d.ts

@@ -9,6 +9,8 @@ export declare class ClientCredentials extends Credentials {
     get workspace(): string;
     needRefresh(): boolean;
     authenticate(): Promise<void>;
+    private sleep;
+    processWithRetry(retry?: number): Promise<void>;
     process(): Promise<void>;
     get authorization(): string;
     get token(): string;

package/dist/authentication/clientcredentials.js

@@ -42,9 +42,24 @@ class ClientCredentials extends credentials_js_1.Credentials {
         if (!this.needRefresh()) {
             return this.currentPromise || Promise.resolve();
         }
-        this.currentPromise = this.process();
+        this.currentPromise = this.processWithRetry();
         return this.currentPromise;
     }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async processWithRetry(retry = 3) {
+        try {
+            return await this.process();
+        }
+        catch (error) {
+            if (retry > 0) {
+                await this.sleep(1000);
+                return this.processWithRetry(retry - 1);
+            }
+            throw error;
+        }
+    }
     async process() {
         const response = await (0, authentication_js_1.oauthToken)({
             headers: {

package/dist/jobs/index.d.ts

@@ -1 +1,3 @@
 export * from "./jobs.js";
+export * from "./start.js";
+export * from "./types.js";

package/dist/jobs/index.js

@@ -15,3 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./jobs.js"), exports);
+__exportStar(require("./start.js"), exports);
+__exportStar(require("./types.js"), exports);

package/dist/jobs/jobs.d.ts

@@ -1,11 +1,13 @@
 declare class BlJob {
-    getArguments(): Promise<{
-        [key: number]: any;
-    }>;
-    private parseCommandLineArgs;
-    get indexKey(): string;
-    get index(): number;
-    start(func: (args: any) => Promise<void>): Promise<void>;
+    jobName: string;
+    constructor(jobName: string);
+    get fallbackUrl(): import("url").URL | null;
+    get externalUrl(): import("url").URL;
+    get internalUrl(): import("url").URL;
+    get forcedUrl(): import("url").URL | null;
+    get url(): import("url").URL;
+    call(url: URL, tasks: Record<string, unknown>[]): Promise<Response>;
+    run(tasks: Record<string, unknown>[]): Promise<string>;
 }
-export declare const blJob: BlJob;
+export declare const blJob: (jobName: string) => BlJob;
 export {};

package/dist/jobs/jobs.js

@@ -2,54 +2,94 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.blJob = void 0;
 const env_js_1 = require("../common/env.js");
+const internal_js_1 = require("../common/internal.js");
+const logger_js_1 = require("../common/logger.js");
+const settings_js_1 = require("../common/settings.js");
+const telemetry_js_1 = require("../telemetry/telemetry.js");
 class BlJob {
-    async getArguments() {
-        if (!env_js_1.env.BL_EXECUTION_DATA_URL) {
-            const args = this.parseCommandLineArgs();
-            return args;
+    jobName;
+    constructor(jobName) {
+        this.jobName = jobName;
+    }
+    get fallbackUrl() {
+        if (this.externalUrl != this.url) {
+            return this.externalUrl;
         }
-        const response = await fetch(env_js_1.env.BL_EXECUTION_DATA_URL);
-        const data = await response.json();
-        return data.tasks[this.index] ?? {};
-    }
-    parseCommandLineArgs() {
-        const args = process.argv.slice(2);
-        const result = {};
-        for (let i = 0; i < args.length; i++) {
-            const arg = args[i];
-            if (arg.startsWith('--')) {
-                const key = arg.slice(2);
-                const value = args[i + 1];
-                if (value && !value.startsWith('--')) {
-                    result[key] = value;
-                    i++;
-                }
-                else {
-                    result[key] = 'true';
-                }
-            }
+        return null;
+    }
+    get externalUrl() {
+        return new URL(`${settings_js_1.settings.runUrl}/${settings_js_1.settings.workspace}/jobs/${this.jobName}`);
+    }
+    get internalUrl() {
+        const hash = (0, internal_js_1.getGlobalUniqueHash)(settings_js_1.settings.workspace, "job", this.jobName);
+        return new URL(`${settings_js_1.settings.runInternalProtocol}://bl-${settings_js_1.settings.env}-${hash}.${settings_js_1.settings.runInternalHostname}`);
+    }
+    get forcedUrl() {
+        const envVar = this.jobName.replace(/-/g, "_").toUpperCase();
+        if (env_js_1.env[`BL_JOB_${envVar}_URL`]) {
+            return new URL(env_js_1.env[`BL_JOB_${envVar}_URL`]);
         }
-        return result;
+        return null;
     }
-    get indexKey() {
-        return env_js_1.env.BL_TASK_KEY ?? "TASK_INDEX";
+    get url() {
+        if (this.forcedUrl)
+            return this.forcedUrl;
+        if (settings_js_1.settings.runInternalHostname)
+            return this.internalUrl;
+        return this.externalUrl;
     }
-    get index() {
-        return env_js_1.env[this.indexKey] ? Number(env_js_1.env[this.indexKey]) ?? 0 : 0;
+    async call(url, tasks) {
+        let body = {
+            tasks: tasks
+        };
+        const response = await fetch(url + "/executions", {
+            method: "POST",
+            headers: {
+                ...settings_js_1.settings.headers,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(body),
+        });
+        return response;
     }
-    /*
-      Run a job defined in a function, it's run in the current process
-    */
-    async start(func) {
+    async run(tasks) {
+        logger_js_1.logger.debug(`Job Calling: ${this.jobName}`);
+        const span = (0, telemetry_js_1.startSpan)(this.jobName, {
+            attributes: {
+                "job.name": this.jobName,
+                "span.type": "job.run",
+            },
+            isRoot: false,
+        });
         try {
-            const parsedArgs = await this.getArguments();
-            await func(parsedArgs);
-            process.exit(0);
+            const response = await this.call(this.url, tasks);
+            return await response.text();
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                if (!this.fallbackUrl) {
+                    span.setAttribute("job.run.error", err.stack);
+                    throw err;
+                }
+                try {
+                    const response = await this.call(this.fallbackUrl, tasks);
+                    return await response.text();
+                }
+                catch (err) {
+                    if (err instanceof Error) {
+                        span.setAttribute("job.run.error", err.stack);
+                    }
+                    throw err;
+                }
+            }
+            throw err;
         }
-        catch (error) {
-            console.error('Job execution failed:', error);
-            process.exit(1);
+        finally {
+            span.end();
         }
     }
 }
-exports.blJob = new BlJob();
+const blJob = (jobName) => {
+    return new BlJob(jobName);
+};
+exports.blJob = blJob;

package/dist/jobs/start.d.ts

@@ -0,0 +1 @@
+export declare const blStartJob: (func: (args: any) => Promise<void>) => void;

package/dist/jobs/start.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blStartJob = void 0;
+const autoload_js_1 = require("../common/autoload.js");
+const env_js_1 = require("../common/env.js");
+const telemetry_js_1 = require("../telemetry/telemetry.js");
+class BlJobWrapper {
+    async getArguments() {
+        if (!env_js_1.env.BL_EXECUTION_DATA_URL) {
+            const args = this.parseCommandLineArgs();
+            return args;
+        }
+        const response = await fetch(env_js_1.env.BL_EXECUTION_DATA_URL);
+        const data = await response.json();
+        return data.tasks[this.index] ?? {};
+    }
+    parseCommandLineArgs() {
+        const args = process.argv.slice(2);
+        const result = {};
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (arg.startsWith('--')) {
+                const key = arg.slice(2);
+                const value = args[i + 1];
+                if (value && !value.startsWith('--')) {
+                    result[key] = value;
+                    i++;
+                }
+                else {
+                    result[key] = 'true';
+                }
+            }
+        }
+        return result;
+    }
+    get indexKey() {
+        return env_js_1.env.BL_TASK_KEY ?? "TASK_INDEX";
+    }
+    get index() {
+        return env_js_1.env[this.indexKey] ? Number(env_js_1.env[this.indexKey]) ?? 0 : 0;
+    }
+    /*
+      Run a job defined in a function, it's run in the current process
+    */
+    async start(func) {
+        await (0, autoload_js_1.authenticate)();
+        let span = (0, telemetry_js_1.startSpan)(`blStartJob-${func.name}`, {
+            attributes: {
+                'job.name': func.name,
+                'job.index': this.index,
+                'job.args': JSON.stringify(this.getArguments()),
+            },
+            isRoot: true,
+        });
+        try {
+            const parsedArgs = await this.getArguments();
+            await func(parsedArgs);
+            span.setStatus('ok');
+            span.end();
+        }
+        catch (error) {
+            span.recordException(error);
+            span.setStatus('error', 'Job execution failed');
+            span.end();
+            throw error;
+        }
+    }
+}
+const blStartJob = (func) => {
+    const job = new BlJobWrapper();
+    job.start(func).then(async () => {
+        try {
+            await (0, telemetry_js_1.flush)();
+        }
+        catch (error) {
+            console.error('Error flushing telemetry:', error);
+        }
+    }).catch((error) => {
+        console.error('Job execution failed:', error);
+        process.exit(1);
+    });
+};
+exports.blStartJob = blStartJob;

package/dist/jobs/types.d.ts

@@ -0,0 +1,3 @@
+export type ExecutionArgs = {
+    [key: number]: any;
+}[];

package/dist/jobs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/telemetry/telemetry.d.ts

@@ -32,6 +32,8 @@ export interface BlaxelSpan {
 export interface BlaxelTelemetryProvider {
     /** Create a new span */
     startSpan(name: string, options?: BlaxelSpanOptions): BlaxelSpan;
+    /** Flush the telemetry provider */
+    flush(): Promise<void>;
 }
 /**
  * Registry for managing the global telemetry provider
@@ -55,5 +57,6 @@ export declare const telemetryRegistry: TelemetryRegistry;
  * Create a span with the registered provider
  */
 export declare function startSpan(name: string, options?: BlaxelSpanOptions): BlaxelSpan;
-export declare function withSpan<T>(name: string, fn: () => T, options?: BlaxelSpanOptions): T;
+export declare function withSpan<T>(name: string, fn: () => Promise<T>, options?: BlaxelSpanOptions): Promise<T>;
+export declare function flush(): Promise<void>;
 export {};

package/dist/telemetry/telemetry.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.telemetryRegistry = void 0;
 exports.startSpan = startSpan;
 exports.withSpan = withSpan;
+exports.flush = flush;
 /**
  * No-operation implementation of Span
  */
@@ -22,6 +23,9 @@ class NoopTelemetryProvider {
     startSpan() {
         return new NoopSpan();
     }
+    flush() {
+        return Promise.resolve();
+    }
 }
 /**
  * Registry for managing the global telemetry provider
@@ -58,10 +62,10 @@ exports.telemetryRegistry = TelemetryRegistry.getInstance();
 function startSpan(name, options) {
     return exports.telemetryRegistry.getProvider().startSpan(name, options);
 }
-function withSpan(name, fn, options) {
+async function withSpan(name, fn, options) {
     const span = startSpan(name, options);
     try {
-        const result = fn();
+        const result = await fn();
         span.end();
         return result;
     }
@@ -71,3 +75,6 @@ function withSpan(name, fn, options) {
         throw error;
     }
 }
+async function flush() {
+    await exports.telemetryRegistry.getProvider().flush();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/core",
-  "version": "0.2.4",
+  "version": "0.2.6-dev.74",
   "description": "Blaxel Core SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",