vtb-appit 0.1.13 → 0.1.14

package/appit.js

@@ -4,9 +4,7 @@ const https = require('https');
 const FormData = require('form-data');
 const axios = require('axios');
 require('./tracing');
-const { trace, SpanStatusCode } = require('@opentelemetry/api');
-
-const tracer = trace.getTracer('vtb-appit', '1.0.0');
+const { withTracing, addEvent } = require('./tracing-utils');
 //
 // async function simulateWork() {
 //   return tracer.startActiveSpan('simulate-work', async (span) => {
@@ -87,139 +85,104 @@ class Appit {
         }
     }
 
-    async exec()
-    {
-      return await tracer.startActiveSpan('appit-sync', async (parentSpan) => {
-        try {
-          this.log('info', 'Starting sync process');
-          parentSpan.addEvent('Sync process started');
-          const errors = [];
+    async exec() {
+      return await withTracing('appit-sync', async () => {
+        this.log('info', 'Starting sync process');
+        addEvent('Sync process started');
+        const errors = [];
 
-          await tracer.startActiveSpan('appit-login', async (span) => {
-        try {
-          span.addEvent('Start login');
+        await this.performLogin();
+        if (!this.token) return false;
 
-          if(!await this.login()) {
-            this.log('info', 'Login failed');
-            span.setStatus({ code: SpanStatusCode.ERROR, message: 'Login failed' });
-            return false;
-          } else {
-            this.log('info', 'Login successful');
-            span.addEvent('Login successful');
-            span.setStatus({ code: SpanStatusCode.OK });
+        await this.fetchProfile();
+
+        if(this.options && this.options.tsData) {
+          try {
+            this.transformer.tsData = await this.transformer.tsGetData();
+            this.log('info', 'TS data loaded successfully');
+          } catch(e) {
+            this.log('error', 'Failed to load TS data', e.message);
+            errors.push({ step: 'tsData', error: e.message });
           }
-        } catch (error) {
-          span.recordException(error);
-          span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
-        } finally{
-          span.end();
         }
-      });
-      
-      if(!this.token) return;
-
-      await tracer.startActiveSpan('appit-profile', async (span) => {
-        try {
-          this.transformer.profile = await this.fetchProfile();
-          console.log(this.transformer.profile);
-          this.log('info', 'Profile fetched successfully');
 
-          span.addEvent('Profile fetched successfully');
-          span.setStatus({ code: SpanStatusCode.OK });
-        } catch(error) {
-          span.recordException(error);
-          span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
-        } finally {
-          span.end();
+        if(this.options && this.options.tsDocuments) {
+          try {
+            this.transformer.tsDocuments = await this.transformer.tsGetDocuments();
+            this.log('info', 'TS documents loaded successfully');
+          } catch(e) {
+            this.log('error', 'Failed to load TS documents', e.message);
+            errors.push({ step: 'tsDocuments', error: e.message });
+          }
+        }
+          
+        const steps = [
+          { name: 'excursion', fn: () => this.excursion() },
+          { name: 'labels', fn: () => this.labels() },
+          { name: 'ships', fn: () => this.ships() },
+          { name: 'places', fn: () => this.places() },
+          { name: 'organizations', fn: () => this.organizations() },
+          { name: 'members', fn: () => this.members() },
+          { name: 'travelInfo', fn: () => this.travelInfo() },
+          { name: 'accommodations', fn: () => this.accommodations() },
+          { name: 'destinations', fn: () => this.destinations() },
+          { name: 'schemes', fn: () => this.schemes() },
+          { name: 'flights', fn: () => this.flights() },
+          { name: 'flightImages', fn: () => this.flightImages() },
+          { name: 'contacts', fn: () => this.contacts() },
+          { name: 'documents', fn: () => this.documents() },
+          { name: 'homescreen', fn: () => this.homescreen() },
+          { name: 'menu', fn: () => this.menu() },
+          { name: 'settings', fn: () => this.settings() },
+          { name: 'notifications', fn: () => this.notifications() }
+        ];
+
+        for(const step of steps) {
+          try {
+            this.log('info', `Processing ${step.name}...`);
+            await step.fn();
+            this.log('info', `✓ ${step.name} completed successfully`);
+          } catch(error) {
+            this.log('error', `✗ ${step.name} failed`, error.message);
+            this.saveErrorToHistory(`Step ${step.name} failed`, '', error.message);
+            // Continue with next step instead of failing entirely
+          }
         }
-      });
-
-          if(this.options && this.options.tsData) {
-                try {
-                    this.transformer.tsData = await this.transformer.tsGetData();
-                    this.log('info', 'TS data loaded successfully');
-                } catch(e) {
-                    this.log('error', 'Failed to load TS data', e.message);
-                    errors.push({ step: 'tsData', error: e.message });
-                }
-            }
-
-            if(this.options && this.options.tsDocuments) {
-                try {
-                    this.transformer.tsDocuments = await this.transformer.tsGetDocuments();
-                    this.log('info', 'TS documents loaded successfully');
-                } catch(e) {
-                    this.log('error', 'Failed to load TS documents', e.message);
-                    errors.push({ step: 'tsDocuments', error: e.message });
-                }
-            }
-            
-            const steps = [
-                { name: 'excursion', fn: () => this.excursion() },
-                { name: 'labels', fn: () => this.labels() },
-                { name: 'ships', fn: () => this.ships() },
-                { name: 'places', fn: () => this.places() },
-                { name: 'organizations', fn: () => this.organizations() },
-                { name: 'members', fn: () => this.members() },
-                { name: 'travelInfo', fn: () => this.travelInfo() },
-                { name: 'accommodations', fn: () => this.accommodations() },
-                { name: 'destinations', fn: () => this.destinations() },
-                { name: 'schemes', fn: () => this.schemes() },
-                { name: 'flights', fn: () => this.flights() },
-                { name: 'flightImages', fn: () => this.flightImages() },
-                { name: 'contacts', fn: () => this.contacts() },
-                { name: 'documents', fn: () => this.documents() },
-                { name: 'homescreen', fn: () => this.homescreen() },
-                { name: 'menu', fn: () => this.menu() },
-                { name: 'settings', fn: () => this.settings() },
-                { name: 'notifications', fn: () => this.notifications() }
-            ];
-
-            for(const step of steps) {
-                try {
-                    this.log('info', `Processing ${step.name}...`);
-                    await step.fn();
-                    this.log('info', `✓ ${step.name} completed successfully`);
-                } catch(error) {
-                    this.log('error', `✗ ${step.name} failed`, error.message);
-                    this.saveErrorToHistory(`Step ${step.name} failed`, '', error.message);
-                    // Continue with next step instead of failing entirely
-                }
-            }
 
-            this.history.updatedAt = new Date().getTime();
-            this.history.status = (!this.history.errors || this.history.errors.length === 0) ? 'completed' : 'completed_with_errors';
+        this.history.updatedAt = new Date().getTime();
+        this.history.status = (!this.history.errors || this.history.errors.length === 0) ? 'completed' : 'completed_with_errors';
 
-            fs.writeFileSync(this.historyPath, JSON.stringify(this.history, null, 2));
+        fs.writeFileSync(this.historyPath, JSON.stringify(this.history, null, 2));
             
-            if(errors.length === 0) {
-                this.log('info', 'Sync completed successfully');
-                parentSpan.addEvent('Sync completed successfully');
-                parentSpan.setStatus({ code: SpanStatusCode.OK });
-                return true;
-            } else {
-                this.log('warn', `Sync completed with ${errors.length} errors`, errors);
-                parentSpan.addEvent(`Sync completed with ${errors.length} errors`);
-                parentSpan.setAttributes({ 'sync.errors.count': errors.length });
-                parentSpan.setStatus({ code: SpanStatusCode.OK });
-                return true; // Still return true as we completed what we could
-            }
-            
-        } catch(error) {
-            this.log('error', 'Critical error during sync', error);
-            this.history.status = 'failed';
-            this.history.criticalError = error.message;
-            this.history.updatedAt = new Date().getTime();
-            this.saveHistoryIncremental();
-            parentSpan.recordException(error);
-            parentSpan.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
-            return false;
-        } finally {
-          parentSpan.end();
+        if(errors.length === 0) {
+            this.log('info', 'Sync completed successfully');
+            addEvent('Sync completed successfully');
+            return true;
+        } else {
+            this.log('warn', `Sync completed with ${errors.length} errors`, errors);
+            addEvent(`Sync completed with ${errors.length} errors`);
+            return true; // Still return true as we completed what we could
         }
-      });
+      })();
     }
 
+    performLogin = withTracing('appit-login', async () => {
+      addEvent('Start login');
+      if (!await this.login()) {
+        this.log('info', 'Login failed');
+        throw new Error('Login failed');
+      }
+      this.log('info', 'Login successful');
+      addEvent('Login successful');
+    });
+
+    fetchProfile = withTracing('appit-profile', async () => {
+      this.transformer.profile = await this.fetchProfile();
+      console.log(this.transformer.profile);
+      this.log('info', 'Profile fetched successfully');
+      addEvent('Profile fetched successfully');
+    });
+
     async labels()
     {
         const labels = this.transformer.labels();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vtb-appit",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "",
   "main": "index.js",
   "scripts": {},

package/tracing-utils.js

@@ -0,0 +1,46 @@
+const { trace, SpanStatusCode } = require('@opentelemetry/api');
+
+const tracer = trace.getTracer('vtb-appit', '1.0.0');
+
+/**
+ * Wraps an async function with tracing
+ * @param {string} spanName - Name of the span
+ * @param {Function} fn - Async function to wrap
+ * @param {Object} attributes - Optional attributes to add to span
+ * @returns {Function} Wrapped function
+ */
+function withTracing(spanName, fn, attributes = {}) {
+  return async (...args) => {
+    return await tracer.startActiveSpan(spanName, async (span) => {
+      try {
+        if (Object.keys(attributes).length > 0) {
+          span.setAttributes(attributes);
+        }
+        
+        const result = await fn(...args);
+        span.setStatus({ code: SpanStatusCode.OK });
+        return result;
+      } catch (error) {
+        span.recordException(error);
+        span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+        throw error;
+      } finally {
+        span.end();
+      }
+    });
+  };
+}
+
+/**
+ * Adds an event to the current active span
+ * @param {string} message - Event message
+ * @param {Object} attributes - Optional attributes
+ */
+function addEvent(message, attributes = {}) {
+  const span = trace.getActiveSpan();
+  if (span) {
+    span.addEvent(message, attributes);
+  }
+}
+
+module.exports = { withTracing, addEvent, tracer };