dd-trace 4.6.0 → 4.8.0

package/packages/dd-trace/src/appsec/iast/telemetry/namespaces.js

@@ -0,0 +1,76 @@
+'use strict'
+
+const log = require('../../../log')
+const { Namespace } = require('../../../telemetry/metrics')
+const { addMetricsToSpan, filterTags } = require('./span-tags')
+const { IAST_TRACE_METRIC_PREFIX } = require('../tags')
+
+const DD_IAST_METRICS_NAMESPACE = Symbol('_dd.iast.request.metrics.namespace')
+
+function initRequestNamespace (context) {
+  if (!context) return
+
+  const namespace = new Namespace('iast')
+  context[DD_IAST_METRICS_NAMESPACE] = namespace
+  return namespace
+}
+
+function getNamespaceFromContext (context) {
+  return context && context[DD_IAST_METRICS_NAMESPACE]
+}
+
+function finalizeRequestNamespace (context, rootSpan) {
+  try {
+    const namespace = getNamespaceFromContext(context)
+    if (!namespace) return
+
+    const metrics = [...namespace.metrics.values()]
+    namespace.metrics.clear()
+
+    addMetricsToSpan(rootSpan, metrics, IAST_TRACE_METRIC_PREFIX)
+
+    merge(metrics)
+  } catch (e) {
+    log.error(e)
+  } finally {
+    if (context) {
+      delete context[DD_IAST_METRICS_NAMESPACE]
+    }
+  }
+}
+
+function merge (metrics) {
+  metrics.forEach(metric => metric.points.forEach(point => {
+    globalNamespace
+      .count(metric.metric, getTagsObject(metric.tags))
+      .inc(point[1])
+  }))
+}
+
+function getTagsObject (tags) {
+  if (tags && tags.length > 0) {
+    return filterTags(tags)
+  }
+}
+
+class IastNamespace extends Namespace {
+  constructor () {
+    super('iast')
+  }
+
+  reset () {
+    this.metrics.clear()
+    this.distributions.clear()
+  }
+}
+
+const globalNamespace = new IastNamespace()
+
+module.exports = {
+  initRequestNamespace,
+  getNamespaceFromContext,
+  finalizeRequestNamespace,
+  globalNamespace,
+
+  DD_IAST_METRICS_NAMESPACE
+}

package/packages/dd-trace/src/appsec/iast/telemetry/span-tags.js

@@ -0,0 +1,53 @@
+'use strict'
+
+function addMetricsToSpan (rootSpan, metrics, tagPrefix) {
+  if (!rootSpan || !rootSpan.addTags || !metrics) return
+
+  const flattenMap = new Map()
+  metrics
+    .filter(data => data && data.metric)
+    .forEach(data => {
+      const name = taggedMetricName(data)
+      let total = flattenMap.get(name)
+      const value = flatten(data)
+      if (!total) {
+        total = value
+      } else {
+        total += value
+      }
+      flattenMap.set(name, total)
+    })
+
+  for (const [key, value] of flattenMap) {
+    const tagName = `${tagPrefix}.${key}`
+    rootSpan.addTags({
+      [tagName]: value
+    })
+  }
+}
+
+function flatten (metricData) {
+  return metricData.points && metricData.points.map(point => point[1]).reduce((total, value) => total + value, 0)
+}
+
+function taggedMetricName (data) {
+  const metric = data.metric
+  const tags = data.tags && filterTags(data.tags)
+  return !tags || !tags.length
+    ? metric
+    : `${metric}.${processTagValue(tags)}`
+}
+
+function filterTags (tags) {
+  return tags.filter(tag => !tag.startsWith('lib_language') && !tag.startsWith('version'))
+}
+
+function processTagValue (tags) {
+  return tags.map(tag => tag.includes(':') ? tag.split(':')[1] : tag)
+    .join('_').replace(/\./g, '_')
+}
+
+module.exports = {
+  addMetricsToSpan,
+  filterTags
+}

package/packages/dd-trace/src/appsec/iast/telemetry/verbosity.js

@@ -0,0 +1,42 @@
+'use strict'
+
+const Verbosity = {
+  OFF: 0,
+  MANDATORY: 1,
+  INFORMATION: 2,
+  DEBUG: 3
+}
+
+function isDebugAllowed (value) {
+  return value >= Verbosity.DEBUG
+}
+
+function isInfoAllowed (value) {
+  return value >= Verbosity.INFORMATION
+}
+
+function getVerbosity (verbosity) {
+  if (verbosity) {
+    verbosity = verbosity.toUpperCase()
+    return Verbosity[verbosity] !== undefined ? Verbosity[verbosity] : Verbosity.INFORMATION
+  } else {
+    return Verbosity.INFORMATION
+  }
+}
+
+function getName (verbosityValue) {
+  for (const name in Verbosity) {
+    if (Verbosity[name] === verbosityValue) {
+      return name
+    }
+  }
+  return 'OFF'
+}
+
+module.exports = {
+  Verbosity,
+  isDebugAllowed,
+  isInfoAllowed,
+  getVerbosity,
+  getName
+}

package/packages/dd-trace/src/appsec/iast/vulnerabilities-formatter/index.js

@@ -54,7 +54,11 @@ class VulnerabilityFormatter {
 
   formatEvidence (type, evidence, sourcesIndexes, sources) {
     if (!evidence.ranges) {
-      return { value: evidence.value }
+      if (typeof evidence.value === 'undefined') {
+        return undefined
+      } else {
+        return { value: evidence.value }
+      }
     }
 
     return this._redactVulnearbilities

package/packages/dd-trace/src/appsec/iast/vulnerabilities.js

@@ -1,5 +1,6 @@
 module.exports = {
   COMMAND_INJECTION: 'COMMAND_INJECTION',
+  HSTS_HEADER_MISSING: 'HSTS_HEADER_MISSING',
   INSECURE_COOKIE: 'INSECURE_COOKIE',
   LDAP_INJECTION: 'LDAP_INJECTION',
   NO_HTTPONLY_COOKIE: 'NO_HTTPONLY_COOKIE',
@@ -9,5 +10,6 @@ module.exports = {
   SSRF: 'SSRF',
   UNVALIDATED_REDIRECT: 'UNVALIDATED_REDIRECT',
   WEAK_CIPHER: 'WEAK_CIPHER',
-  WEAK_HASH: 'WEAK_HASH'
+  WEAK_HASH: 'WEAK_HASH',
+  XCONTENTTYPE_HEADER_MISSING: 'XCONTENTTYPE_HEADER_MISSING'
 }

package/packages/dd-trace/src/appsec/iast/vulnerability-reporter.js

@@ -28,7 +28,7 @@ function addVulnerability (iastContext, vulnerability) {
 
 function isValidVulnerability (vulnerability) {
   return vulnerability && vulnerability.type &&
-    vulnerability.evidence && vulnerability.evidence.value &&
+    vulnerability.evidence &&
     vulnerability.location && vulnerability.location.spanId
 }
 

package/packages/dd-trace/src/config.js

@@ -247,6 +247,10 @@ class Config {
       process.env.DD_TELEMETRY_DEBUG,
       false
     )
+    const DD_TELEMETRY_METRICS_ENABLED = coalesce(
+      process.env.DD_TELEMETRY_METRICS_ENABLED,
+      false
+    )
     const DD_TRACE_AGENT_PROTOCOL_VERSION = coalesce(
       options.protocolVersion,
       process.env.DD_TRACE_AGENT_PROTOCOL_VERSION,
@@ -277,7 +281,7 @@ class Config {
       process.env.DD_TRACE_EXPERIMENTAL_B3_ENABLED,
       false
     )
-    const defaultPropagationStyle = ['tracecontext', 'datadog']
+    const defaultPropagationStyle = ['datadog', 'tracecontext']
     if (isTrue(DD_TRACE_B3_ENABLED)) {
       defaultPropagationStyle.push('b3')
       defaultPropagationStyle.push('b3 single header')
@@ -317,13 +321,38 @@ class Config {
       false
     )
     const DD_TRACE_SPAN_ATTRIBUTE_SCHEMA = validateNamingVersion(
-      process.env.DD_TRACE_SPAN_ATTRIBUTE_SCHEMA
+      coalesce(
+        options.spanAttributeSchema,
+        process.env.DD_TRACE_SPAN_ATTRIBUTE_SCHEMA
+      )
+    )
+    const DD_TRACE_PEER_SERVICE_MAPPING = coalesce(
+      options.peerServiceMapping,
+      process.env.DD_TRACE_PEER_SERVICE_MAPPING ? fromEntries(
+        process.env.DD_TRACE_PEER_SERVICE_MAPPING.split(',').map(x => x.trim().split(':'))
+      ) : {}
+    )
+
+    const peerServiceSet = (
+      options.hasOwnProperty('spanComputePeerService') ||
+      process.env.hasOwnProperty('DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED')
+    )
+    const peerServiceValue = coalesce(
+      options.spanComputePeerService,
+      process.env.DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED
+    )
+
+    const DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED = (
+      DD_TRACE_SPAN_ATTRIBUTE_SCHEMA === 'v0'
+        // In v0, peer service is computed only if it is explicitly set to true
+        ? peerServiceSet && isTrue(peerServiceValue)
+        // In >v0, peer service is false only if it is explicitly set to false
+        : (peerServiceSet ? !isFalse(peerServiceValue) : true)
     )
-    const DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED = process.env.DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED
 
     const DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED = coalesce(
-      isTrue(process.env.DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED),
-      false
+      options.spanRemoveIntegrationFromService,
+      isTrue(process.env.DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED)
     )
     const DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH = coalesce(
       process.env.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH,
@@ -461,6 +490,12 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
       true
     )
 
+    const DD_IAST_TELEMETRY_VERBOSITY = coalesce(
+      iastOptions && iastOptions.telemetryVerbosity,
+      process.env.DD_IAST_TELEMETRY_VERBOSITY,
+      'INFORMATION'
+    )
+
     const DD_CIVISIBILITY_GIT_UPLOAD_ENABLED = coalesce(
       process.env.DD_CIVISIBILITY_GIT_UPLOAD_ENABLED,
       true
@@ -549,11 +584,9 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
       exporters: DD_PROFILING_EXPORTERS
     }
     this.spanAttributeSchema = DD_TRACE_SPAN_ATTRIBUTE_SCHEMA
-    this.spanComputePeerService = (this.spanAttributeSchema === 'v0'
-      ? isTrue(DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED)
-      : true
-    )
-    this.traceRemoveIntegrationServiceNamesEnabled = DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED
+    this.spanComputePeerService = DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED
+    this.spanRemoveIntegrationFromService = DD_TRACE_REMOVE_INTEGRATION_SERVICE_NAMES_ENABLED
+    this.peerServiceMapping = DD_TRACE_PEER_SERVICE_MAPPING
     this.lookup = options.lookup
     this.startupLogs = isTrue(DD_TRACE_STARTUP_LOGS)
     // Disabled for CI Visibility's agentless
@@ -561,7 +594,8 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
       enabled: DD_TRACE_EXPORTER !== 'datadog' && isTrue(DD_TRACE_TELEMETRY_ENABLED),
       heartbeatInterval: DD_TELEMETRY_HEARTBEAT_INTERVAL,
       logCollection: isTrue(DD_TELEMETRY_LOG_COLLECTION_ENABLED),
-      debug: isTrue(DD_TELEMETRY_DEBUG)
+      debug: isTrue(DD_TELEMETRY_DEBUG),
+      metrics: isTrue(DD_TELEMETRY_METRICS_ENABLED)
     }
     this.protocolVersion = DD_TRACE_AGENT_PROTOCOL_VERSION
     this.tagsHeaderMaxLength = parseInt(DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH)
@@ -590,7 +624,8 @@ ken|consumer_?(?:id|key|secret)|sign(?:ed|ature)?|auth(?:entication|orization)?)
       maxConcurrentRequests: DD_IAST_MAX_CONCURRENT_REQUESTS,
       maxContextOperations: DD_IAST_MAX_CONTEXT_OPERATIONS,
       deduplicationEnabled: DD_IAST_DEDUPLICATION_ENABLED,
-      redactionEnabled: DD_IAST_REDACTION_ENABLED
+      redactionEnabled: DD_IAST_REDACTION_ENABLED,
+      telemetryVerbosity: DD_IAST_TELEMETRY_VERBOSITY
     }
 
     this.isCiVisibility = isTrue(DD_IS_CIVISIBILITY)

package/packages/dd-trace/src/constants.js

@@ -28,6 +28,7 @@ module.exports = {
   CLIENT_PORT_KEY: 'network.destination.port',
   PEER_SERVICE_KEY: 'peer.service',
   PEER_SERVICE_SOURCE_KEY: '_dd.peer.service.source',
+  PEER_SERVICE_REMAP_KEY: '_dd.peer.service.remapped_from',
   SCI_REPOSITORY_URL: '_dd.git.repository_url',
   SCI_COMMIT_SHA: '_dd.git.commit.sha'
 }

package/packages/dd-trace/src/external-logger/src/index.js

@@ -127,4 +127,12 @@ class ExternalLogger {
   }
 }
 
-module.exports = ExternalLogger
+class NoopExternalLogger {
+  log () { }
+  enqueue () { }
+  shutdown () { }
+  flush () { }
+}
+
+module.exports.ExternalLogger = ExternalLogger
+module.exports.NoopExternalLogger = NoopExternalLogger

package/packages/dd-trace/src/external-logger/test/index.spec.js

@@ -15,7 +15,7 @@ describe('External Logger', () => {
   beforeEach(() => {
     errorLog = sinon.spy(tracerLogger, 'error')
 
-    const ExternalLogger = proxyquire('../src', {
+    const { ExternalLogger } = proxyquire('../src', {
       '../../log': {
         error: errorLog
       }

package/packages/dd-trace/src/format.js

@@ -107,7 +107,7 @@ function extractTags (trace, span) {
     }
   }
 
-  setSingleSpanIngestionTags(trace, context._sampling.spanSampling)
+  setSingleSpanIngestionTags(trace, context._spanSampling)
 
   addTag(trace.meta, trace.metrics, 'language', 'javascript')
   addTag(trace.meta, trace.metrics, PROCESS_ID, process.pid)

package/packages/dd-trace/src/lambda/handler.js

@@ -86,6 +86,13 @@ exports.datadog = function datadog (lambdaHandler) {
     const context = extractContext(args)
 
     checkTimeout(context)
-    return lambdaHandler.apply(this, args).then((res) => { clearTimeout(__lambdaTimeout); return res })
+    const result = lambdaHandler.apply(this, args)
+    if (result && typeof result.then === 'function') {
+      return result.then((res) => {
+        clearTimeout(__lambdaTimeout)
+        return res
+      })
+    }
+    return result
   }
 }

package/packages/dd-trace/src/opentelemetry/span.js

@@ -10,6 +10,7 @@ const { timeInputToHrTime } = require('@opentelemetry/core')
 const tracer = require('../../')
 const DatadogSpan = require('../opentracing/span')
 const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../constants')
+const { SERVICE_NAME, RESOURCE_NAME } = require('../../../../ext/tags')
 
 const SpanContext = require('./span_context')
 
@@ -40,7 +41,8 @@ class Span {
       hostname: _tracer._hostname,
       integrationName: 'otel',
       tags: {
-        'service.name': _tracer._service
+        [SERVICE_NAME]: _tracer._service,
+        [RESOURCE_NAME]: spanName
       }
     }, _tracer._debug)
 

package/packages/dd-trace/src/opentracing/span_context.js

@@ -12,7 +12,8 @@ class DatadogSpanContext {
     this._name = props.name
     this._isFinished = props.isFinished || false
     this._tags = props.tags || {}
-    this._sampling = Object.assign({}, props.sampling)
+    this._sampling = props.sampling || {}
+    this._spanSampling = undefined
     this._baggageItems = props.baggageItems || {}
     this._traceparent = props.traceparent
     this._tracestate = props.tracestate

package/packages/dd-trace/src/opentracing/tracer.js

@@ -27,6 +27,7 @@ class DatadogTracer {
     this._env = config.env
     this._tags = config.tags
     this._computePeerService = config.spanComputePeerService
+    this._peerServiceMapping = config.peerServiceMapping
     this._logInjection = config.logInjection
     this._debug = config.debug
     this._prioritySampler = new PrioritySampler(config.env, config.sampler)

package/packages/dd-trace/src/plugins/ci_plugin.js

@@ -111,7 +111,12 @@ module.exports = class CiPlugin extends Plugin {
     const childOf = getTestParentSpan(this.tracer)
 
     let testTags = {
-      ...getTestCommonTags(testName, testSuite, this.frameworkVersion),
+      ...getTestCommonTags(
+        testName,
+        testSuite,
+        this.frameworkVersion,
+        this.constructor.id
+      ),
       [COMPONENT]: this.constructor.id,
       ...extraTags
     }

package/packages/dd-trace/src/plugins/outbound.js

@@ -3,7 +3,8 @@
 const {
   CLIENT_PORT_KEY,
   PEER_SERVICE_KEY,
-  PEER_SERVICE_SOURCE_KEY
+  PEER_SERVICE_SOURCE_KEY,
+  PEER_SERVICE_REMAP_KEY
 } = require('../constants')
 const TracingPlugin = require('./tracing')
 
@@ -34,9 +35,11 @@ class OutboundPlugin extends TracingPlugin {
      * - If `peer.service` was defined _before_ we compute it (for example in custom instrumentation),
      *   `_dd.peer.service.source`'s value is `peer.service`
      */
-
-    if (tags['peer.service'] !== undefined) {
-      return { [PEER_SERVICE_SOURCE_KEY]: 'peer.service' }
+    if (tags[PEER_SERVICE_KEY] !== undefined) {
+      return {
+        [PEER_SERVICE_KEY]: tags[PEER_SERVICE_KEY],
+        [PEER_SERVICE_SOURCE_KEY]: PEER_SERVICE_KEY
+      }
     }
 
     const sourceTags = [
@@ -52,23 +55,37 @@ class OutboundPlugin extends TracingPlugin {
         }
       }
     }
-    return {}
+    return undefined
   }
 
-  startSpan (name, options) {
-    const span = super.startSpan(name, options)
-    return span
+  getPeerServiceRemap (peerData) {
+    /**
+     * If DD_TRACE_PEER_SERVICE_MAPPING is matched, we need to override the existing
+     * peer service and add the value we overrode.
+     */
+    const peerService = peerData[PEER_SERVICE_KEY]
+    if (peerService && this.tracer._peerServiceMapping[peerService]) {
+      return {
+        ...peerData,
+        [PEER_SERVICE_KEY]: this.tracer._peerServiceMapping[peerService],
+        [PEER_SERVICE_REMAP_KEY]: peerService
+      }
+    }
+    return peerData
   }
 
   finish () {
-    const span = this.activeSpan
+    this.tagPeerService(this.activeSpan)
+    super.finish(...arguments)
+  }
+
+  tagPeerService (span) {
     if (this.tracer._computePeerService) {
       const peerData = this.getPeerService(span.context()._tags)
-      if (peerData) {
-        span.addTags(peerData)
+      if (peerData !== undefined) {
+        span.addTags(this.getPeerServiceRemap(peerData))
       }
     }
-    super.finish(...arguments)
   }
 
   connect (url) {

package/packages/dd-trace/src/plugins/plugin.js

@@ -25,9 +25,31 @@ class Subscription {
   }
 }
 
+class StoreBinding {
+  constructor (event, transform) {
+    this._channel = dc.channel(event)
+    this._transform = data => {
+      const store = storage.getStore()
+
+      return !store || !store.noop
+        ? transform(data)
+        : store
+    }
+  }
+
+  enable () {
+    this._channel.bindStore(storage, this._transform)
+  }
+
+  disable () {
+    this._channel.unbindStore(storage, this._transform)
+  }
+}
+
 module.exports = class Plugin {
   constructor (tracer, tracerConfig) {
     this._subscriptions = []
+    this._bindings = []
     this._enabled = false
     this._tracer = tracer
     this.config = {} // plugin-specific configuration, unset until .configure() is called
@@ -53,6 +75,10 @@ module.exports = class Plugin {
     this._subscriptions.push(new Subscription(channelName, handler))
   }
 
+  addBind (channelName, transform) {
+    this._bindings.push(new StoreBinding(channelName, transform))
+  }
+
   addError (error) {
     const store = storage.getStore()
 
@@ -71,9 +97,11 @@ module.exports = class Plugin {
     if (config.enabled && !this._enabled) {
       this._enabled = true
       this._subscriptions.forEach(sub => sub.enable())
+      this._bindings.forEach(sub => sub.enable())
     } else if (!config.enabled && this._enabled) {
       this._enabled = false
       this._subscriptions.forEach(sub => sub.disable())
+      this._bindings.forEach(sub => sub.disable())
     }
   }
 }

package/packages/dd-trace/src/plugins/tracing.js

@@ -13,17 +13,7 @@ class TracingPlugin extends Plugin {
     this.component = this.constructor.component || this.constructor.id
     this.operation = this.constructor.operation
 
-    this.addTraceSub('start', message => {
-      this.start(message)
-    })
-
-    this.addTraceSub('error', err => {
-      this.error(err)
-    })
-
-    this.addTraceSub('finish', message => {
-      this.finish(message)
-    })
+    this.addTraceSubs()
   }
 
   get activeSpan () {
@@ -65,19 +55,43 @@ class TracingPlugin extends Plugin {
     this.addError(error)
   }
 
+  addTraceSubs () {
+    const events = ['start', 'end', 'asyncStart', 'asyncEnd', 'error', 'finish']
+
+    for (const event of events) {
+      const bindName = `bind${event.charAt(0).toUpperCase()}${event.slice(1)}`
+
+      if (this[event]) {
+        this.addTraceSub(event, message => {
+          this[event](message)
+        })
+      }
+
+      if (this[bindName]) {
+        this.addTraceBind(event, message => this[bindName](message))
+      }
+    }
+  }
+
   addTraceSub (eventName, handler) {
-    this.addSub(`apm:${this.component}:${this.operation}:${eventName}`, handler)
+    const prefix = this.constructor.prefix || `apm:${this.component}:${this.operation}`
+    this.addSub(`${prefix}:${eventName}`, handler)
   }
 
-  addError (error) {
-    const span = this.activeSpan
+  addTraceBind (eventName, transform) {
+    const prefix = this.constructor.prefix || `apm:${this.component}:${this.operation}`
+    this.addBind(`${prefix}:${eventName}`, transform)
+  }
 
+  addError (error, span = this.activeSpan) {
     if (!span._spanContext._tags['error']) {
+      // Errors may be wrapped in a context.
+      error = (error && error.error) || error
       span.setTag('error', error || 1)
     }
   }
 
-  startSpan (name, { childOf, kind, meta, metrics, service, resource, type } = {}) {
+  startSpan (name, { childOf, kind, meta, metrics, service, resource, type } = {}, enter = true) {
     const store = storage.getStore()
 
     if (store && childOf === undefined) {
@@ -100,7 +114,10 @@ class TracingPlugin extends Plugin {
 
     analyticsSampler.sample(span, this.config.measured)
 
-    storage.enterWith({ ...store, span })
+    // TODO: Remove this after migration to TracingChannel is done.
+    if (enter) {
+      storage.enterWith({ ...store, span })
+    }
 
     return span
   }

package/packages/dd-trace/src/plugins/util/ci.js

@@ -77,7 +77,7 @@ function filterSensitiveInfoFromRepository (repositoryUrl) {
 
     return `${protocol}//${hostname}${pathname}`
   } catch (e) {
-    return repositoryUrl
+    return ''
   }
 }
 
@@ -399,6 +399,7 @@ module.exports = {
         BITBUCKET_BRANCH,
         BITBUCKET_COMMIT,
         BITBUCKET_GIT_SSH_ORIGIN,
+        BITBUCKET_GIT_HTTP_ORIGIN,
         BITBUCKET_TAG,
         BITBUCKET_PIPELINE_UUID,
         BITBUCKET_CLONE_DIR
@@ -416,7 +417,7 @@ module.exports = {
         [CI_PIPELINE_URL]: url,
         [GIT_BRANCH]: BITBUCKET_BRANCH,
         [GIT_TAG]: BITBUCKET_TAG,
-        [GIT_REPOSITORY_URL]: BITBUCKET_GIT_SSH_ORIGIN,
+        [GIT_REPOSITORY_URL]: BITBUCKET_GIT_SSH_ORIGIN || BITBUCKET_GIT_HTTP_ORIGIN,
         [CI_WORKSPACE_PATH]: BITBUCKET_CLONE_DIR,
         [CI_PIPELINE_ID]: BITBUCKET_PIPELINE_UUID && BITBUCKET_PIPELINE_UUID.replace(/{|}/gm, '')
       }