dd-trace 6.9.0 → 6.11.0

package/packages/datadog-plugin-vitest/src/index.js

@@ -2,6 +2,7 @@
 
 const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
 const { storage } = require('../../datadog-core')
+const { writeDatadogParentId, writeDatadogTraceId } = require('../../dd-trace/src/carrier')
 
 const {
   TEST_STATUS,
@@ -13,7 +14,6 @@ const {
   getTestSuiteCommonTags,
   getTestLevelsMetadataTags,
   getTestSessionName,
-  getIsFaultyEarlyFlakeDetection,
   TEST_SOURCE_FILE,
   TEST_IS_RETRY,
   TEST_CODE_OWNERS,
@@ -107,19 +107,6 @@ class VitestPlugin extends CiPlugin {
       })
     })
 
-    this.addSub('ci:vitest:is-early-flake-detection-faulty', ({
-      knownTests,
-      testFilepaths,
-      onDone,
-    }) => {
-      const isFaulty = getIsFaultyEarlyFlakeDetection(
-        testFilepaths.map(testFilepath => getTestSuitePath(testFilepath, this.repositoryRoot)),
-        knownTests,
-        this.libraryConfig.earlyFlakeDetectionFaultyThreshold
-      )
-      onDone(isFaulty)
-    })
-
     this.addBind('ci:vitest:test:start', (ctx) => {
       const {
         testName,
@@ -424,12 +411,13 @@ class VitestPlugin extends CiPlugin {
       this._setRepositoryRoot(repositoryRoot, codeOwnersEntries)
       this.command = testCommand
       this.frameworkVersion = frameworkVersion
-      const testSessionSpanContext = testSessionId && testModuleId
-        ? this.tracer.extract('text_map', {
-          'x-datadog-trace-id': testSessionId,
-          'x-datadog-parent-id': testModuleId,
-        })
-        : undefined
+      let testSessionSpanContext
+      if (testSessionId && testModuleId) {
+        const carrier = /** @type {Record<string, unknown>} */ ({})
+        writeDatadogTraceId(carrier, testSessionId)
+        writeDatadogParentId(carrier, testModuleId)
+        testSessionSpanContext = this.tracer.extract('text_map', carrier)
+      }
 
       const trimmedCommand = DD_MAJOR < 6 ? this.command : 'vitest run'
       // test suites run in a different process, so they also need to init the metadata dictionary
@@ -535,6 +523,7 @@ class VitestPlugin extends CiPlugin {
           this.telemetry.ciVisEvent(TELEMETRY_CODE_COVERAGE_FINISHED, 'suite', { library: coverageLibrary })
           this.telemetry.distribution(TELEMETRY_CODE_COVERAGE_NUM_FILES, {}, relativeFiles.length)
         }
+        this.tracer._exporter.deferTestSuiteSpan?.(testSuiteSpan)
         testSuiteSpan.finish()
         finishAllTraceSpans(testSuiteSpan)
       }
@@ -578,6 +567,7 @@ class VitestPlugin extends CiPlugin {
     this.addSub('ci:vitest:session:finish', ({
       status,
       error,
+      isTestSessionFinalizationError,
       testCodeCoverageLinesTotal,
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
@@ -600,6 +590,9 @@ class VitestPlugin extends CiPlugin {
       this.testSessionSpan.setTag(TEST_STATUS, status)
       this.testModuleSpan.setTag(TEST_STATUS, status)
       if (error) {
+        if (isTestSessionFinalizationError) {
+          this.tracer._exporter.setDeferredTestSuiteError?.(error)
+        }
         this.testModuleSpan.setTag('error', error)
         this.testSessionSpan.setTag('error', error)
       }
@@ -629,6 +622,7 @@ class VitestPlugin extends CiPlugin {
       if (vitestPool) {
         this.testSessionSpan.setTag(VITEST_POOL, vitestPool)
       }
+      this.tracer._exporter.exportDeferredTestSuiteSpans?.()
       this.testModuleSpan.finish()
       this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
       this.testSessionSpan.finish()

package/packages/datadog-plugin-ws/src/util.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const { readDatadogTraceId, readTraceparent } = require('../../dd-trace/src/carrier')
 const DatadogSpanContext = require('../../dd-trace/src/opentracing/span_context')
 
 const TRACE_ID_UPPER_TAG = '_dd.p.tid'
@@ -38,7 +39,7 @@ function createWebSocketSpanContext (spanContext) {
  * @returns {boolean}
  */
 function hasTraceHeaders (headers) {
-  return !!(headers && (headers['x-datadog-trace-id'] || headers.traceparent))
+  return !!(headers && (readDatadogTraceId(headers) || readTraceparent(headers)))
 }
 
 /**

package/packages/datadog-webpack/index.js

@@ -6,7 +6,6 @@ const fs = require('node:fs')
 const instrumentations = require('../datadog-instrumentations/src/helpers/instrumentations')
 const extractPackageAndModulePath = require('../datadog-instrumentations/src/helpers/extract-package-and-module-path')
 const hooks = require('../datadog-instrumentations/src/helpers/hooks')
-const { matchesOptionalPeerFile } = require('../datadog-instrumentations/src/helpers/optional-peer-bundler')
 const { isESMFile } = require('../datadog-esbuild/src/utils')
 const log = require('./src/log')
 
@@ -137,16 +136,6 @@ class DatadogWebpackPlugin {
 
         const normalizedResource = resource.replaceAll('\\', '/')
 
-        // Rewrite optional-peer loads so installed peers get bundled and survive relocation
-        // (#8980); absent peers stay opaque, so a build that does not opt into the feature does
-        // not follow their dependency chain (#8635).
-        if (matchesOptionalPeerFile(normalizedResource)) {
-          createData.loaders ||= []
-          createData.loaders.push({ loader: require.resolve('./src/optional-peer-loader') })
-          log.debug('INLINE: optional-peer loader applied to %s', normalizedResource)
-          return
-        }
-
         if (!resource.includes('node_modules')) {
           return
         }

package/packages/dd-trace/index.js

@@ -1,4 +1,3 @@
 'use strict'
 
-require('./src/openfeature/register')
 module.exports = require('./src/bootstrap')

package/packages/dd-trace/src/agent/info.js

@@ -17,8 +17,10 @@ module.exports = {
  * Fetches agent information from the /info endpoint
  * @param {URL} url - The agent URL
  * @param {Function} callback - Callback function with signature (err, agentInfo)
+ * @param {{ deadline?: number, signal?: AbortSignal }} [options] - Request finalization options
+ * @param {Function} [makeRequest] - Request implementation
  */
-function fetchAgentInfo (url, callback) {
+function fetchAgentInfo (url, callback, options = {}, makeRequest = request) {
   const urlKey = url.href
 
   if (cachedUrl !== null && cachedUrl !== urlKey) {
@@ -29,10 +31,9 @@ function fetchAgentInfo (url, callback) {
     return process.nextTick(callback, null, cachedData)
   }
 
-  request('', {
-    path: '/info',
-    url,
-  }, (err, res) => {
+  options.path = '/info'
+  options.url = url
+  makeRequest('', options, (err, res) => {
     if (err) {
       return callback(err)
     }

package/packages/dd-trace/src/aiguard/client.js

@@ -1,5 +1,27 @@
 'use strict'
 
+const tracerVersion = require('../../../../package.json').version
+const { AIGuardClientError } = require('./errors')
+const { parseEvaluationResponse } = require('./evaluation')
+const TAGS = require('./tags')
+
+/**
+ * Resolves the AI Guard host for a Datadog site.
+ *
+ * @param {string} site
+ * @returns {string}
+ */
+function aiGuardHost (site) {
+  return site.split('.').length === 2 ? `app.${site}` : site
+}
+
+/**
+ * Sends a request to the AI Guard service.
+ *
+ * @param {object} body
+ * @param {{ url: string, headers: Record<string, string>, timeout: number }} opts
+ * @returns {Promise<{ status: number, body: unknown }>}
+ */
 async function executeRequest (body, opts) {
   const postData = JSON.stringify(body)
   const headers = {
@@ -22,4 +44,81 @@ async function executeRequest (body, opts) {
   }
 }
 
-module.exports = executeRequest
+class AIGuardClient {
+  #headers
+  #evaluateUrl
+  #timeout
+
+  /**
+   * @param {import('../config/config-base')} config
+   */
+  constructor (config) {
+    this.#headers = {
+      'DD-API-KEY': config.DD_API_KEY,
+      'DD-APPLICATION-KEY': config.DD_APP_KEY,
+      'DD-AI-GUARD-VERSION': tracerVersion,
+      'DD-AI-GUARD-SOURCE': 'SDK',
+      'DD-AI-GUARD-LANGUAGE': 'nodejs',
+    }
+    const endpoint = config.experimental.aiguard.endpoint || `https://${aiGuardHost(config.site)}/api/v2/ai-guard`
+    this.#evaluateUrl = `${endpoint}/evaluate`
+    this.#timeout = config.experimental.aiguard.timeout
+  }
+
+  /**
+   * Evaluates messages and converts the service response to the internal evaluation contract.
+   *
+   * @param {import('../../../../index').aiguard.Message[]} messages
+   * @param {{ service: string, env: string }} meta
+   * @returns {Promise<NonNullable<ReturnType<typeof parseEvaluationResponse>>>}
+   */
+  evaluate (messages, meta) {
+    const payload = {
+      data: {
+        attributes: {
+          messages,
+          meta,
+        },
+      },
+    }
+    return executeRequest(
+      payload,
+      { url: this.#evaluateUrl, headers: this.#headers, timeout: this.#timeout }
+    )
+      .then(response => this.#parseResponse(response))
+      .catch(cause => {
+        if (cause instanceof AIGuardClientError) throw cause
+
+        throw new AIGuardClientError(`Unexpected error calling AI Guard service: ${cause.message}`, {
+          cause,
+          telemetryType: TAGS.ERROR_TYPE_CLIENT,
+        })
+      })
+  }
+
+  /**
+   * Validates an AI Guard HTTP response.
+   *
+   * @param {{ status: number, body: unknown }} response
+   * @returns {NonNullable<ReturnType<typeof parseEvaluationResponse>>}
+   */
+  #parseResponse (response) {
+    if (response.status !== 200) {
+      throw new AIGuardClientError(`AI Guard service call failed, status ${response.status}`, {
+        errors: response.body?.errors,
+        telemetryType: TAGS.ERROR_TYPE_STATUS,
+      })
+    }
+
+    const evaluation = parseEvaluationResponse(response.body)
+    if (!evaluation) {
+      throw new AIGuardClientError(`AI Guard service returned unexpected response : ${response.body}`, {
+        telemetryType: TAGS.ERROR_TYPE_RESPONSE,
+      })
+    }
+
+    return evaluation
+  }
+}
+
+module.exports = AIGuardClient

package/packages/dd-trace/src/aiguard/errors.js

@@ -0,0 +1,41 @@
+'use strict'
+
+class AIGuardAbortError extends Error {
+  /**
+   * @param {string|undefined} reason
+   * @param {Array<unknown>} tags
+   * @param {Record<string, unknown>} tagProbabilities
+   * @param {Array<unknown>} sds
+   */
+  constructor (reason, tags, tagProbabilities, sds) {
+    super(reason)
+    this.name = 'AIGuardAbortError'
+    this.reason = reason
+    this.tags = tags
+    this.tagProbabilities = tagProbabilities
+    this.sds = sds || []
+  }
+}
+
+class AIGuardClientError extends Error {
+  /**
+   * @param {string} message
+   * @param {{ telemetryType: string, errors?: Array<unknown>, cause?: Error }} opts
+   */
+  constructor (message, opts) {
+    super(message)
+    this.name = 'AIGuardClientError'
+    this.telemetryType = opts.telemetryType
+    if (opts.errors) {
+      this.errors = opts.errors
+    }
+    if (opts.cause) {
+      this.cause = opts.cause
+    }
+  }
+}
+
+module.exports = {
+  AIGuardAbortError,
+  AIGuardClientError,
+}

package/packages/dd-trace/src/aiguard/evaluation.js

@@ -0,0 +1,357 @@
+'use strict'
+
+const { HTTP_CLIENT_IP, HTTP_USERAGENT, NETWORK_CLIENT_IP } = require('../../../../ext/tags')
+const clone = require('../../../../vendor/dist/rfdc')({ proto: false, circles: false })
+const { USER_ID, USER_SESSION_ID } = require('../appsec/addresses')
+const { getActiveRequest } = require('../appsec/store')
+const { keepTrace } = require('../priority_sampler')
+const { extractIp } = require('../plugins/util/ip_extractor')
+const { AI_GUARD } = require('../standalone/product')
+const telemetryMetrics = require('../telemetry/metrics')
+const TAGS = require('./tags')
+
+const ALLOW = 'ALLOW'
+
+/** @typedef {import('../../../../index').aiguard.Message} Message */
+/** @typedef {import('../opentracing/span')} Span */
+
+/**
+ * @typedef {object} EvaluationResponse
+ * @property {string} action
+ * @property {string|undefined} reason
+ * @property {Array<unknown>} tags
+ * @property {Array<unknown>} sdsFindings
+ * @property {Record<string, unknown>} tagProbabilities
+ * @property {boolean} hasTagProbabilities
+ * @property {boolean} blockingEnabled
+ */
+
+/**
+ * @typedef {object} EvaluationOutcome
+ * @property {{ action: string, reason: string|undefined, tags: Array<unknown>,
+ *   tagProbabilities: Record<string, unknown>, sds: Array<unknown> }} result
+ * @property {boolean} shouldBlock
+ * @property {boolean} hasTagProbabilities
+ */
+
+/**
+ * @typedef {object} EvaluationMetaStruct
+ * @property {Message[]} messages
+ * @property {Array<unknown>} [attack_categories]
+ * @property {Array<unknown>} [sds]
+ * @property {Record<string, unknown>} [tag_probs]
+ */
+
+/**
+ * @typedef {object} EvaluationReport
+ * @property {Span} span
+ * @property {EvaluationMetaStruct} metaStruct
+ * @property {{ source: string, integration: string }} telemetryTags
+ */
+
+/**
+ * Returns whether a value is a non-array object.
+ *
+ * @param {unknown} value
+ * @returns {value is Record<string, unknown>}
+ */
+function isRecord (value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+/**
+ * Parses the backend evaluation response into the tracer's internal contract.
+ *
+ * @param {unknown} body
+ * @returns {EvaluationResponse|undefined}
+ */
+function parseEvaluationResponse (body) {
+  if (!isRecord(body) || !isRecord(body.data) || !isRecord(body.data.attributes)) return
+
+  const attributes = body.data.attributes
+  if (typeof attributes.action !== 'string' || attributes.action.length === 0) return
+
+  return {
+    action: attributes.action,
+    reason: typeof attributes.reason === 'string' ? attributes.reason : undefined,
+    tags: Array.isArray(attributes.tags) ? attributes.tags : [],
+    sdsFindings: Array.isArray(attributes.sds_findings) ? attributes.sds_findings : [],
+    tagProbabilities: isRecord(attributes.tag_probs) ? attributes.tag_probs : {},
+    hasTagProbabilities: isRecord(attributes.tag_probs),
+    blockingEnabled: attributes.is_blocking_enabled === true,
+  }
+}
+
+/**
+ * Determines whether the current evaluation must abort the guarded operation.
+ *
+ * @param {boolean} block
+ * @param {{ action: string, blockingEnabled: boolean }} evaluation
+ * @returns {boolean}
+ */
+function shouldBlockEvaluation (block, evaluation) {
+  return block && evaluation.blockingEnabled && evaluation.action !== ALLOW
+}
+
+/**
+ * Applies local evaluation policy and creates the result returned to the caller.
+ *
+ * @param {EvaluationResponse} evaluation
+ * @param {boolean} block
+ * @returns {EvaluationOutcome}
+ */
+function createEvaluationOutcome (evaluation, block) {
+  return {
+    result: {
+      action: evaluation.action,
+      reason: evaluation.reason,
+      tags: evaluation.tags,
+      tagProbabilities: evaluation.tagProbabilities,
+      sds: evaluation.sdsFindings,
+    },
+    shouldBlock: shouldBlockEvaluation(block, evaluation),
+    hasTagProbabilities: evaluation.hasTagProbabilities,
+  }
+}
+
+const aiguardMetrics = telemetryMetrics.manager.namespace('ai_guard')
+
+// Tags from the service entry span that must be mirrored onto every AI Guard span
+// so anomaly detection pipelines can process each span independently.
+const SERVICE_ENTRY_TAG_MAPPINGS = [
+  [HTTP_USERAGENT, TAGS.HTTP_USERAGENT_TAG_KEY],
+  [HTTP_CLIENT_IP, TAGS.HTTP_CLIENT_IP_TAG_KEY],
+  [NETWORK_CLIENT_IP, TAGS.NETWORK_CLIENT_IP_TAG_KEY],
+  [USER_ID, TAGS.USR_ID_TAG_KEY],
+  [USER_SESSION_ID, TAGS.USR_SESSION_ID_TAG_KEY],
+]
+
+class EvaluationReporter {
+  #config
+  #maxMessagesLength
+  #maxContentSize
+
+  /**
+   * @param {import('../config/config-base')} config
+   */
+  constructor (config) {
+    this.#config = config
+    this.#maxMessagesLength = config.experimental.aiguard.maxMessagesLength
+    this.#maxContentSize = config.experimental.aiguard.maxContentSize
+  }
+
+  /**
+   * Initializes span and trace reporting before the AI Guard request starts.
+   *
+   * @param {Span} span
+   * @param {Message[]} messages
+   * @param {{ source: string, integration: string }} options
+   * @returns {EvaluationReport}
+   */
+  start (span, messages, options) {
+    const telemetryTags = { source: options.source, integration: options.integration }
+    const last = messages.at(-1)
+    const target = this.#isToolCall(last) ? 'tool' : 'prompt'
+    span.setTag(TAGS.TARGET_TAG_KEY, target)
+    if (target === 'tool') {
+      const name = this.#getToolName(last, messages)
+      if (name) {
+        span.setTag(TAGS.TOOL_NAME_TAG_KEY, name)
+      }
+    }
+
+    const metaStruct = {
+      messages: this.#buildMessagesForMetaStruct(messages, telemetryTags),
+    }
+    span.meta_struct = {
+      [TAGS.META_STRUCT_KEY]: metaStruct,
+    }
+
+    const rootSpan = span.context()?._trace?.started?.[0]
+    if (rootSpan) {
+      this.#setRootSpanClientIpTags(rootSpan)
+      this.#copyServiceEntryTagsToGuardSpan(span, rootSpan)
+      // This must happen before the request so its sampling decision reaches outgoing HTTP spans.
+      keepTrace(rootSpan, AI_GUARD)
+      rootSpan.setTag(TAGS.EVENT_TAG_KEY, 'true')
+    }
+
+    return {
+      span,
+      metaStruct,
+      telemetryTags,
+    }
+  }
+
+  /**
+   * Reports a failed evaluation request.
+   *
+   * @param {EvaluationReport} report
+   * @param {string} errorType
+   * @returns {void}
+   */
+  fail (report, errorType) {
+    aiguardMetrics.count(TAGS.TELEMETRY_REQUESTS, { error: true, ...report.telemetryTags }).inc(1)
+    aiguardMetrics.count(TAGS.TELEMETRY_ERROR, { type: errorType, ...report.telemetryTags }).inc(1)
+  }
+
+  /**
+   * Reports a successful evaluation and its local policy outcome.
+   *
+   * @param {EvaluationReport} report
+   * @param {EvaluationOutcome} outcome
+   * @returns {void}
+   */
+  finish (report, outcome) {
+    const { result, shouldBlock } = outcome
+
+    if (result.tags.length > 0) report.metaStruct.attack_categories = result.tags
+    if (result.sds.length > 0) report.metaStruct.sds = result.sds
+    if (outcome.hasTagProbabilities) report.metaStruct.tag_probs = result.tagProbabilities
+
+    const requestTelemetryTags = {
+      action: result.action,
+      error: false,
+      block: shouldBlock,
+      ...report.telemetryTags,
+    }
+    aiguardMetrics.count(TAGS.TELEMETRY_REQUESTS, requestTelemetryTags).inc(1)
+
+    report.span.setTag(TAGS.ACTION_TAG_KEY, result.action)
+    if (result.reason) {
+      report.span.setTag(TAGS.REASON_TAG_KEY, result.reason)
+    }
+    if (shouldBlock) {
+      report.span.setTag(TAGS.BLOCKED_TAG_KEY, 'true')
+    }
+  }
+
+  /**
+   * Returns a safe, size-limited message copy for the span meta-struct.
+   *
+   * @param {Message[]} messages
+   * @param {{ source: string, integration: string }} telemetryTags
+   * @returns {Message[]}
+   */
+  #buildMessagesForMetaStruct (messages, telemetryTags) {
+    const size = Math.min(messages.length, this.#maxMessagesLength)
+    if (messages.length > size) {
+      aiguardMetrics.count(TAGS.TELEMETRY_TRUNCATED, { type: 'messages', ...telemetryTags }).inc(1)
+    }
+    const result = []
+    let contentTruncated = false
+    for (let i = messages.length - size; i < messages.length; i++) {
+      const message = clone(messages[i])
+      if (message.content?.length > this.#maxContentSize) {
+        contentTruncated = true
+        message.content = message.content.slice(0, this.#maxContentSize)
+      }
+      result.push(message)
+    }
+    if (contentTruncated) {
+      aiguardMetrics.count(TAGS.TELEMETRY_TRUNCATED, { type: 'content', ...telemetryTags }).inc(1)
+    }
+    return result
+  }
+
+  /**
+   * Returns whether a message represents a tool call or tool output.
+   *
+   * @param {Message} message
+   * @returns {boolean}
+   */
+  #isToolCall (message) {
+    return Boolean(message.tool_calls || message.tool_call_id)
+  }
+
+  /**
+   * Resolves the tool name associated with a tool call or output message.
+   *
+   * @param {Message} message
+   * @param {Message[]} history
+   * @returns {string|null}
+   */
+  #getToolName (message, history) {
+    if (message.tool_calls) {
+      const names = message.tool_calls.map(tool => tool.function.name)
+      return names.length === 0 ? null : names.join(',')
+    }
+
+    const id = message.tool_call_id
+    for (let i = history.length - 2; i >= 0; i--) {
+      const item = history[i]
+      if (item.tool_calls) {
+        for (const toolCall of item.tool_calls) {
+          if (toolCall.id === id) {
+            return toolCall.function.name
+          }
+        }
+      }
+    }
+    return null
+  }
+
+  /**
+   * Adds missing client IP tags to the service entry span.
+   *
+   * @param {Span} rootSpan
+   * @returns {void}
+   */
+  #setRootSpanClientIpTags (rootSpan) {
+    const currentTags = rootSpan.context().getTags()
+    const needsHttpClientIp = !Object.hasOwn(currentTags, HTTP_CLIENT_IP)
+    const needsNetworkClientIp = !Object.hasOwn(currentTags, NETWORK_CLIENT_IP)
+
+    if (!needsHttpClientIp && !needsNetworkClientIp) return
+
+    const request = getActiveRequest()
+    if (!request) return
+
+    const newTags = {}
+    let hasNewTags = false
+
+    if (needsHttpClientIp) {
+      const clientIp = extractIp(this.#config, request)
+      if (clientIp) {
+        newTags[HTTP_CLIENT_IP] = clientIp
+        hasNewTags = true
+      }
+    }
+
+    if (needsNetworkClientIp) {
+      const networkClientIp = request.socket?.remoteAddress
+      if (networkClientIp) {
+        newTags[NETWORK_CLIENT_IP] = networkClientIp
+        hasNewTags = true
+      }
+    }
+
+    if (hasNewTags) {
+      rootSpan.addTags(newTags)
+    }
+  }
+
+  /**
+   * Copies service entry tags required by anomaly detection to the AI Guard span.
+   *
+   * @param {Span} guardSpan
+   * @param {Span} rootSpan
+   * @returns {void}
+   */
+  #copyServiceEntryTagsToGuardSpan (guardSpan, rootSpan) {
+    const rootTags = rootSpan.context().getTags()
+    for (const [sourceTag, destinationTag] of SERVICE_ENTRY_TAG_MAPPINGS) {
+      const value = rootTags[sourceTag]
+      if (value !== undefined && value !== null) {
+        guardSpan.setTag(destinationTag, value)
+      }
+    }
+  }
+}
+
+module.exports = {
+  createEvaluationOutcome,
+  EvaluationReporter,
+  parseEvaluationResponse,
+  shouldBlockEvaluation,
+}