@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,444 @@
+'use strict'
+
+const CiPlugin = require('../../dd-trace/src/plugins/ci_plugin')
+const { storage } = require('../../datadog-core')
+const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
+
+const {
+  TEST_STATUS,
+  VITEST_POOL,
+  finishAllTraceSpans,
+  getTestSuitePath,
+  getTestSuiteCommonTags,
+  getTestSessionName,
+  getIsFaultyEarlyFlakeDetection,
+  TEST_SOURCE_FILE,
+  TEST_IS_RETRY,
+  TEST_CODE_COVERAGE_LINES_PCT,
+  TEST_CODE_OWNERS,
+  TEST_LEVEL_EVENT_TYPES,
+  TEST_SESSION_NAME,
+  TEST_SOURCE_START,
+  TEST_IS_NEW,
+  TEST_EARLY_FLAKE_ENABLED,
+  TEST_EARLY_FLAKE_ABORT_REASON,
+  TEST_RETRY_REASON,
+  TEST_MANAGEMENT_ENABLED,
+  TEST_MANAGEMENT_IS_QUARANTINED,
+  TEST_MANAGEMENT_IS_DISABLED,
+  TEST_MANAGEMENT_IS_ATTEMPT_TO_FIX,
+  TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED,
+  TEST_HAS_FAILED_ALL_RETRIES,
+  getLibraryCapabilitiesTags,
+  TEST_RETRY_REASON_TYPES,
+  isModifiedTest,
+  TEST_IS_MODIFIED,
+} = require('../../dd-trace/src/plugins/util/test')
+const { COMPONENT } = require('../../dd-trace/src/constants')
+const {
+  TELEMETRY_EVENT_CREATED,
+  TELEMETRY_EVENT_FINISHED,
+  TELEMETRY_TEST_SESSION,
+} = require('../../dd-trace/src/ci-visibility/telemetry')
+const { DD_MAJOR } = require('../../../version')
+
+// Milliseconds that we subtract from the error test duration
+// so that they do not overlap with the following test
+// This is because there's some loss of resolution.
+const MILLISECONDS_TO_SUBTRACT_FROM_FAILED_TEST_DURATION = 5
+
+class VitestPlugin extends CiPlugin {
+  static id = 'vitest'
+
+  constructor (...args) {
+    super(...args)
+
+    this.taskToFinishTime = new WeakMap()
+
+    this.addSub('ci:vitest:test:is-new', ({ knownTests, testSuiteAbsolutePath, testName, onDone }) => {
+      // if for whatever reason the worker does not receive valid known tests, we don't consider it as new
+      if (!knownTests.vitest) {
+        return onDone(false)
+      }
+      const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
+      const testsForThisTestSuite = knownTests.vitest[testSuite] || []
+      onDone(!testsForThisTestSuite.includes(testName))
+    })
+
+    this.addSub('ci:vitest:test:is-attempt-to-fix', ({
+      testManagementTests,
+      testSuiteAbsolutePath,
+      testName,
+      onDone,
+    }) => {
+      const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
+      const { isAttemptToFix } = this.getTestProperties(testManagementTests, testSuite, testName)
+
+      onDone(isAttemptToFix ?? false)
+    })
+
+    this.addSub('ci:vitest:test:is-disabled', ({ testManagementTests, testSuiteAbsolutePath, testName, onDone }) => {
+      const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
+      const { isDisabled } = this.getTestProperties(testManagementTests, testSuite, testName)
+
+      onDone(isDisabled)
+    })
+
+    this.addSub('ci:vitest:test:is-quarantined', ({ testManagementTests, testSuiteAbsolutePath, testName, onDone }) => {
+      const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
+      const { isQuarantined } = this.getTestProperties(testManagementTests, testSuite, testName)
+
+      onDone(isQuarantined)
+    })
+
+    this.addSub('ci:vitest:test:is-modified', ({ modifiedFiles, testSuiteAbsolutePath, onDone }) => {
+      const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
+      const isModified = isModifiedTest(testSuite, 0, 0, modifiedFiles, this.constructor.id)
+
+      onDone(isModified)
+    })
+
+    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,
+        testSuiteAbsolutePath,
+        isRetry,
+        isNew,
+        isAttemptToFix,
+        isQuarantined,
+        isDisabled,
+        mightHitProbe,
+        isRetryReasonEfd,
+        isRetryReasonAttemptToFix,
+        isRetryReasonAtr,
+        isModified,
+      } = ctx
+
+      const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
+      const store = storage('legacy').getStore()
+
+      const extraTags = {
+        [TEST_SOURCE_FILE]: testSuite,
+      }
+      if (isRetry) {
+        extraTags[TEST_IS_RETRY] = 'true'
+        if (isRetryReasonAttemptToFix) {
+          extraTags[TEST_RETRY_REASON] = TEST_RETRY_REASON_TYPES.atf
+        } else if (isRetryReasonEfd) {
+          extraTags[TEST_RETRY_REASON] = TEST_RETRY_REASON_TYPES.efd
+        } else if (isRetryReasonAtr) {
+          extraTags[TEST_RETRY_REASON] = TEST_RETRY_REASON_TYPES.atr
+        } else {
+          extraTags[TEST_RETRY_REASON] = TEST_RETRY_REASON_TYPES.ext
+        }
+      }
+      if (isNew) {
+        extraTags[TEST_IS_NEW] = 'true'
+      }
+      if (isAttemptToFix) {
+        extraTags[TEST_MANAGEMENT_IS_ATTEMPT_TO_FIX] = 'true'
+      }
+      if (isQuarantined) {
+        extraTags[TEST_MANAGEMENT_IS_QUARANTINED] = 'true'
+      }
+      if (isDisabled) {
+        extraTags[TEST_MANAGEMENT_IS_DISABLED] = 'true'
+      }
+      if (isModified) {
+        extraTags[TEST_IS_MODIFIED] = 'true'
+      }
+
+      const span = this.startTestSpan(
+        testName,
+        testSuite,
+        this.testSuiteSpan,
+        extraTags
+      )
+
+      ctx.parentStore = store
+      ctx.currentStore = { ...store, span }
+
+      // TODO: there might be multiple tests for which mightHitProbe is true, so activeTestSpan
+      // might be wrongly overwritten.
+      if (mightHitProbe) {
+        this.activeTestSpan = span
+      }
+
+      return ctx.currentStore
+    })
+
+    this.addBind('ci:vitest:test:finish-time', (ctx) => {
+      const { status, task, attemptToFixPassed, attemptToFixFailed } = ctx
+      const span = ctx.currentStore?.span
+
+      // we store the finish time to finish at a later hook
+      // this is because the test might fail at a `afterEach` hook
+      if (span) {
+        span.setTag(TEST_STATUS, status)
+
+        if (attemptToFixPassed) {
+          span.setTag(TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED, 'true')
+        } else if (attemptToFixFailed) {
+          span.setTag(TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED, 'false')
+        }
+
+        this.taskToFinishTime.set(task, span._getTime())
+
+        ctx.parentStore = ctx.currentStore
+        ctx.currentStore = { ...ctx.currentStore, span }
+      }
+
+      return ctx.currentStore
+    })
+
+    this.addSub('ci:vitest:test:pass', ({ span, task }) => {
+      if (span) {
+        this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'test', this.getTestTelemetryTags(span))
+        span.setTag(TEST_STATUS, 'pass')
+        span.finish(this.taskToFinishTime.get(task))
+        finishAllTraceSpans(span)
+      }
+    })
+
+    this.addSub('ci:vitest:test:error', ({
+      span,
+      duration,
+      error,
+      shouldSetProbe,
+      promises,
+      hasFailedAllRetries,
+      attemptToFixFailed,
+    }) => {
+      if (!span) {
+        return
+      }
+      if (shouldSetProbe && this.di && error?.stack) {
+        const probeInformation = this.addDiProbe(error)
+        if (probeInformation) {
+          const { file, line, stackIndex, setProbePromise } = probeInformation
+          this.runningTestProbe = { file, line }
+          this.testErrorStackIndex = stackIndex
+          promises.setProbePromise = setProbePromise
+        }
+      }
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'test', this.getTestTelemetryTags(span))
+      span.setTag(TEST_STATUS, 'fail')
+
+      if (error) {
+        span.setTag('error', error)
+      }
+      if (hasFailedAllRetries) {
+        span.setTag(TEST_HAS_FAILED_ALL_RETRIES, 'true')
+      }
+      if (attemptToFixFailed) {
+        span.setTag(TEST_MANAGEMENT_ATTEMPT_TO_FIX_PASSED, 'false')
+      }
+      if (duration) {
+        span.finish(span._startTime + duration - MILLISECONDS_TO_SUBTRACT_FROM_FAILED_TEST_DURATION) // milliseconds
+      } else {
+        span.finish() // `duration` is empty for retries, so we'll use clock time
+      }
+      finishAllTraceSpans(span)
+    })
+
+    this.addSub('ci:vitest:test:skip', ({ testName, testSuiteAbsolutePath, isNew, isDisabled }) => {
+      const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
+      const testSpan = this.startTestSpan(
+        testName,
+        testSuite,
+        this.testSuiteSpan,
+        {
+          [TEST_SOURCE_FILE]: testSuite,
+          [TEST_SOURCE_START]: 1, // we can't get the proper start line in vitest
+          [TEST_STATUS]: 'skip',
+          ...(isDisabled ? { [TEST_MANAGEMENT_IS_DISABLED]: 'true' } : {}),
+          ...(isNew ? { [TEST_IS_NEW]: 'true' } : {}),
+        }
+      )
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'test', this.getTestTelemetryTags(testSpan))
+      testSpan.finish()
+    })
+
+    this.addBind('ci:vitest:test-suite:start', (ctx) => {
+      const { testSuiteAbsolutePath, frameworkVersion } = ctx
+
+      // TODO: Handle case where the command is not set
+      this.command = getValueFromEnvSources('DD_CIVISIBILITY_TEST_COMMAND')
+      this.frameworkVersion = frameworkVersion
+      const testSessionSpanContext = this.tracer.extract('text_map', {
+        // TODO: Handle case where the session ID or module ID is not set
+        'x-datadog-trace-id': getValueFromEnvSources('DD_CIVISIBILITY_TEST_SESSION_ID'),
+        'x-datadog-parent-id': getValueFromEnvSources('DD_CIVISIBILITY_TEST_MODULE_ID'),
+      })
+
+      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
+      const testSessionName = getTestSessionName(this.config, trimmedCommand, this.testEnvironmentMetadata)
+      const metadataTags = {}
+      for (const testLevel of TEST_LEVEL_EVENT_TYPES) {
+        metadataTags[testLevel] = {
+          [TEST_SESSION_NAME]: testSessionName,
+        }
+      }
+      if (this.tracer._exporter.addMetadataTags) {
+        const libraryCapabilitiesTags = getLibraryCapabilitiesTags(this.constructor.id)
+        metadataTags.test = {
+          ...metadataTags.test,
+          ...libraryCapabilitiesTags,
+        }
+        this.tracer._exporter.addMetadataTags(metadataTags)
+      }
+
+      const testSuite = getTestSuitePath(testSuiteAbsolutePath, this.repositoryRoot)
+      // Request error tags are applied to test spans in the main process (worker-report:trace handler)
+      const testSuiteMetadata = {
+        ...getTestSuiteCommonTags(
+          this.command,
+          this.frameworkVersion,
+          testSuite,
+          'vitest'
+        ),
+        [TEST_SOURCE_FILE]: testSuite,
+        [TEST_SOURCE_START]: 1,
+      }
+
+      const codeOwners = this.getCodeOwners(testSuiteMetadata)
+      if (codeOwners) {
+        testSuiteMetadata[TEST_CODE_OWNERS] = codeOwners
+      }
+
+      const testSuiteSpan = this.tracer.startSpan('vitest.test_suite', {
+        childOf: testSessionSpanContext,
+        tags: {
+          [COMPONENT]: this.constructor.id,
+          ...this.testEnvironmentMetadata,
+          ...testSuiteMetadata,
+        },
+      })
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_CREATED, 'suite')
+      const store = storage('legacy').getStore()
+      ctx.parentStore = store
+      ctx.currentStore = { ...store, testSuiteSpan }
+      this.testSuiteSpan = testSuiteSpan
+
+      return ctx.currentStore
+    })
+
+    this.addSub('ci:vitest:test-suite:finish', ({ testSuiteSpan, status, onFinish }) => {
+      if (testSuiteSpan) {
+        testSuiteSpan.setTag(TEST_STATUS, status)
+        testSuiteSpan.finish()
+        finishAllTraceSpans(testSuiteSpan)
+      }
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'suite')
+      this.tracer._exporter.flush(onFinish)
+      if (this.runningTestProbe) {
+        this.removeDiProbe(this.runningTestProbe)
+      }
+    })
+
+    this.addBind('ci:vitest:test-suite:error', (ctx) => {
+      const { error } = ctx
+      const testSuiteSpan = ctx.currentStore?.testSuiteSpan
+
+      if (testSuiteSpan && error) {
+        testSuiteSpan.setTag('error', error)
+        testSuiteSpan.setTag(TEST_STATUS, 'fail')
+
+        ctx.parentStore = ctx.currentStore
+        ctx.currentStore = { ...ctx.currentStore, testSuiteSpan }
+      }
+
+      return ctx.currentStore
+    })
+
+    this.addSub('ci:vitest:session:finish', ({
+      status,
+      error,
+      testCodeCoverageLinesTotal,
+      isEarlyFlakeDetectionEnabled,
+      isEarlyFlakeDetectionFaulty,
+      isTestManagementTestsEnabled,
+      vitestPool,
+      onFinish,
+    }) => {
+      this.testSessionSpan.setTag(TEST_STATUS, status)
+      this.testModuleSpan.setTag(TEST_STATUS, status)
+      if (error) {
+        this.testModuleSpan.setTag('error', error)
+        this.testSessionSpan.setTag('error', error)
+      }
+      if (testCodeCoverageLinesTotal !== undefined) {
+        this.testModuleSpan.setTag(TEST_CODE_COVERAGE_LINES_PCT, testCodeCoverageLinesTotal)
+        this.testSessionSpan.setTag(TEST_CODE_COVERAGE_LINES_PCT, testCodeCoverageLinesTotal)
+      }
+      if (isEarlyFlakeDetectionEnabled) {
+        this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ENABLED, 'true')
+      }
+      if (isEarlyFlakeDetectionFaulty) {
+        this.testSessionSpan.setTag(TEST_EARLY_FLAKE_ABORT_REASON, 'faulty')
+      }
+      if (isTestManagementTestsEnabled) {
+        this.testSessionSpan.setTag(TEST_MANAGEMENT_ENABLED, 'true')
+      }
+      if (vitestPool) {
+        this.testSessionSpan.setTag(VITEST_POOL, vitestPool)
+      }
+      this.testModuleSpan.finish()
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'module')
+      this.testSessionSpan.finish()
+      this.telemetry.ciVisEvent(TELEMETRY_EVENT_FINISHED, 'session', {
+        hasFailedTestReplay: this.libraryConfig?.isDiEnabled || undefined,
+      })
+      finishAllTraceSpans(this.testSessionSpan)
+      this.telemetry.count(TELEMETRY_TEST_SESSION, {
+        provider: this.ciProviderName,
+        autoInjected: !!getValueFromEnvSources('DD_CIVISIBILITY_AUTO_INSTRUMENTATION_PROVIDER'),
+      })
+      this.tracer._exporter.flush(onFinish)
+    })
+
+    this.addSub('ci:vitest:coverage-report', ({ rootDir, onDone }) => {
+      this.handleCoverageReport(rootDir, onDone)
+    })
+  }
+
+  /**
+   * Handles the coverage report by discovering and uploading it if enabled.
+   * @param {string} rootDir - The root directory where coverage reports are located.
+   * @param {Function} [onDone] - Callback to signal completion.
+   */
+  handleCoverageReport (rootDir, onDone) {
+    if (!this.libraryConfig?.isCoverageReportUploadEnabled) {
+      onDone()
+      return
+    }
+    this.uploadCoverageReports({
+      rootDir,
+      testEnvironmentMetadata: this.testEnvironmentMetadata,
+      onDone,
+    })
+  }
+
+  getTestProperties (testManagementTests, testSuite, testName) {
+    const { attempt_to_fix: isAttemptToFix, disabled: isDisabled, quarantined: isQuarantined } =
+      testManagementTests?.vitest?.suites?.[testSuite]?.tests?.[testName]?.properties || {}
+
+    return { isAttemptToFix, isDisabled, isQuarantined }
+  }
+}
+
+module.exports = VitestPlugin

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

@@ -0,0 +1,18 @@
+'use strict'
+
+const Plugin = require('../../dd-trace/src/plugins/plugin')
+const web = require('../../dd-trace/src/plugins/util/web')
+
+class WebPlugin extends Plugin {
+  static id = 'web'
+
+  configure (config) {
+    return super.configure(web.normalizeConfig(config))
+  }
+
+  setFramework (req, name, config) {
+    web.setFramework(req, name, config)
+  }
+}
+
+module.exports = WebPlugin

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

@@ -0,0 +1,8 @@
+'use strict'
+
+const LogPlugin = require('../../dd-trace/src/plugins/log_plugin')
+
+class WinstonPlugin extends LogPlugin {
+  static id = 'winston'
+}
+module.exports = WinstonPlugin

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

@@ -0,0 +1,121 @@
+'use strict'
+
+const TracingPlugin = require('../../dd-trace/src/plugins/tracing.js')
+const {
+  WEBSOCKET_PTR_KIND,
+  SPAN_POINTER_DIRECTION,
+  SPAN_POINTER_DIRECTION_NAME,
+} = require('../../dd-trace/src/constants')
+const {
+  incrementWebSocketCounter,
+  buildWebSocketSpanPointerHash,
+  hasDistributedTracingContext,
+} = require('./util')
+
+class WSClosePlugin extends TracingPlugin {
+  static get id () { return 'ws' }
+  static get prefix () { return 'tracing:ws:close' }
+  static get type () { return 'websocket' }
+  static get kind () { return 'close' }
+
+  bindStart (ctx) {
+    const {
+      traceWebsocketMessagesInheritSampling,
+      traceWebsocketMessagesSeparateTraces,
+    } = this.config
+
+    const { code, data, socket, isPeerClose } = ctx
+    if (!socket?.spanContext) return
+
+    const spanKind = isPeerClose ? 'consumer' : 'producer'
+    const spanTags = socket.spanTags
+    const path = spanTags['resource.name'].split(' ')[1]
+    const service = this.serviceName({ pluginConfig: this.config })
+    const span = this.startSpan(this.operationName(), {
+      service,
+      meta: {
+        'resource.name': `websocket ${path}`,
+        'span.type': 'websocket',
+        'span.kind': spanKind,
+        'websocket.close.code': code,
+
+      },
+    }, ctx)
+
+    if (data?.toString().length > 0) {
+      span.setTag('websocket.close.reason', data.toString())
+    }
+
+    if (isPeerClose && traceWebsocketMessagesInheritSampling && traceWebsocketMessagesSeparateTraces) {
+      span.setTag('_dd.dm.service', spanTags['service.name'] || service)
+      span.setTag('_dd.dm.resource', spanTags['resource.name'] || `websocket ${path}`)
+      span.setTag('_dd.dm.inherited', 1)
+    }
+
+    ctx.span = span
+    return ctx.currentStore
+  }
+
+  bindAsyncStart (ctx) {
+    if (!ctx.isPeerClose) ctx.span.finish()
+    return ctx.parentStore
+  }
+
+  asyncStart (ctx) {
+    ctx.span.finish()
+  }
+
+  end (ctx) {
+    if (!Object.hasOwn(ctx, 'result') || !ctx.span) return
+
+    if (ctx.socket.spanContext) {
+      const linkAttributes = {}
+
+      // Determine link kind based on whether this is peer close (incoming) or self close (outgoing)
+      const isIncoming = ctx.isPeerClose
+      linkAttributes['dd.kind'] = isIncoming ? 'executed_by' : 'resuming'
+
+      // Add span pointer for context propagation
+      if (this.config.traceWebsocketMessagesEnabled && ctx.socket.spanContext) {
+        const handshakeContext = ctx.socket.spanContext
+
+        // Only add span pointers if distributed tracing is enabled and handshake has distributed context
+        if (hasDistributedTracingContext(handshakeContext, ctx.socket)) {
+          const counterType = isIncoming ? 'receiveCounter' : 'sendCounter'
+          const counter = incrementWebSocketCounter(ctx.socket, counterType)
+
+          const ptrHash = buildWebSocketSpanPointerHash(
+            handshakeContext._traceId,
+            handshakeContext._spanId,
+            counter,
+            true, // isServer
+            isIncoming
+          )
+
+          const directionName = isIncoming
+            ? SPAN_POINTER_DIRECTION_NAME.UPSTREAM
+            : SPAN_POINTER_DIRECTION_NAME.DOWNSTREAM
+          const direction = isIncoming
+            ? SPAN_POINTER_DIRECTION.UPSTREAM
+            : SPAN_POINTER_DIRECTION.DOWNSTREAM
+
+          // Add span pointer attributes to link
+          linkAttributes['link.name'] = directionName
+          linkAttributes['dd.kind'] = 'span-pointer'
+          linkAttributes['ptr.kind'] = WEBSOCKET_PTR_KIND
+          linkAttributes['ptr.dir'] = direction
+          linkAttributes['ptr.hash'] = ptrHash
+        }
+      }
+
+      ctx.span.addLink({
+        context: ctx.socket.spanContext,
+        attributes: linkAttributes,
+      })
+    }
+
+    ctx.span.finish()
+  }
+}
+
+module.exports = WSClosePlugin

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

@@ -0,0 +1,30 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+
+const WSServerPlugin = require('./server')
+const WSProducerPlugin = require('./producer')
+const WSReceiverPlugin = require('./receiver')
+const WSClosePlugin = require('./close')
+
+class WSPlugin extends CompositePlugin {
+  static get id () { return 'ws' }
+  static get plugins () {
+    return {
+      server: WSServerPlugin,
+      producer: WSProducerPlugin,
+      receiver: WSReceiverPlugin,
+      close: WSClosePlugin,
+    }
+  }
+
+  configure (config) {
+    if (!config.traceWebsocketMessagesEnabled) {
+      super.configure(false)
+      return
+    }
+    return super.configure(config)
+  }
+}
+
+module.exports = WSPlugin