[backend] remove @opentelemetry/semantic-conventions dependancy

opencti-platform/opencti-graphql/package.json

@@ -72,7 +72,6 @@
     "@opentelemetry/sdk-node": "0.53.0",
     "@opentelemetry/sdk-trace-base": "1.26.0",
     "@opentelemetry/sdk-trace-node": "1.26.0",
-    "@opentelemetry/semantic-conventions": "1.27.0",
     "ajv": "8.17.1",
     "amqplib": "0.10.4",
     "antlr4": "4.13.2",

opencti-platform/opencti-graphql/src/back.js

@@ -13,17 +13,17 @@ import './manager/index';
 // import tracing
 import './config/tracing';
 // endregion
-import { SEMRESATTRS_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
 import { platformStart } from './boot';
 import { ENABLED_EVENT_LOOP_MONITORING, ENABLED_TRACING, logApp } from './config/conf';
 import { isNotEmptyField } from './database/utils';
+import { TELEMETRY_SERVICE_NAME } from './utils/telemetry-attributes';
 
 // -- Apply telemetry
 // ------- Tracing
 if (ENABLED_TRACING) {
   const provider = new NodeTracerProvider({
     resource: Resource.default().merge(new Resource({
-      [SEMRESATTRS_SERVICE_NAME]: 'opencti-platform',
+      [TELEMETRY_SERVICE_NAME]: 'opencti-platform',
     })),
   });
   // OTLP - JAEGER ...

opencti-platform/opencti-graphql/src/config/tracing.ts

@@ -1,4 +1,3 @@
-import { SEMATTRS_ENDUSER_ID } from '@opentelemetry/semantic-conventions';
 import { MeterProvider, MetricReader, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics';
 import { ValueType } from '@opentelemetry/api-metrics';
 import type { Counter } from '@opentelemetry/api-metrics/build/src/types/Metric';
@@ -12,6 +11,7 @@ import type { Gauge } from '@opentelemetry/api/build/src/metrics/Metric';
 import type { AuthContext, AuthUser } from '../types/user';
 import { ENABLED_METRICS, ENABLED_TRACING } from './conf';
 import { isNotEmptyField } from '../database/utils';
+import { TELEMETRY_ENDUSER_ID } from '../utils/telemetry-attributes';
 
 class MeterManager {
   meterProvider: MeterProvider;
@@ -114,7 +114,7 @@ export const telemetry = (context: AuthContext, user: AuthUser, spanName: string
   const tracingSpan = tracer.startSpan(spanName, {
     attributes: {
       'enduser.type': context.source,
-      [SEMATTRS_ENDUSER_ID]: user.id,
+      [TELEMETRY_ENDUSER_ID]: user.id,
       ...attrs
     },
     kind: 2 }, ctx);

opencti-platform/opencti-graphql/src/database/cache.ts

@@ -1,4 +1,3 @@
-import { SEMATTRS_DB_NAME, SEMATTRS_DB_OPERATION } from '@opentelemetry/semantic-conventions';
 import type { BasicStoreIdentifier, StoreEntity, StoreRelation } from '../types/store';
 import { logApp } from '../config/conf';
 import { UnsupportedError } from '../config/errors';
@@ -12,6 +11,7 @@ import { convertStoreToStix } from './stix-converter';
 import { ENTITY_TYPE_PLAYBOOK } from '../modules/playbook/playbook-types';
 import { type BasicStoreEntityPublicDashboard, ENTITY_TYPE_PUBLIC_DASHBOARD } from '../modules/publicDashboard/publicDashboard-types';
 import { wait } from './utils';
+import { TELEMETRY_DB_NAME, TELEMETRY_DB_OPERATION } from '../utils/telemetry-attributes';
 
 const STORE_ENTITIES_LINKS: Record<string, string[]> = {
   // Filters must be reset depending on stream and triggers modifications
@@ -101,8 +101,8 @@ const getEntitiesFromCache = async <T extends BasicStoreIdentifier | StixObject>
     return fromCache.values ?? (type === ENTITY_TYPE_RESOLVED_FILTERS ? new Map() : []);
   };
   return telemetry(context, user, `CACHE ${type}`, {
-    [SEMATTRS_DB_NAME]: 'cache_engine',
-    [SEMATTRS_DB_OPERATION]: 'select',
+    [TELEMETRY_DB_NAME]: 'cache_engine',
+    [TELEMETRY_DB_OPERATION]: 'select',
   }, getEntitiesFromCacheFn);
 };
 

opencti-platform/opencti-graphql/src/database/engine.js

@@ -8,7 +8,6 @@ import { AwsSigv4Signer } from '@opensearch-project/opensearch/aws';
 import { Promise as BluePromise } from 'bluebird';
 import * as R from 'ramda';
 import semver from 'semver';
-import { SEMATTRS_DB_NAME, SEMATTRS_DB_OPERATION, SEMATTRS_DB_STATEMENT } from '@opentelemetry/semantic-conventions';
 import * as jsonpatch from 'fast-json-patch';
 import {
   buildPagination,
@@ -165,6 +164,7 @@ import { ENTITY_TYPE_DELETE_OPERATION } from '../modules/deleteOperation/deleteO
 import { buildEntityData } from './data-builder';
 import { controlUserConfidenceAgainstElement } from '../utils/confidence-level';
 import { enrichWithRemoteCredentials } from '../config/credentials';
+import { TELEMETRY_DB_NAME, TELEMETRY_DB_OPERATION, TELEMETRY_DB_STATEMENT } from '../utils/telemetry-attributes';
 import { isStixCyberObservable } from '../schema/stixCyberObservable';
 
 const ELK_ENGINE = 'elk';
@@ -352,9 +352,9 @@ export const elRawSearch = (context, user, types, query) => {
     return parsedSearch;
   });
   return telemetry(context, user, `SELECT ${Array.isArray(types) ? types.join(', ') : (types || 'None')}`, {
-    [SEMATTRS_DB_NAME]: 'search_engine',
-    [SEMATTRS_DB_OPERATION]: 'read',
-    [SEMATTRS_DB_STATEMENT]: JSON.stringify(query),
+    [TELEMETRY_DB_NAME]: 'search_engine',
+    [TELEMETRY_DB_OPERATION]: 'read',
+    [TELEMETRY_DB_STATEMENT]: JSON.stringify(query),
   }, elRawSearchFn);
 };
 export const elRawDeleteByQuery = (query) => engine.deleteByQuery(query).then((r) => oebp(r));
@@ -3879,8 +3879,8 @@ export const elIndexElements = async (context, user, indexingType, elements) =>
     return transformedElements.length;
   };
   return telemetry(context, user, `INSERT ${indexingType}`, {
-    [SEMATTRS_DB_NAME]: 'search_engine',
-    [SEMATTRS_DB_OPERATION]: 'insert',
+    [TELEMETRY_DB_NAME]: 'search_engine',
+    [TELEMETRY_DB_OPERATION]: 'insert',
   }, elIndexElementsFn);
 };
 

opencti-platform/opencti-graphql/src/database/middleware.js

@@ -3,7 +3,6 @@ import * as R from 'ramda';
 import DataLoader from 'dataloader';
 import { Promise } from 'bluebird';
 import { compareUnsorted } from 'js-deep-equals';
-import { SEMATTRS_DB_NAME, SEMATTRS_DB_OPERATION } from '@opentelemetry/semantic-conventions';
 import * as jsonpatch from 'fast-json-patch';
 import {
   ALREADY_DELETED_ERROR,
@@ -203,6 +202,7 @@ import {
 import { buildEntityData, buildInnerRelation, buildRelationData } from './data-builder';
 import { deleteAllObjectFiles, moveAllFilesFromEntityToAnother, uploadToStorage } from './file-storage-helper';
 import { storeFileConverter } from './file-storage';
+import { TELEMETRY_DB_NAME, TELEMETRY_DB_OPERATION } from '../utils/telemetry-attributes';
 
 // region global variables
 const MAX_BATCH_SIZE = 300;
@@ -815,8 +815,8 @@ const inputResolveRefs = async (context, user, input, type, entitySetting) => {
     return inputResolved;
   };
   return telemetry(context, user, `INPUTS RESOLVE ${type}`, {
-    [SEMATTRS_DB_NAME]: 'middleware',
-    [SEMATTRS_DB_OPERATION]: 'resolver',
+    [TELEMETRY_DB_NAME]: 'middleware',
+    [TELEMETRY_DB_OPERATION]: 'resolver',
   }, inputResolveRefsFn);
 };
 const isRelationTargetGrants = (elementGrants, relation, type) => {

opencti-platform/opencti-graphql/src/database/rabbitmq.js

@@ -1,13 +1,13 @@
 import amqp from 'amqplib/callback_api';
 import util from 'util';
-import { SEMATTRS_DB_NAME, SEMATTRS_DB_OPERATION } from '@opentelemetry/semantic-conventions';
 import { LRUCache } from 'lru-cache';
 import conf, { booleanConf, configureCA, loadCert, logApp } from '../config/conf';
 import { DatabaseError } from '../config/errors';
 import { SYSTEM_USER } from '../utils/access';
 import { telemetry } from '../config/tracing';
 import { isEmptyField, RABBIT_QUEUE_PREFIX } from './utils';
 import { getHttpClient } from '../utils/http-client';
+import { TELEMETRY_DB_NAME, TELEMETRY_DB_OPERATION } from '../utils/telemetry-attributes';
 import { listEntities } from './middleware-loader';
 import { ENTITY_TYPE_CONNECTOR } from '../schema/internalObject';
 
@@ -171,8 +171,8 @@ export const metrics = async (context, user) => {
     return { overview, consumers, queues: platformQueues };
   };
   return telemetry(context, user, 'QUEUE metrics', {
-    [SEMATTRS_DB_NAME]: 'messaging_engine',
-    [SEMATTRS_DB_OPERATION]: 'metrics',
+    [TELEMETRY_DB_NAME]: 'messaging_engine',
+    [TELEMETRY_DB_OPERATION]: 'metrics',
   }, metricApi);
 };
 

opencti-platform/opencti-graphql/src/database/redis.ts

@@ -1,4 +1,3 @@
-import { SEMATTRS_DB_NAME } from '@opentelemetry/semantic-conventions';
 import Redis, { Cluster, type RedisOptions, type SentinelAddress } from 'ioredis';
 import Redlock from 'redlock';
 import * as jsonpatch from 'fast-json-patch';
@@ -26,6 +25,7 @@ import type { ExecutionEnvelop } from '../manager/playbookManager';
 import { generateCreateMessage, generateDeleteMessage, generateMergeMessage, generateRestoreMessage } from './generate-message';
 import { INPUT_OBJECTS } from '../schema/general';
 import { enrichWithRemoteCredentials } from '../config/credentials';
+import { TELEMETRY_DB_NAME } from '../utils/telemetry-attributes';
 
 const USE_SSL = booleanConf('redis:use_ssl', false);
 const REDIS_CA = conf.get('redis:ca').map((path: string) => loadCert(path));
@@ -461,7 +461,7 @@ const pushToStream = async (context: AuthContext, user: AuthUser, client: Cluste
       }
     };
     telemetry(context, user, 'INSERT STREAM', {
-      [SEMATTRS_DB_NAME]: 'stream_engine',
+      [TELEMETRY_DB_NAME]: 'stream_engine',
     }, pushToStreamFn);
   }
 };

opencti-platform/opencti-graphql/src/domain/file.js

@@ -1,6 +1,5 @@
 import * as R from 'ramda';
 import { Readable } from 'stream';
-import { SEMATTRS_DB_NAME, SEMATTRS_DB_OPERATION } from '@opentelemetry/semantic-conventions';
 import { logApp } from '../config/conf';
 import { deleteFile, loadFile, uploadJobImport } from '../database/file-storage';
 import { internalLoadById, listAllEntities } from '../database/middleware-loader';
@@ -22,6 +21,7 @@ import { ENTITY_TYPE_MARKING_DEFINITION } from '../schema/stixMetaObject';
 import { FilterMode, OrderingMode } from '../generated/graphql';
 import { telemetry } from '../config/tracing';
 import { ENTITY_TYPE_WORK } from '../schema/internalObject';
+import { TELEMETRY_DB_NAME, TELEMETRY_DB_OPERATION } from '../utils/telemetry-attributes';
 
 export const buildOptionsFromFileManager = async (context) => {
   let importPaths = ['import/'];
@@ -217,7 +217,7 @@ export const batchFileWorks = async (context, user, files) => {
     return files.map((fileId) => items.filter(({ event_source_id }) => event_source_id === fileId));
   };
   return telemetry(context, user, 'BATCH works for file', {
-    [SEMATTRS_DB_NAME]: 'file_domain',
-    [SEMATTRS_DB_OPERATION]: 'read',
+    [TELEMETRY_DB_NAME]: 'file_domain',
+    [TELEMETRY_DB_OPERATION]: 'read',
   }, getWorkForFileFn);
 };

opencti-platform/opencti-graphql/src/domain/status.ts

@@ -1,4 +1,3 @@
-import { SEMATTRS_DB_NAME, SEMATTRS_DB_OPERATION } from '@opentelemetry/semantic-conventions';
 import * as R from 'ramda';
 import { ENTITY_TYPE_STATUS, ENTITY_TYPE_STATUS_TEMPLATE } from '../schema/internalObject';
 import { createEntity, deleteElementById, internalDeleteElementById, updateAttribute } from '../database/middleware';
@@ -27,6 +26,7 @@ import { elCount } from '../database/engine';
 import { publishUserAction } from '../listener/UserActionListener';
 import { validateSetting } from '../modules/entitySetting/entitySetting-validators';
 import { telemetry } from '../config/tracing';
+import { TELEMETRY_DB_NAME, TELEMETRY_DB_OPERATION } from '../utils/telemetry-attributes';
 
 export const findTemplateById = (context: AuthContext, user: AuthUser, statusTemplateId: string): StatusTemplate => {
   return storeLoadById(context, user, statusTemplateId, ENTITY_TYPE_STATUS_TEMPLATE) as unknown as StatusTemplate;
@@ -60,8 +60,8 @@ export const getTypeStatuses = async (context: AuthContext, user: AuthUser, type
     return findAll(context, user, args);
   };
   return telemetry(context, user, 'QUERY type statuses', {
-    [SEMATTRS_DB_NAME]: 'statuses_domain',
-    [SEMATTRS_DB_OPERATION]: 'read',
+    [TELEMETRY_DB_NAME]: 'statuses_domain',
+    [TELEMETRY_DB_OPERATION]: 'read',
   }, getTypeStatusesFn);
 };
 export const batchStatusesByType = async (context: AuthContext, user: AuthUser, types: string[]) => {
@@ -81,8 +81,8 @@ export const batchStatusesByType = async (context: AuthContext, user: AuthUser,
     return types.map((type) => statusesGrouped[type] || []);
   };
   return telemetry(context, user, 'BATCH type statuses', {
-    [SEMATTRS_DB_NAME]: 'statuses_domain',
-    [SEMATTRS_DB_OPERATION]: 'read',
+    [TELEMETRY_DB_NAME]: 'statuses_domain',
+    [TELEMETRY_DB_OPERATION]: 'read',
   }, batchStatusesByTypeFn);
 };
 export const createStatusTemplate = async (context: AuthContext, user: AuthUser, input: StatusTemplateAddInput) => {

opencti-platform/opencti-graphql/src/domain/subType.ts

@@ -1,5 +1,4 @@
 import * as R from 'ramda';
-import { SEMATTRS_DB_NAME, SEMATTRS_DB_OPERATION } from '@opentelemetry/semantic-conventions';
 import { ABSTRACT_STIX_CORE_RELATIONSHIP, ABSTRACT_STIX_CYBER_OBSERVABLE, ABSTRACT_STIX_DOMAIN_OBJECT } from '../schema/general';
 import { STIX_SIGHTING_RELATIONSHIP } from '../schema/stixSightingRelationship';
 import { buildPagination } from '../database/utils';
@@ -11,6 +10,7 @@ import { ENTITY_HASHED_OBSERVABLE_ARTIFACT } from '../schema/stixCyberObservable
 import { telemetry } from '../config/tracing';
 import type { AuthContext, AuthUser } from '../types/user';
 import { ENTITY_TYPE_EXTERNAL_REFERENCE } from '../schema/stixMetaObject';
+import { TELEMETRY_DB_NAME, TELEMETRY_DB_OPERATION } from '../utils/telemetry-attributes';
 
 // -- ENTITY TYPES --
 
@@ -32,8 +32,8 @@ export const queryDefaultSubTypes = async (context: AuthContext, user: AuthUser,
   };
 
   return telemetry(context, user, 'QUERY default subtypes', {
-    [SEMATTRS_DB_NAME]: 'subtypes_domain',
-    [SEMATTRS_DB_OPERATION]: 'read',
+    [TELEMETRY_DB_NAME]: 'subtypes_domain',
+    [TELEMETRY_DB_OPERATION]: 'read',
   }, queryDefaultSubTypesFn);
 };
 

opencti-platform/opencti-graphql/src/graphql/telemetryPlugin.js

@@ -1,8 +1,8 @@
 import { head, includes } from 'ramda';
-import { SEMATTRS_DB_OPERATION, SEMATTRS_ENDUSER_ID, SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES } from '@opentelemetry/semantic-conventions';
 import { meterManager } from '../config/tracing';
 import { AUTH_FAILURE, AUTH_REQUIRED, FORBIDDEN_ACCESS } from '../config/errors';
 import { isEmptyField } from '../database/utils';
+import { TELEMETRY_DB_OPERATION, TELEMETRY_ENDUSER_ID, TELEMETRY_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES } from '../utils/telemetry-attributes';
 
 const getRequestError = (context) => {
   const isSuccess = isEmptyField(context.errors) || context.errors.length === 0;
@@ -32,8 +32,8 @@ export default {
         tracingSpan = context.tracing.getTracer().startSpan(`${operationType} ${resolveContext.operationName}`, {
           attributes: {
             'enduser.type': context.source,
-            [SEMATTRS_DB_OPERATION]: operationType,
-            [SEMATTRS_ENDUSER_ID]: endUserId,
+            [TELEMETRY_DB_OPERATION]: operationType,
+            [TELEMETRY_ENDUSER_ID]: endUserId,
           },
           kind: 1,
         });
@@ -44,7 +44,7 @@ export default {
         const payloadSize = Buffer.byteLength(JSON.stringify(sendContext.request.variables || {}));
         // Tracing span can be null for invalid operations
         if (tracingSpan) {
-          tracingSpan.setAttribute(SEMATTRS_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES, payloadSize);
+          tracingSpan.setAttribute(TELEMETRY_MESSAGING_MESSAGE_PAYLOAD_COMPRESSED_SIZE_BYTES, payloadSize);
         }
         if (requestError) {
           const operation = sendContext.request.query.startsWith('mutation') ? 'mutation' : 'query';

opencti-platform/opencti-graphql/src/manager/telemetryManager.ts

@@ -1,6 +1,4 @@
 import { Resource } from '@opentelemetry/resources';
-import { SEMRESATTRS_SERVICE_NAME, SEMRESATTRS_SERVICE_VERSION } from '@opentelemetry/semantic-conventions';
-import { SEMRESATTRS_SERVICE_INSTANCE_ID } from '@opentelemetry/semantic-conventions/build/src/resource/SemanticResourceAttributes';
 import { ConsoleMetricExporter, InstrumentType, MeterProvider } from '@opentelemetry/sdk-metrics';
 import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-http';
 import { AggregationTemporality } from '@opentelemetry/sdk-metrics/build/src/export/AggregationTemporality';
@@ -94,9 +92,9 @@ const telemetryInitializer = async (): Promise<HandlerInput> => {
   const settings = await getSettings(context) as Settings;
   const platformId = settings.id;
   const filigranResource = new Resource({
-    [SEMRESATTRS_SERVICE_NAME]: TELEMETRY_SERVICE_NAME,
-    [SEMRESATTRS_SERVICE_VERSION]: PLATFORM_VERSION,
-    [SEMRESATTRS_SERVICE_INSTANCE_ID]: platformId,
+    'service.name': TELEMETRY_SERVICE_NAME,
+    'service.version': PLATFORM_VERSION,
+    'service.instance.id': platformId,
     'service.instance.creation': settings.created_at
   });
   const resource = Resource.default().merge(filigranResource);

opencti-platform/opencti-graphql/src/modules/entitySetting/entitySetting-attributeUtils.ts

@@ -1,4 +1,3 @@
-import { SEMATTRS_DB_NAME, SEMATTRS_DB_OPERATION } from '@opentelemetry/semantic-conventions';
 import type { AuthContext, AuthUser } from '../../types/user';
 import type { BasicStoreEntityEntitySetting } from './entitySetting-types';
 import { defaultScale, type EntitySettingSchemaAttribute, getAttributesConfiguration } from './entitySetting-utils';
@@ -10,6 +9,7 @@ import { isNotEmptyField } from '../../database/utils';
 import { internalFindByIdsMapped } from '../../database/middleware-loader';
 import { extractRepresentative } from '../../database/entity-representative';
 import { isUserHasCapability, KNOWLEDGE_KNUPDATE_KNBYPASSFIELDS } from '../../utils/access';
+import { TELEMETRY_DB_NAME, TELEMETRY_DB_OPERATION } from '../../utils/telemetry-attributes';
 
 // ==================================================================
 // Need a specific utils file to those functions because
@@ -25,8 +25,8 @@ export const getEntitySettingSchemaAttributes = async (
   entitySetting: BasicStoreEntityEntitySetting
 ): Promise<EntitySettingSchemaAttribute[]> => {
   return telemetry(context, user, 'ATTRIBUTES', {
-    [SEMATTRS_DB_NAME]: 'attributes_domain',
-    [SEMATTRS_DB_OPERATION]: 'attributes_definition',
+    [TELEMETRY_DB_NAME]: 'attributes_domain',
+    [TELEMETRY_DB_OPERATION]: 'attributes_definition',
   }, async () => {
     if (!entitySetting) {
       return [];

opencti-platform/opencti-graphql/src/modules/entitySetting/entitySetting-domain.ts

@@ -1,4 +1,3 @@
-import { SEMATTRS_DB_NAME, SEMATTRS_DB_OPERATION } from '@opentelemetry/semantic-conventions';
 import type { AuthContext, AuthUser } from '../../types/user';
 import { createEntity, loadEntity, updateAttribute } from '../../database/middleware';
 import type { BasicStoreEntityEntitySetting } from './entitySetting-types';
@@ -18,6 +17,7 @@ import { containsValidAdmin } from '../../utils/authorizedMembers';
 import { FunctionalError } from '../../config/errors';
 import { getEntitySettingSchemaAttributes, getMandatoryAttributesForSetting } from './entitySetting-attributeUtils';
 import { schemaOverviewLayoutCustomization } from '../../schema/schema-overviewLayoutCustomization';
+import { TELEMETRY_DB_NAME, TELEMETRY_DB_OPERATION } from '../../utils/telemetry-attributes';
 
 // -- LOADING --
 
@@ -36,8 +36,8 @@ export const findByType = async (context: AuthContext, user: AuthUser, targetTyp
     });
   };
   return telemetry(context, user, 'QUERY entitySetting', {
-    [SEMATTRS_DB_NAME]: 'entitySetting_domain',
-    [SEMATTRS_DB_OPERATION]: 'read',
+    [TELEMETRY_DB_NAME]: 'entitySetting_domain',
+    [TELEMETRY_DB_OPERATION]: 'read',
   }, findByTypeFn);
 };
 
@@ -54,8 +54,8 @@ export const batchEntitySettingsByType = async (context: AuthContext, user: Auth
     return targetTypes.map((targetType) => entitySettings.find((entitySetting) => entitySetting.target_type === targetType));
   };
   return telemetry(context, user, 'BATCH entitySettings', {
-    [SEMATTRS_DB_NAME]: 'entitySetting_domain',
-    [SEMATTRS_DB_OPERATION]: 'read',
+    [TELEMETRY_DB_NAME]: 'entitySetting_domain',
+    [TELEMETRY_DB_OPERATION]: 'read',
   }, findByTypeFn);
 };