@depup/dd-trace 5.90.0-depup.0

package/packages/datadog-plugin-google-cloud-pubsub/src/consumer.js

@@ -0,0 +1,212 @@
+'use strict'
+
+const { getMessageSize } = require('../../dd-trace/src/datastreams')
+const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
+const SpanContext = require('../../dd-trace/src/opentracing/span_context')
+const id = require('../../dd-trace/src/id')
+const { storage } = require('../../datadog-core')
+
+/**
+ * PULL SUBSCRIPTION: Service explicitly pulls messages from Pub/Sub and processes them.
+ * Async context storage for linking acknowledge() API calls back to original message spans.
+ *
+ * Problem: message.ack() is often called asynchronously outside the original handler,
+ * losing async context. The acknowledge() API only receives ackIds (strings), not Messages.
+ *
+ * Solution: Store context by Message (WeakMap), lookup by ackId (Map<ackId, WeakRef<Message>>).
+ * WeakRef allows Messages to be GC'd even if never acknowledged (network failures, crashes).
+ */
+const messageToContext = new WeakMap() // Message -> context (auto-cleanup on GC)
+const ackIdToMessage = new Map() // ackId -> WeakRef<Message> (needs cleanup)
+
+const ackMapCleanup = new FinalizationRegistry((ackId) => {
+  ackIdToMessage.delete(ackId) // Remove orphaned ackId when Message is GC'd
+})
+
+class GoogleCloudPubsubConsumerPlugin extends ConsumerPlugin {
+  static id = 'google-cloud-pubsub'
+  static operation = 'receive'
+
+  constructor (...args) {
+    super(...args)
+
+    /**
+     * Channel: message:ack-store
+     * When message.ack() is called, capture and store the current async context.
+     * Use WeakRef to allow Message GC even if never acknowledged.
+     */
+    this.addSub('apm:google-cloud-pubsub:message:ack-store', (ctx) => {
+      const { message, ackId } = ctx
+      const currentStore = storage('legacy').getStore()
+
+      if (currentStore) {
+        messageToContext.set(message, currentStore)
+        ackIdToMessage.set(ackId, new WeakRef(message))
+        ackMapCleanup.register(message, ackId, message)
+      }
+    })
+
+    /**
+     * Channel: message:ack-retrieve
+     * When acknowledge() API is called, retrieve stored context for the ackIds.
+     * Map: ackId -> WeakRef<Message> -> stored context.
+     * Clean up immediately after acknowledge (happy path), or via FinalizationRegistry (GC).
+     */
+    this.addSub('apm:google-cloud-pubsub:message:ack-retrieve', ({ ackIds, api, ctx }) => {
+      for (const ackId of ackIds) {
+        const weakRef = ackIdToMessage.get(ackId)
+        if (weakRef) {
+          const message = weakRef.deref()
+          if (message) {
+            const storedContext = messageToContext.get(message)
+            if (storedContext) {
+              ctx.storedContext = storedContext
+              break
+            }
+          }
+        }
+      }
+
+      if (api === 'acknowledge') {
+        for (const ackId of ackIds) {
+          ackIdToMessage.delete(ackId)
+        }
+      }
+    })
+  }
+
+  #reconstructPubSubRequestContext (attrs) {
+    const traceIdLower = attrs['_dd.pubsub_request.trace_id']
+    const spanId = attrs['_dd.pubsub_request.span_id']
+    const traceIdUpper = attrs['_dd.pubsub_request.p.tid']
+
+    if (!traceIdLower || !spanId) return null
+
+    const traceId128 = traceIdUpper ? traceIdUpper + traceIdLower : traceIdLower.padStart(32, '0')
+    const traceId = id(traceId128, 16)
+    const parentId = id(spanId, 16)
+
+    const tags = {}
+    if (traceIdUpper) tags['_dd.p.tid'] = traceIdUpper
+
+    return new SpanContext({
+      traceId,
+      spanId: parentId,
+      tags,
+    })
+  }
+
+  bindStart (ctx) {
+    const { message } = ctx
+    const subscription = message._subscriber._subscription
+    const topic = subscription?.metadata?.topic || message.attributes?.['pubsub.topic']
+
+    const batchRequestTraceId = message.attributes?.['_dd.pubsub_request.trace_id']
+    const batchRequestSpanId = message.attributes?.['_dd.pubsub_request.span_id']
+
+    // Parse batch metadata once upfront for reuse
+    const batchSizeStr = message.attributes?.['_dd.batch.size']
+    const batchIndexStr = message.attributes?.['_dd.batch.index']
+    const batchSize = batchSizeStr ? Number(batchSizeStr) : undefined
+    const batchIndex = batchIndexStr ? Number(batchIndexStr) : undefined
+
+    let childOf = this.tracer.extract('text_map', message.attributes)
+
+    const isFirstMessage = batchIndex === 0
+    if (isFirstMessage && batchRequestSpanId) {
+      const pubsubRequestContext = this.#reconstructPubSubRequestContext(message.attributes)
+      if (pubsubRequestContext) {
+        childOf = pubsubRequestContext
+      }
+    }
+
+    const topicName = topic?.slice(topic.lastIndexOf('/') + 1) ??
+      subscription.name.slice(subscription.name.lastIndexOf('/') + 1)
+    const baseService = this.tracer._service || 'unknown'
+    const serviceName = this.config.service || `${baseService}-pubsub`
+    const meta = {
+      'gcloud.project_id': subscription.pubsub.projectId,
+      'pubsub.topic': topic,
+      'pubsub.message_id': message.messageId,
+      'span.kind': 'consumer',
+      'pubsub.subscription': subscription.name,
+      'pubsub.subscription_type': 'pull',
+      'messaging.operation': 'receive',
+      base_service: baseService,
+      service_override_type: 'custom',
+    }
+
+    if (batchRequestTraceId && batchRequestSpanId) {
+      meta['pubsub.batch.request_trace_id'] = batchRequestTraceId
+      // Use JSON format like producer for proper span link parsing
+      meta['_dd.span_links'] = JSON.stringify([{
+        trace_id: batchRequestTraceId,
+        span_id: batchRequestSpanId,
+        flags: 0,
+      }])
+    }
+
+    const metrics = {
+      'pubsub.ack': 0,
+    }
+
+    if (batchSize) {
+      metrics['pubsub.batch.message_count'] = batchSize
+      metrics['pubsub.batch.size'] = batchSize
+    }
+    if (batchIndex !== undefined) {
+      metrics['pubsub.batch.message_index'] = batchIndex
+      metrics['pubsub.batch.index'] = batchIndex
+    }
+
+    if (batchSize && batchIndex !== undefined) {
+      meta['pubsub.batch.description'] = `Message ${batchIndex + 1} of ${batchSize}`
+    }
+
+    const span = this.startSpan({
+      childOf,
+      resource: `Message from ${topicName}`,
+      type: 'worker',
+      service: serviceName,
+      meta,
+      metrics,
+    }, ctx)
+
+    if (message.publishTime) {
+      span.setTag('pubsub.publish_time', message.publishTime.toISOString())
+    }
+
+    if (message.attributes) {
+      const publishStartTime = message.attributes['x-dd-publish-start-time']
+      if (publishStartTime) {
+        const deliveryDuration = Date.now() - Number(publishStartTime)
+        span.setTag('pubsub.delivery_duration_ms', deliveryDuration)
+      }
+    }
+
+    if (this.config.dsmEnabled && message?.attributes) {
+      const payloadSize = getMessageSize(message)
+      this.tracer.decodeDataStreamsContext(message.attributes)
+      this.tracer
+        .setCheckpoint(['direction:in', `topic:${topic}`, 'type:google-pubsub'], span, payloadSize)
+    }
+
+    return ctx.currentStore
+  }
+
+  bindFinish (ctx) {
+    const { message } = ctx
+    const span = ctx.currentStore?.span
+
+    if (!span) return ctx.parentStore
+
+    if (message?._handled) {
+      span.setTag('pubsub.ack', 1)
+    }
+
+    super.finish()
+    return ctx.parentStore
+  }
+}
+
+module.exports = GoogleCloudPubsubConsumerPlugin

package/packages/datadog-plugin-google-cloud-pubsub/src/index.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const ProducerPlugin = require('./producer')
+const ConsumerPlugin = require('./consumer')
+const ClientPlugin = require('./client')
+
+class GoogleCloudPubsubPlugin extends CompositePlugin {
+  static id = 'google-cloud-pubsub'
+  static get plugins () {
+    return {
+      producer: ProducerPlugin,
+      consumer: ConsumerPlugin,
+      client: ClientPlugin,
+    }
+  }
+}
+
+module.exports = GoogleCloudPubsubPlugin

package/packages/datadog-plugin-google-cloud-pubsub/src/producer.js

@@ -0,0 +1,191 @@
+'use strict'
+
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const { DsmPathwayCodec, getHeadersSize } = require('../../dd-trace/src/datastreams')
+const id = require('../../dd-trace/src/id')
+
+class GoogleCloudPubsubProducerPlugin extends ProducerPlugin {
+  static id = 'google-cloud-pubsub'
+  static operation = 'request'
+
+  constructor (...args) {
+    super(...args)
+
+    /**
+     * Inject trace context into individual messages published via Topic.publish() or
+     * Topic.publishMessage(). This happens before the batch publish API call, allowing
+     * each message to propagate trace context to consumers.
+     */
+    this.addSub('apm:google-cloud-pubsub:message:publish', this.handleMessagePublish.bind(this))
+  }
+
+  handleMessagePublish ({ attributes, pubsub, topicName }) {
+    // Skip if message already has trace context from upstream
+    if (attributes['x-datadog-trace-id'] || attributes.traceparent) return
+
+    const activeSpan = this.tracer.scope().active()
+    if (!activeSpan) return
+
+    // Inject current span's trace context into message attributes
+    this.tracer.inject(activeSpan, 'text_map', attributes)
+
+    const traceIdUpperBits = activeSpan.context()._trace.tags['_dd.p.tid']
+    if (traceIdUpperBits) attributes['_dd.p.tid'] = traceIdUpperBits
+
+    if (pubsub) attributes['gcloud.project_id'] = pubsub.projectId
+    if (topicName) attributes['pubsub.topic'] = topicName
+  }
+
+  bindStart (ctx) {
+    const { request, api, projectId } = ctx
+    if (api !== 'publish') return
+
+    const messages = request.messages || []
+    const topic = request.topic
+    const messageCount = messages.length
+    const hasTraceContext = messages[0]?.attributes?.['x-datadog-trace-id']
+
+    /**
+     * Batch Publishing Strategy:
+     * - Create one "batch span" representing the entire publish operation
+     * - If messages already have trace context (from upstream), use the first message's
+     *   context as the parent, and create span links for messages 2-N
+     * - Otherwise, use the current active span as parent
+     * - Inject batch span context + metadata into all message attributes for downstream
+     *   consumers to reconstruct the trace and understand batch relationships
+     */
+    const spanLinkData = hasTraceContext
+      ? messages.slice(1).map(msg => this.#extractSpanLink(msg.attributes)).filter(Boolean)
+      : []
+
+    const firstAttrs = messages[0]?.attributes
+    const parentData = firstAttrs?.['x-datadog-trace-id'] && firstAttrs['x-datadog-parent-id']
+      ? {
+          traceId: firstAttrs['x-datadog-trace-id'],
+          spanId: firstAttrs['x-datadog-parent-id'],
+          traceIdUpper: firstAttrs['_dd.p.tid'],
+          samplingPriority: firstAttrs['x-datadog-sampling-priority'],
+        }
+      : null
+
+    const lastSlash = topic.lastIndexOf('/')
+    const topicName = lastSlash === -1 ? topic : topic.slice(lastSlash + 1)
+    const batchSpan = this.startSpan({
+      childOf: parentData ? this.#extractParentContext(parentData) : undefined,
+      resource: `${api} to Topic ${topicName}`,
+      meta: {
+        'gcloud.project_id': projectId,
+        'pubsub.method': api,
+        'pubsub.topic': topic,
+        'span.kind': 'producer',
+        '_dd.base_service': this.tracer._service,
+        '_dd.serviceoverride.type': 'integration',
+        'pubsub.linked_message_count': spanLinkData.length || undefined,
+        operation: messageCount > 1 ? 'batched.pubsub.request' : 'pubsub.request',
+      },
+      metrics: {
+        'pubsub.batch.message_count': messageCount,
+        'pubsub.batch': messageCount > 1 ? true : undefined,
+      },
+    }, ctx)
+
+    const spanCtx = batchSpan.context()
+    // Get 128-bit trace ID and span ID as hex strings
+    const fullTraceIdHex = spanCtx.toTraceId(true)
+    const batchSpanIdHex = spanCtx.toSpanId(true)
+    // Extract lower 64 bits (last 16 hex chars) for trace ID
+    const batchTraceIdHex = fullTraceIdHex.slice(-16)
+    const batchTraceIdUpper = spanCtx._trace.tags['_dd.p.tid']
+
+    if (spanLinkData.length) {
+      batchSpan.setTag('_dd.span_links', JSON.stringify(
+        spanLinkData.map(link => ({
+          trace_id: link.traceId,
+          span_id: link.spanId,
+          flags: link.samplingPriority || 0,
+        }))
+      ))
+    }
+
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i]
+      msg.attributes ??= {}
+
+      if (!hasTraceContext) {
+        this.tracer.inject(batchSpan, 'text_map', msg.attributes)
+      }
+
+      Object.assign(msg.attributes, {
+        '_dd.pubsub_request.trace_id': batchTraceIdHex,
+        '_dd.pubsub_request.span_id': batchSpanIdHex,
+        '_dd.batch.size': String(messageCount),
+        '_dd.batch.index': String(i),
+        'gcloud.project_id': projectId,
+        'pubsub.topic': topic,
+        'x-dd-publish-start-time': String(Math.floor(batchSpan._startTime)),
+      })
+
+      if (batchTraceIdUpper) {
+        msg.attributes['_dd.pubsub_request.p.tid'] = batchTraceIdUpper
+      }
+
+      if (this.config.dsmEnabled) {
+        const dataStreamsContext = this.tracer.setCheckpoint(
+          ['direction:out', `topic:${topic}`, 'type:google-pubsub'],
+          batchSpan,
+          getHeadersSize(msg)
+        )
+        DsmPathwayCodec.encode(dataStreamsContext, msg.attributes)
+      }
+    }
+
+    ctx.batchSpan = batchSpan
+    return ctx.currentStore
+  }
+
+  bindFinish (ctx) {
+    if (ctx.batchSpan && !ctx.batchSpan._duration) ctx.batchSpan.finish()
+    return super.bindFinish(ctx)
+  }
+
+  bindError (ctx) {
+    if (ctx.error && ctx.batchSpan) {
+      ctx.batchSpan.setTag('error', ctx.error)
+    }
+    return ctx.parentStore
+  }
+
+  #extractSpanLink (attrs) {
+    if (!attrs?.['x-datadog-trace-id'] || !attrs['x-datadog-parent-id']) return null
+
+    // Convert to hex strings
+    const lowerHex = id(attrs['x-datadog-trace-id']).toString(16)
+    const spanIdHex = id(attrs['x-datadog-parent-id']).toString(16)
+
+    // Build full 128-bit trace ID
+    const traceIdHex = attrs['_dd.p.tid']
+      ? attrs['_dd.p.tid'] + lowerHex
+      : lowerHex.padStart(32, '0')
+
+    return {
+      traceId: traceIdHex,
+      spanId: spanIdHex,
+      samplingPriority: attrs['x-datadog-sampling-priority']
+        ? Number.parseInt(attrs['x-datadog-sampling-priority'], 10)
+        : undefined,
+    }
+  }
+
+  #extractParentContext (data) {
+    const carrier = {
+      'x-datadog-trace-id': data.traceId,
+      'x-datadog-parent-id': data.spanId,
+    }
+    if (data.traceIdUpper) carrier['_dd.p.tid'] = data.traceIdUpper
+    if (data.samplingPriority) carrier['x-datadog-sampling-priority'] = String(data.samplingPriority)
+
+    return this.tracer.extract('text_map', carrier)
+  }
+}
+
+module.exports = GoogleCloudPubsubProducerPlugin

package/packages/datadog-plugin-google-cloud-pubsub/src/pubsub-push-subscription.js

@@ -0,0 +1,217 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing')
+const SpanContext = require('../../dd-trace/src/opentracing/span_context')
+const id = require('../../dd-trace/src/id')
+const log = require('../../dd-trace/src/log')
+
+// WeakMap to track push receive spans by request
+const pushReceiveSpans = new WeakMap()
+
+class GoogleCloudPubsubPushSubscriptionPlugin extends TracingPlugin {
+  static get id () { return 'google-cloud-pubsub-push-subscription' }
+
+  constructor (...args) {
+    super(...args)
+
+    /**
+     * PUSH SUBSCRIPTION: GCP sends HTTP POST requests to our service with message data in headers.
+     * We intercept these requests to create a pubsub.push.receive span that wraps the HTTP request.
+     *
+     * Flow: Detect push request -> Extract trace context -> Create receive span -> Activate it
+     * Hierarchy: pubsub.push.receive (parent) -> http.request (child) -> express.middleware...
+     *
+     * Plugin load order (http/index.js) ensures we subscribe before HttpServerPlugin.
+     */
+    this.addSub('apm:http:server:request:start', (ctx) => {
+      this.#handlePubSubRequest(ctx)
+    })
+
+    this.addSub('apm:http:server:request:finish', ({ req }) => {
+      this.#finishPushReceiveSpan(req)
+    })
+  }
+
+  #finishPushReceiveSpan (req) {
+    const pushReceiveSpan = pushReceiveSpans.get(req)
+    if (pushReceiveSpan && !pushReceiveSpan._duration) {
+      pushReceiveSpan.finish()
+      pushReceiveSpans.delete(req)
+    }
+  }
+
+  #handlePubSubRequest (ctx) {
+    const { req } = ctx
+    const userAgent = req.headers['user-agent'] || ''
+    if (req.method !== 'POST' || !userAgent.includes('APIs-Google')) {
+      return false
+    }
+
+    if (req.headers['x-goog-pubsub-message-id']) {
+      this.#createPushReceiveSpanAndActivate(ctx)
+      return true
+    }
+
+    log.warn(
+      // eslint-disable-next-line @stylistic/max-len
+      '[PubSub] No x-goog-pubsub-* headers detected. pubsub.push.receive spans will not be created. Add --push-no-wrapper-write-metadata to your subscription.'
+    )
+    return false
+  }
+
+  #createPushReceiveSpanAndActivate (ctx) {
+    const { req, res } = ctx
+    const messageData = this.#parseMessage(req)
+    if (!messageData) {
+      return
+    }
+
+    const originalContext = this.#extractContext(messageData)
+    const pubsubRequestContext = this.#reconstructPubSubContext(messageData.attrs) || originalContext
+    const isSameTrace = pubsubRequestContext &&
+      originalContext?.toTraceId() === pubsubRequestContext.toTraceId()
+
+    /**
+     * Create receive span, choosing parent context:
+     * - Same trace: use batch context (message is part of the batch trace)
+     * - Different trace: use message context as parent, link to batch for observability
+     *
+     * this.enter() activates the span so the HTTP request span becomes its child.
+     */
+    const pushReceiveSpan = this.#createPushReceiveSpan(
+      messageData,
+      isSameTrace ? pubsubRequestContext : originalContext,
+      isSameTrace ? null : pubsubRequestContext
+    )
+
+    if (!pushReceiveSpan) {
+      return
+    }
+
+    this.enter(pushReceiveSpan, { req, res })
+    pushReceiveSpans.set(req, pushReceiveSpan)
+  }
+
+  #parseMessage (req) {
+    const subscription = req.headers['x-goog-pubsub-subscription-name']
+    const message = {
+      messageId: req.headers['x-goog-pubsub-message-id'],
+      publishTime: req.headers['x-goog-pubsub-publish-time'],
+    }
+
+    const topicName = req.headers['pubsub.topic'] || 'push-subscription-topic'
+    return { message, subscription, attrs: req.headers, topicName }
+  }
+
+  #extractContext (messageData) {
+    return this.tracer.extract('text_map', messageData.attrs)
+  }
+
+  #reconstructPubSubContext (attrs) {
+    /**
+     * Reconstruct the batch publish span context from message attributes.
+     *
+     * When a batch is published, the producer injects:
+     * - _dd.pubsub_request.trace_id: lower 64 bits of the batch span's trace ID (hex)
+     * - _dd.pubsub_request.span_id: the batch span's span ID (hex)
+     * - _dd.pubsub_request.p.tid: upper 64 bits of trace ID (hex, optional for 128-bit traces)
+     *
+     * This context represents the "pubsub.request" span on the producer side.
+     * We use it to create span links, connecting each pubsub.push.receive span back to the original batch.
+     */
+    const traceIdLower = attrs['_dd.pubsub_request.trace_id']
+    const spanId = attrs['_dd.pubsub_request.span_id']
+    const traceIdUpper = attrs['_dd.pubsub_request.p.tid']
+
+    if (!traceIdLower || !spanId) return null
+
+    // Reconstruct full 128-bit trace ID (or pad 64-bit to 128-bit)
+    const traceId128 = traceIdUpper ? traceIdUpper + traceIdLower : traceIdLower.padStart(32, '0')
+    const traceId = id(traceId128, 16)
+    const parentId = id(spanId, 16)
+
+    const tags = {}
+    if (traceIdUpper) tags['_dd.p.tid'] = traceIdUpper
+
+    return new SpanContext({
+      traceId,
+      spanId: parentId,
+      tags,
+    })
+  }
+
+  #createPushReceiveSpan (messageData, parentContext, linkContext) {
+    const { message, subscription, topicName, attrs } = messageData
+    const subscriptionName = subscription?.slice(subscription.lastIndexOf('/') + 1) ?? subscription
+    const publishStartTime = attrs['x-dd-publish-start-time']
+    const startTime = publishStartTime ? Number.parseInt(publishStartTime, 10) : undefined
+
+    // Get the base service name and construct the pubsub service override
+    const baseService = this.tracer._service
+    const serviceOverride = this.config.service ?? `${baseService}-pubsub`
+
+    // Use this.startSpan() which automatically activates the span
+    const span = this.startSpan('pubsub.push.receive', {
+      childOf: parentContext,
+      startTime,
+      kind: 'consumer',
+      service: serviceOverride,
+      meta: {
+        component: 'google-cloud-pubsub',
+        'pubsub.method': 'receive',
+        'pubsub.subscription': subscription,
+        'pubsub.message_id': message.messageId,
+        'pubsub.subscription_type': 'push',
+        'pubsub.topic': topicName,
+        '_dd.base_service': baseService,
+        '_dd.serviceoverride.type': 'integration',
+        'resource.name': `Push Subscription ${subscriptionName}`,
+      },
+    })
+
+    if (!span) {
+      return null
+    }
+
+    span._integrationName = 'google-cloud-pubsub'
+    // Calculate delivery latency (queue time from publish to delivery)
+    if (publishStartTime) {
+      const deliveryDuration = Date.now() - Number(publishStartTime)
+      span.setTag('pubsub.delivery_duration_ms', deliveryDuration)
+    }
+
+    this.#addBatchMetadata(span, attrs)
+
+    if (linkContext) {
+      if (span.addLink) {
+        span.addLink(linkContext, {})
+      } else {
+        span._links ??= []
+        span._links.push({ context: linkContext, attributes: {} })
+      }
+    }
+
+    return span
+  }
+
+  #addBatchMetadata (span, attrs) {
+    const batchSizeStr = attrs['_dd.batch.size']
+    const batchIndexStr = attrs['_dd.batch.index']
+
+    if (!batchSizeStr || batchIndexStr === undefined) return
+
+    const size = Number(batchSizeStr)
+    const index = Number(batchIndexStr)
+
+    span.setTag('pubsub.batch.message_count', size)
+    span.setTag('pubsub.batch.message_index', index)
+    span.setTag('pubsub.batch.description', `Message ${index + 1} of ${size}`)
+
+    const requestTraceId = attrs['_dd.pubsub_request.trace_id']
+    if (requestTraceId) {
+      span.setTag('pubsub.batch.request_trace_id', requestTraceId)
+    }
+  }
+}
+
+module.exports = GoogleCloudPubsubPushSubscriptionPlugin

package/packages/datadog-plugin-google-cloud-vertexai/src/index.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const VertexAILLMObsPlugin = require('../../dd-trace/src/llmobs/plugins/vertexai')
+const GoogleVertexAITracingPlugin = require('./tracing')
+
+class GoogleCloudVertexAIPlugin extends CompositePlugin {
+  static id = 'google-cloud-vertexai'
+  static get plugins () {
+    return {
+      llmobs: VertexAILLMObsPlugin,
+      tracing: GoogleVertexAITracingPlugin,
+    }
+  }
+}
+
+module.exports = GoogleCloudVertexAIPlugin