add logging

src/app/services/monitoring/opentelemetry/logging.ts

@@ -0,0 +1,26 @@
+import { Injectable } from "@angular/core";
+import { v4 as uuidv4 } from 'uuid';
+import { WebSocketGraylogService } from "../socket/socket";
+import { Span } from "@opentelemetry/sdk-trace-web";
+
+
+export class OpenTelemetryLogging {
+
+  socket = new WebSocketGraylogService()
+
+  constructor() {
+    this.socket.start()
+  }
+
+  send(data: Object & { type: string; payload: any, spanContext:any }): void {
+    this.socket.send({
+      type: data.type,
+      payload: data.payload,
+      requestId: uuidv4(),
+      spanContext: data.spanContext
+    });
+  }
+
+}
+
+export const openTelemetryLogging = new OpenTelemetryLogging()

src/app/services/monitoring/opentelemetry/matrix.ts

@@ -1,6 +1,8 @@
 import { metrics } from '@opentelemetry/api';
 import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
 import { MeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
+import { Subject } from 'rxjs';
+import { throttleTime } from 'rxjs/operators';
 import { environment } from 'src/environments/environment';
 
 // Initialize OpenTelemetry metrics
@@ -10,15 +12,28 @@ metrics.setGlobalMeterProvider(meterProvider);
 if (window.location.protocol !== 'https:' && environment.apiURL != 'https://gdqas-api.oapr.gov.ao/api/') {
   const metricReader = new PeriodicExportingMetricReader({
     exporter: new OTLPMetricExporter({
-      url: 'http://5-180-182-151.cloud-xip.com:4318/v1/metrics',
+      url: 'https://5-180-182-151.cloud-xip.com:85/collector2/v1/metrics',
       // headers: {
       //   'Authorization': 'Basic ' + btoa('tabteste@006:tabteste@006'),
       // }
     }),
-    exportIntervalMillis: 3000,
+    exportIntervalMillis: 30000,
   });
 
   meterProvider.addMetricReader(metricReader);
+
+  const subject = new Subject()
+
+  subject
+  .pipe(
+    throttleTime(5000) // 5000 milliseconds = 5 seconds
+  )
+  .subscribe(() => {
+    metricReader.forceFlush().then(() => {
+      console.log('Metrics exported');
+    });
+  });
+
 }
 export const meter = meterProvider.getMeter('example-exporter-collector');
 export const RequestCounter = meter.createCounter('post_requests', {

src/app/services/monitoring/opentelemetry/opentelemetry.ts

@@ -3,6 +3,8 @@ import { WebTracerProvider } from '@opentelemetry/sdk-trace-web';
 import { ZipkinExporter } from '@opentelemetry/exporter-zipkin';
 import { SemanticResourceAttributes } from '@opentelemetry/semantic-conventions'
 import { Resource } from '@opentelemetry/resources';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-otlp-http';
+import { context, trace, propagation } from '@opentelemetry/api';
 
 function createProvider(serviceName) {
   const provider = new WebTracerProvider({
@@ -32,3 +34,54 @@ export const OpentelemetryAgendaProvider = createProvider('FO-agenda-service');
 export const OpentelemetryNotificationProvider = createProvider('FO-notification');
 export const OpentelemetryInterceptorProvider = createProvider('FO-interceptor');
 export const OpentelemetryPublicationProvider = createProvider('FO-publication-service');
+export const OpentelemetryLogging = createProvider('logging');
+
+const tracerInstance = OpentelemetryAgendaProvider.getTracer('example-tracer-hole', '111', {})
+
+
+function parentSpanExample() {
+  // Create a tracer instance
+  const tracer = trace.getTracer('FO-chat-service');
+
+  // Start a parent span
+  const parentSpan = tracer.startSpan('parent-span');
+  parentSpan.setAttribute('key', 'value')
+
+  const traceId = parentSpan.spanContext().traceId;
+  const spanId = parentSpan.spanContext().spanId;
+  parentSpan.end();  // End the parent span
+
+  const spanContext = {
+    traceId: traceId,
+    spanId: spanId,
+    traceFlags: 1 // 1 means the trace is sampled
+  };
+
+  // Create a new context with the parent span
+  const parentContext = trace.setSpan(context.active(), parentSpan);
+  const parentContext1 = trace.setSpan(context.active(), trace.wrapSpanContext(spanContext));
+
+  // Start a new child span
+  const childSpan = tracer.startSpan('child-span1', {root: false}, parentContext1);
+  childSpan.end();
+
+  // Simulate some work
+  setTimeout(() => {
+    childSpanExample(parentContext);  // Pass the context to child span
+
+  }, 500);
+}
+
+
+function childSpanExample(parentContext) {
+  // Create a new child span with the parent context
+  const tracer = trace.getTracer('FO-chat-service');
+  const childSpan = tracer.startSpan('child-span', undefined, parentContext);
+
+  // Simulate some work
+  setTimeout(() => {
+    childSpan.end();  // End the child span
+  }, 500);
+}
+
+parentSpanExample()

src/app/services/monitoring/opentelemetry/tracer.ts

@@ -1,11 +1,12 @@
 import { v4 as uuidv4 } from 'uuid';
 import { SemanticAttributes } from '@opentelemetry/semantic-conventions';
 import { Tracer, Span } from '@opentelemetry/sdk-trace-base';
-import { OpentelemetryAgendaProvider, OpentelemetryInterceptorProvider, OpentelemetryNotificationProvider } from './opentelemetry';
+import { OpentelemetryAgendaProvider, OpentelemetryInterceptorProvider, OpentelemetryLogging, OpentelemetryNotificationProvider } from './opentelemetry';
 import { Device, DeviceInfo } from '@capacitor/device';
 import { SessionStore } from 'src/app/store/session.service';
 import { environment } from 'src/environments/environment';
 import { UseCaseCounter } from './matrix';
+import { openTelemetryLogging } from './logging';
 // import { context, propagation } from '@opentelemetry/api';
 
 const tracerInstance = OpentelemetryAgendaProvider.getTracer('example-tracer-hole', '111', {})
@@ -18,6 +19,24 @@ Device.getInfo().then(e => {
   device = e
 });
 
+function convertAttributesToString(obj) {
+  const result = {};
+
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      if (typeof obj[key] === 'object' && obj[key] !== null) {
+        // Convert only the object attribute to string
+        result[key] = JSON.stringify(obj[key], null, 2);
+      } else {
+        // Convert primitive values to string
+        result[key] = String(obj[key]);
+      }
+    }
+  }
+
+  return result;
+}
+
 
 const createTracingInstance = ({bugPrint, name, module, autoFinish}): TracingType => {
   const requestId = uuidv4()
@@ -31,7 +50,6 @@ const createTracingInstance = ({bugPrint, name, module, autoFinish}): TracingTyp
   }
 
   const span = _tracerInstance.startSpan(name);
-  let hasBug:Boolean
 
   const data = {
     event: {},
@@ -64,6 +82,28 @@ const createTracingInstance = ({bugPrint, name, module, autoFinish}): TracingTyp
         span.setAttribute('error', 'true')
       }
     },
+    log(message: string, data: Object) {
+      const spanId = span.spanContext().spanId;
+      const _tracer = OpentelemetryLogging.getTracer('logging')
+      const spanContext = _tracer.startSpan(name)
+
+      data = convertAttributesToString(data)
+      openTelemetryLogging.send({
+        type: 'graylog',
+        spanContext,
+        payload: {
+          message: message,
+          object: {
+            ...data,
+            spanId,
+            name,
+            user:  SessionStore?.user?.FullName,
+            device_name: device?.name || device?.model,
+            commit_date: environment.version.lastCommitTime,
+          }
+        }
+      })
+    },
     getAttribute: (key: string) => {
       return data.tags[key]
     },
@@ -77,9 +117,7 @@ const createTracingInstance = ({bugPrint, name, module, autoFinish}): TracingTyp
         console.error(name, data)
       }
     },
-    bugFlag:() => {
-      hasBug = true
-    },
+    bugFlag:() => {},
     createSpan: (name, parent?: any) => {
       return tracerInstance.startSpan(name, { root: false }, parent) as Span;
     }
@@ -177,7 +215,7 @@ export type TracingType = {
   attributes: typeof SemanticAttributes;
   // axios: (config?: AxiosRequestConfig) => AxiosInstance;
   setStatus: (status: any) => void;
-  //logEvent: (name: string, attributesOrStartTime?: AttributeValue | TimeInput) => void;
+  log: (message: string, data: Object) => void;
   addEvent: (context: string, message?: any, obj?: any)  => void;
   setAttribute: (key: string, value: string) => void;
   getAttribute: (key: string) => string;

src/app/services/monitoring/socket/socket.ts

@@ -0,0 +1,59 @@
+
+import { Injectable } from '@angular/core';
+import { v4 as uuidv4 } from 'uuid';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class WebSocketGraylogService {
+  private adminSocketGlobal!: WebSocket;
+  connected = false
+
+  constructor() { }
+
+  connect(): void {
+    this.adminSocketGlobal = new WebSocket('wss://5-180-182-151.cloud-xip.com:85/ws/');
+
+    this.adminSocketGlobal.onopen = () => {
+      console.log('Admin WebSocket is open now.');
+      this.adminSocketGlobal.send("uuid");
+      this.connected = true
+    };
+
+    this.adminSocketGlobal.onmessage = async (event: MessageEvent) => {
+      // Handle incoming messages here
+    };
+
+    this.adminSocketGlobal.onclose = () => {
+      console.log('Admin WebSocket is closed now.');
+      this.connect();
+    };
+
+    this.adminSocketGlobal.onerror = (error: Event) => {
+      console.error('Admin WebSocket error:', error);
+    };
+  }
+
+  send(data: Object & { type: string; payload: Object , requestId: string, spanContext:any }): void {
+    if (this.adminSocketGlobal.readyState === WebSocket.OPEN) {
+
+      this.adminSocketGlobal.send(JSON.stringify({
+        type: data.type ,
+        payload: data.payload,
+        requestId: data.requestId,
+        parentSpan: {
+          traceId: data.spanContext.spanContext().traceId,
+          spanId: data.spanContext.spanContext().spanId,
+        }
+      }));
+
+      // data.spanContext.end()
+    } else {
+      console.warn('WebSocket is not open. Message not sent.');
+    }
+  }
+
+  start(): void {
+    this.connect();
+  }
+}