Service Mapping for Source Code Integration

Containers

If you are using Docker containers, you have three options: using Docker, using the Datadog SDK, or configuring your application with DD_GIT_* environment variables.

Option 1: Docker

You can embed git information in your Docker image using either build arguments with environment variables, or image labels.

Using build arguments and environment variables

1. Add the following lines to your application’s Dockerfile:

   ARG DD_GIT_REPOSITORY_URLARG DD_GIT_COMMIT_SHAENV DD_GIT_REPOSITORY_URL=${DD_GIT_REPOSITORY_URL} ENV DD_GIT_COMMIT_SHA=${DD_GIT_COMMIT_SHA}

2. Add the following arguments to your Docker build command:

   docker build . \
    -t my-application \
    --build-arg DD_GIT_REPOSITORY_URL=<git-provider.example/me/my-repo> \
    --build-arg DD_GIT_COMMIT_SHA=$(git rev-parse HEAD)
   

Using image labels

This approach requires Docker, or containerd >= 1.5.6. It doesn’t support containers running on AWS Fargate.

Datadog can extract source code information directly from your images’ Docker labels. During build time, follow the Open Containers standard to add the git commit SHA and repository URL as Docker labels:

docker build . \
 -t my-application \
 --label org.opencontainers.image.revision=$(git rev-parse HEAD) \
 --label org.opencontainers.image.source=$(git config --get remote.origin.url)

Option 2: Datadog SDK

Go embeds version control information in binaries since version 1.18. The Datadog tracing library uses this information to tag your telemetry with the latest commit SHA and repository URL.

Ensure your service meets the following requirements to use this approach:

• Go version is 1.18 or later.
• The service is built as a go module and the module path is your code’s repository URL.

Option 3: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Serverless

If you are using Serverless, you have three options depending on your serverless application’s setup.

Option 1: Datadog tooling

Datadog CLI tool

Use the datadog-ci client version 2.10.0 or later. You must run the CLI tool in the same directory as the code repository.

Datadog Serverless Plugin

Use the plugin version 5.60.0 or later.

Datadog CDK Construct

Use the datadog-cdk-constructs version 0.8.5 or later for AWS CDK v1.
Use the datadog-cdk-constructs version 1.4.0 or later for AWS CDK v2.

Option 2: Datadog SDK

Go embeds version control information in binaries since version 1.18. The Datadog tracing library uses this information to tag your telemetry with the latest commit SHA and repository URL.

Ensure your service meets the following requirements to use this approach:

• Go version is 1.18 or later.
• The service is built as a go module and the module path is your code’s repository URL.

Option 3: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Host

If you are using a host, you have two options.

Option 1: Datadog SDK

Go embeds version control information in binaries since version 1.18. The Datadog tracing library uses this information to tag your telemetry with the latest commit SHA and repository URL.

Ensure your service meets the following requirements to use this approach:

• Go version is 1.18 or later.
• The service is built as a go module and the module path is your code’s repository URL.

Option 2: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Containers

If you are using Docker containers, you have three options: using Docker, using Setuptools, or configuring your application with DD_GIT_* environment variables.

Option 1: Docker

You can embed git information in your Docker image using either build arguments with environment variables, or image labels.

Using build arguments and environment variables

1. Add the following lines to your application’s Dockerfile:

   ARG DD_GIT_REPOSITORY_URLARG DD_GIT_COMMIT_SHAENV DD_GIT_REPOSITORY_URL=${DD_GIT_REPOSITORY_URL} ENV DD_GIT_COMMIT_SHA=${DD_GIT_COMMIT_SHA}

2. Add the following arguments to your Docker build command:

   docker build . \
    -t my-application \
    --build-arg DD_GIT_REPOSITORY_URL=<git-provider.example/me/my-repo> \
    --build-arg DD_GIT_COMMIT_SHA=$(git rev-parse HEAD)
   

Using image labels

This approach requires Docker, or containerd >= 1.5.6. It doesn’t support containers running on AWS Fargate.

Datadog can extract source code information directly from your images’ Docker labels. During build time, follow the Open Containers standard to add the git commit SHA and repository URL as Docker labels:

docker build . \
 -t my-application \
 --label org.opencontainers.image.revision=$(git rev-parse HEAD) \
 --label org.opencontainers.image.source=$(git config --get remote.origin.url)

Option 2: Setuptools or unified Python project settings file

If your application is packaged with setuptools:

1. Install the dd-trace package.
2. Add import ddtrace.sourcecode.setuptools_auto as the first import to the setup.py file.
3. Set the DD_MAIN_PACKAGE environment variable as the name of the primary Python package.

If your application is using a unified Python project settings file:

1. Install the hatch-datadog-build-metadata plugin and configure it to embed git metadata. If a project already has URLs, reconfigure them as dynamic and move them to another configuration section. For more information, see the plugin source code.
2. Set the DD_MAIN_PACKAGE environment variable as the name of the primary Python package.

Option 3: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Serverless

If you are using Serverless, you have three options depending on your serverless application’s setup.

Option 1: Datadog tooling

Datadog CLI tool

Use the datadog-ci client version 2.10.0 or later. You must run the CLI tool in the same directory as the code repository.

Datadog Serverless Plugin

Use the plugin version 5.60.0 or later.

Datadog CDK Construct

Use the datadog-cdk-constructs version 0.8.5 or later for AWS CDK v1.
Use the datadog-cdk-constructs version 1.4.0 or later for AWS CDK v2.

Option 2: Setuptools or unified Python project settings file

If your application is packaged with setuptools:

1. Install the dd-trace package.
2. Add import ddtrace.sourcecode.setuptools_auto as the first import to the setup.py file.
3. Set the DD_MAIN_PACKAGE environment variable as the name of the primary Python package.

If your application is using a unified Python project settings file:

1. Install the hatch-datadog-build-metadata plugin and configure it to embed git metadata. If a project already has URLs, reconfigure them as dynamic and move them to another configuration section. For more information, see the plugin source code.
2. Set the DD_MAIN_PACKAGE environment variable as the name of the primary Python package.

Option 3: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Host

If you are using a host, you have two options.

Option 1: Setuptools or unified Python project settings file

If your application is packaged with setuptools:

1. Install the dd-trace package.
2. Add import ddtrace.sourcecode.setuptools_auto as the first import to the setup.py file.
3. Set the DD_MAIN_PACKAGE environment variable as the name of the primary Python package.

If your application is using a unified Python project settings file:

1. Install the hatch-datadog-build-metadata plugin and configure it to embed git metadata. If a project already has URLs, reconfigure them as dynamic and move them to another configuration section. For more information, see the plugin source code.
2. Set the DD_MAIN_PACKAGE environment variable as the name of the primary Python package.

Option 2: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

As a first step, ensure that your .pdb files are deployed alongside your .NET assemblies (.dll or .exe) in the same folder. Then, follow the rest of the instructions based on your specific deployment model:

Containers

If you are using Docker containers, you have three options: using Docker, using Microsoft SourceLink, or configuring your application with DD_GIT_* environment variables.

Option 1: Docker

You can embed git information in your Docker image using either build arguments with environment variables, or image labels.

Using build arguments and environment variables

1. Add the following lines to your application’s Dockerfile:

   ARG DD_GIT_REPOSITORY_URLARG DD_GIT_COMMIT_SHAENV DD_GIT_REPOSITORY_URL=${DD_GIT_REPOSITORY_URL} ENV DD_GIT_COMMIT_SHA=${DD_GIT_COMMIT_SHA}

2. Add the following arguments to your Docker build command:

   docker build . \
    -t my-application \
    --build-arg DD_GIT_REPOSITORY_URL=<git-provider.example/me/my-repo> \
    --build-arg DD_GIT_COMMIT_SHA=$(git rev-parse HEAD)
   

Using image labels

This approach requires Docker, or containerd >= 1.5.6. It doesn’t support containers running on AWS Fargate.

Datadog can extract source code information directly from your images’ Docker labels. During build time, follow the Open Containers standard to add the git commit SHA and repository URL as Docker labels:

docker build . \
 -t my-application \
 --label org.opencontainers.image.revision=$(git rev-parse HEAD) \
 --label org.opencontainers.image.source=$(git config --get remote.origin.url)

Option 2: Microsoft SourceLink

If you are using Microsoft SourceLink, Datadog can extract the git commit SHA and repository URL from your .NET assembly.

1. Open your project’s file (.csproj) in an IDE and add a reference to one of the following NuGet packages, depending on where your git repository is hosted:

   Provider	Microsoft SourceLink
   GitHub	Microsoft.SourceLink.GitHub
   Bitbucket	Microsoft.SourceLink.Bitbucket.Git
   GitLab	Microsoft.SourceLink.GitLab
   Azure DevOps	Microsoft.SourceLink.AzureRepos.Git
   Azure DevOps Server	Microsoft.SourceLink.AzureDevOpsServer.Git

Option 3: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Serverless

If you are using Serverless, you have three options depending on your serverless application’s setup.

Option 1: Datadog tooling

Datadog CLI tool

Use the datadog-ci client version 2.10.0 or later. You must run the CLI tool in the same directory as the code repository.

Datadog Serverless Plugin

Use the plugin version 5.60.0 or later.

Datadog CDK Construct

Use the datadog-cdk-constructs version 0.8.5 or later for AWS CDK v1.
Use the datadog-cdk-constructs version 1.4.0 or later for AWS CDK v2.

Option 2: Microsoft SourceLink

If you are using Microsoft SourceLink, Datadog can extract the git commit SHA and repository URL from your .NET assembly.

1. Open your project’s file (.csproj) in an IDE and add a reference to one of the following NuGet packages, depending on where your git repository is hosted:

   Provider	Microsoft SourceLink
   GitHub	Microsoft.SourceLink.GitHub
   Bitbucket	Microsoft.SourceLink.Bitbucket.Git
   GitLab	Microsoft.SourceLink.GitLab
   Azure DevOps	Microsoft.SourceLink.AzureRepos.Git
   Azure DevOps Server	Microsoft.SourceLink.AzureDevOpsServer.Git

Option 3: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Host

If you are using a host, you have two options: using Microsoft SourceLink or configuring your application with DD_GIT_* environment variables.

Option 1: Microsoft SourceLink

If you are using Microsoft SourceLink, Datadog can extract the git commit SHA and repository URL from your .NET assembly.

1. Open your project’s file (.csproj) in an IDE and add a reference to one of the following NuGet packages, depending on where your git repository is hosted:

   Provider	Microsoft SourceLink
   GitHub	Microsoft.SourceLink.GitHub
   Bitbucket	Microsoft.SourceLink.Bitbucket.Git
   GitLab	Microsoft.SourceLink.GitLab
   Azure DevOps	Microsoft.SourceLink.AzureRepos.Git
   Azure DevOps Server	Microsoft.SourceLink.AzureDevOpsServer.Git

Option 2: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Containers

If you are using Docker containers, you have three options: using a bundler plugin, using Docker, or configuring your application with DD_GIT_* environment variables.

Option 1: Bundler plugin

If you’re bundling your application from a Git directory, you can use plugins to inject Git metadata into the runtime bundle.

Bundling with esbuild

Use the dd-trace/esbuild plugin to automatically inject DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA in your runtime bundle. See the plugin documentation. Install dd-trace v5.68.0 or later for automatic Git tag injection.

const esbuild = require('esbuild');
+ const ddPlugin = require('dd-trace/esbuild');
esbuild.build({
 entryPoints: ['index.js'],
 bundle: true,
 platform: 'node',
 target: ['node20'],
 format: 'cjs',
 outfile: 'dist/bundle.js',
 packages: 'external',
 external: ['dd-trace', 'express']
+ plugins: [ddPlugin],
}).catch((e) => {
 console.error(e);
 process.exit(1);
});

Bundling with Rollup

Use rollup-plugin-inject-process-env to inject DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA in your runtime bundle. Run the bundle step inside a Git repository so the script can read .git/ information.

+ const injectProcessEnv = require('rollup-plugin-inject-process-env');
+ const { DD_GIT_REPOSITORY_URL, DD_GIT_COMMIT_SHA } = getGitInfo();
module.exports = {
 input: 'index.js',
 output: {
 file: 'dist/bundle.js',
 format: 'cjs'
 },
 external: [
 'express',
 'dd-trace'
 ],
 plugins: [
 nodeResolve(),
 commonjs()
+ injectProcessEnv({
+ DD_GIT_REPOSITORY_URL,
+ DD_GIT_COMMIT_SHA
+ })
 ]
};

The getGitInfo() function executes git commands to return DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA variables. It needs to be executed in the git repository.

const { execSync } = require('child_process');
function getGitInfo() {
 try {
 const commitSha = execSync('git rev-parse HEAD', { encoding: 'utf8' }).trim();
 const repositoryUrl = execSync('git config --get remote.origin.url', { encoding: 'utf8' }).trim();
 console.log('Build-time Git metadata:', {
 commitSha,
 repositoryUrl,
 });
 return {
 DD_GIT_REPOSITORY_URL: repositoryUrl,
 DD_GIT_COMMIT_SHA: commitSha,
 };
 } catch (error) {
 console.warn('Could not get Git metadata at build time:', error.message);
 return {
 DD_GIT_REPOSITORY_URL: '',
 DD_GIT_COMMIT_SHA: '',
 };
 }
}

Bundling with webpack

Use the BannerPlugin to inject DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA in your runtime bundle. Run the bundle step inside a Git repository so the script can read .git/ information.

+ const webpack = require('webpack');
+ const { DD_GIT_REPOSITORY_URL, DD_GIT_COMMIT_SHA } = getGitInfo();
module.exports = {
	target: 'node',
	entry: './index.js',
	mode: 'production',
	output: {
		path: path.resolve(__dirname, 'dist'),
		filename: 'bundle.js',
		libraryTarget: 'commonjs2'
	},
	externals: [
		'express',
		'dd-trace'
	],
	plugins: [
+		new webpack.BannerPlugin({
+			raw: true,
+			entryOnly: true,
+			banner:
+ `process.env.DD_GIT_REPOSITORY_URL=${JSON.stringify(DD_GIT_REPOSITORY_URL)};` +
+				 `process.env.DD_GIT_COMMIT_SHA=${JSON.stringify(DD_GIT_COMMIT_SHA)};`,
+		}),
	]
};

The getGitInfo() function executes git commands to return DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA variables. It needs to be executed in the git repository.

const { execSync } = require('child_process');
function getGitInfo() {
 try {
 const commitSha = execSync('git rev-parse HEAD', { encoding: 'utf8' }).trim();
 const repositoryUrl = execSync('git config --get remote.origin.url', { encoding: 'utf8' }).trim();
 console.log('Build-time Git metadata:', {
 commitSha,
 repositoryUrl,
 });
 return {
 DD_GIT_REPOSITORY_URL: repositoryUrl,
 DD_GIT_COMMIT_SHA: commitSha,
 };
 } catch (error) {
 console.warn('Could not get Git metadata at build time:', error.message);
 return {
 DD_GIT_REPOSITORY_URL: '',
 DD_GIT_COMMIT_SHA: '',
 };
 }
}

Option 2: Docker

You can embed git information in your Docker image using either build arguments with environment variables, or image labels.

Using build arguments and environment variables

1. Add the following lines to your application’s Dockerfile:

   ARG DD_GIT_REPOSITORY_URLARG DD_GIT_COMMIT_SHAENV DD_GIT_REPOSITORY_URL=${DD_GIT_REPOSITORY_URL} ENV DD_GIT_COMMIT_SHA=${DD_GIT_COMMIT_SHA}

2. Add the following arguments to your Docker build command:

   docker build . \
    -t my-application \
    --build-arg DD_GIT_REPOSITORY_URL=<git-provider.example/me/my-repo> \
    --build-arg DD_GIT_COMMIT_SHA=$(git rev-parse HEAD)
   

Using image labels

This approach requires Docker, or containerd >= 1.5.6. It doesn’t support containers running on AWS Fargate.

Datadog can extract source code information directly from your images’ Docker labels. During build time, follow the Open Containers standard to add the git commit SHA and repository URL as Docker labels:

docker build . \
 -t my-application \
 --label org.opencontainers.image.revision=$(git rev-parse HEAD) \
 --label org.opencontainers.image.source=$(git config --get remote.origin.url)

Option 3: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Serverless

If you are using Serverless, you have several options depending on your serverless application’s setup.

Option 1: Bundler plugin

If you’re bundling your application from a Git directory, you can use plugins to inject Git metadata into the runtime bundle.

Bundling with esbuild

Use the dd-trace/esbuild plugin to automatically inject DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA in your runtime bundle. See the plugin documentation. Install dd-trace v5.68.0 or later for automatic Git tag injection.

const esbuild = require('esbuild');
+ const ddPlugin = require('dd-trace/esbuild');
esbuild.build({
 entryPoints: ['index.js'],
 bundle: true,
 platform: 'node',
 target: ['node20'],
 format: 'cjs',
 outfile: 'dist/bundle.js',
 packages: 'external',
 external: ['dd-trace', 'express']
+ plugins: [ddPlugin],
}).catch((e) => {
 console.error(e);
 process.exit(1);
});

Bundling with Rollup

Use rollup-plugin-inject-process-env to inject DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA in your runtime bundle. Run the bundle step inside a Git repository so the script can read .git/ information.

+ const injectProcessEnv = require('rollup-plugin-inject-process-env');
+ const { DD_GIT_REPOSITORY_URL, DD_GIT_COMMIT_SHA } = getGitInfo();
module.exports = {
 input: 'index.js',
 output: {
 file: 'dist/bundle.js',
 format: 'cjs'
 },
 external: [
 'express',
 'dd-trace'
 ],
 plugins: [
 nodeResolve(),
 commonjs()
+ injectProcessEnv({
+ DD_GIT_REPOSITORY_URL,
+ DD_GIT_COMMIT_SHA
+ })
 ]
};

The getGitInfo() function executes git commands to return DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA variables. It needs to be executed in the git repository.

const { execSync } = require('child_process');
function getGitInfo() {
 try {
 const commitSha = execSync('git rev-parse HEAD', { encoding: 'utf8' }).trim();
 const repositoryUrl = execSync('git config --get remote.origin.url', { encoding: 'utf8' }).trim();
 console.log('Build-time Git metadata:', {
 commitSha,
 repositoryUrl,
 });
 return {
 DD_GIT_REPOSITORY_URL: repositoryUrl,
 DD_GIT_COMMIT_SHA: commitSha,
 };
 } catch (error) {
 console.warn('Could not get Git metadata at build time:', error.message);
 return {
 DD_GIT_REPOSITORY_URL: '',
 DD_GIT_COMMIT_SHA: '',
 };
 }
}

Bundling with webpack

Use the BannerPlugin to inject DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA in your runtime bundle. Run the bundle step inside a Git repository so the script can read .git/ information.

+ const webpack = require('webpack');
+ const { DD_GIT_REPOSITORY_URL, DD_GIT_COMMIT_SHA } = getGitInfo();
module.exports = {
	target: 'node',
	entry: './index.js',
	mode: 'production',
	output: {
		path: path.resolve(__dirname, 'dist'),
		filename: 'bundle.js',
		libraryTarget: 'commonjs2'
	},
	externals: [
		'express',
		'dd-trace'
	],
	plugins: [
+		new webpack.BannerPlugin({
+			raw: true,
+			entryOnly: true,
+			banner:
+ `process.env.DD_GIT_REPOSITORY_URL=${JSON.stringify(DD_GIT_REPOSITORY_URL)};` +
+				 `process.env.DD_GIT_COMMIT_SHA=${JSON.stringify(DD_GIT_COMMIT_SHA)};`,
+		}),
	]
};

The getGitInfo() function executes git commands to return DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA variables. It needs to be executed in the git repository.

const { execSync } = require('child_process');
function getGitInfo() {
 try {
 const commitSha = execSync('git rev-parse HEAD', { encoding: 'utf8' }).trim();
 const repositoryUrl = execSync('git config --get remote.origin.url', { encoding: 'utf8' }).trim();
 console.log('Build-time Git metadata:', {
 commitSha,
 repositoryUrl,
 });
 return {
 DD_GIT_REPOSITORY_URL: repositoryUrl,
 DD_GIT_COMMIT_SHA: commitSha,
 };
 } catch (error) {
 console.warn('Could not get Git metadata at build time:', error.message);
 return {
 DD_GIT_REPOSITORY_URL: '',
 DD_GIT_COMMIT_SHA: '',
 };
 }
}

Option 2: Datadog tooling

Datadog CLI tool

Use the datadog-ci client version 2.10.0 or later. You must run the CLI tool in the same directory as the code repository.

Datadog Serverless Plugin

Use the plugin version 5.60.0 or later.

Datadog CDK Construct

Use the datadog-cdk-constructs version 0.8.5 or later for AWS CDK v1.
Use the datadog-cdk-constructs version 1.4.0 or later for AWS CDK v2.

Option 3: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Host

For host-based environments, you have two options based on your build and deploy configuration.

Option 1: Bundler plugin

If you’re bundling your application from a Git directory, you can use plugins to inject Git metadata into the runtime bundle.

Bundling with esbuild

Use the dd-trace/esbuild plugin to automatically inject DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA in your runtime bundle. See the plugin documentation. Install dd-trace v5.68.0 or later for automatic Git tag injection.

const esbuild = require('esbuild');
+ const ddPlugin = require('dd-trace/esbuild');
esbuild.build({
 entryPoints: ['index.js'],
 bundle: true,
 platform: 'node',
 target: ['node20'],
 format: 'cjs',
 outfile: 'dist/bundle.js',
 packages: 'external',
 external: ['dd-trace', 'express']
+ plugins: [ddPlugin],
}).catch((e) => {
 console.error(e);
 process.exit(1);
});

Bundling with Rollup

Use rollup-plugin-inject-process-env to inject DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA in your runtime bundle. Run the bundle step inside a Git repository so the script can read .git/ information.

+ const injectProcessEnv = require('rollup-plugin-inject-process-env');
+ const { DD_GIT_REPOSITORY_URL, DD_GIT_COMMIT_SHA } = getGitInfo();
module.exports = {
 input: 'index.js',
 output: {
 file: 'dist/bundle.js',
 format: 'cjs'
 },
 external: [
 'express',
 'dd-trace'
 ],
 plugins: [
 nodeResolve(),
 commonjs()
+ injectProcessEnv({
+ DD_GIT_REPOSITORY_URL,
+ DD_GIT_COMMIT_SHA
+ })
 ]
};

The getGitInfo() function executes git commands to return DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA variables. It needs to be executed in the git repository.

const { execSync } = require('child_process');
function getGitInfo() {
 try {
 const commitSha = execSync('git rev-parse HEAD', { encoding: 'utf8' }).trim();
 const repositoryUrl = execSync('git config --get remote.origin.url', { encoding: 'utf8' }).trim();
 console.log('Build-time Git metadata:', {
 commitSha,
 repositoryUrl,
 });
 return {
 DD_GIT_REPOSITORY_URL: repositoryUrl,
 DD_GIT_COMMIT_SHA: commitSha,
 };
 } catch (error) {
 console.warn('Could not get Git metadata at build time:', error.message);
 return {
 DD_GIT_REPOSITORY_URL: '',
 DD_GIT_COMMIT_SHA: '',
 };
 }
}

Bundling with webpack

Use the BannerPlugin to inject DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA in your runtime bundle. Run the bundle step inside a Git repository so the script can read .git/ information.

+ const webpack = require('webpack');
+ const { DD_GIT_REPOSITORY_URL, DD_GIT_COMMIT_SHA } = getGitInfo();
module.exports = {
	target: 'node',
	entry: './index.js',
	mode: 'production',
	output: {
		path: path.resolve(__dirname, 'dist'),
		filename: 'bundle.js',
		libraryTarget: 'commonjs2'
	},
	externals: [
		'express',
		'dd-trace'
	],
	plugins: [
+		new webpack.BannerPlugin({
+			raw: true,
+			entryOnly: true,
+			banner:
+ `process.env.DD_GIT_REPOSITORY_URL=${JSON.stringify(DD_GIT_REPOSITORY_URL)};` +
+				 `process.env.DD_GIT_COMMIT_SHA=${JSON.stringify(DD_GIT_COMMIT_SHA)};`,
+		}),
	]
};

The getGitInfo() function executes git commands to return DD_GIT_REPOSITORY_URL and DD_GIT_COMMIT_SHA variables. It needs to be executed in the git repository.

const { execSync } = require('child_process');
function getGitInfo() {
 try {
 const commitSha = execSync('git rev-parse HEAD', { encoding: 'utf8' }).trim();
 const repositoryUrl = execSync('git config --get remote.origin.url', { encoding: 'utf8' }).trim();
 console.log('Build-time Git metadata:', {
 commitSha,
 repositoryUrl,
 });
 return {
 DD_GIT_REPOSITORY_URL: repositoryUrl,
 DD_GIT_COMMIT_SHA: commitSha,
 };
 } catch (error) {
 console.warn('Could not get Git metadata at build time:', error.message);
 return {
 DD_GIT_REPOSITORY_URL: '',
 DD_GIT_COMMIT_SHA: '',
 };
 }
}

Option 2: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Containers

If you are using Docker containers, you have two options: using Docker or configuring your application with the DD_TAGS environment variable.

Option 1: Docker

You can embed git information in your Docker image using either build arguments with environment variables, or image labels.

Using build arguments and environment variables

1. Add the following lines to your application’s Dockerfile:

   ARG DD_GIT_REPOSITORY_URLARG DD_GIT_COMMIT_SHAENV DD_TAGS="git.repository_url:${DD_GIT_REPOSITORY_URL},git.commit.sha:${DD_GIT_COMMIT_SHA}"

2. Add the following arguments to your Docker build command:

   docker build . \
    -t my-application \
    --build-arg DD_GIT_REPOSITORY_URL=<git-provider.example/me/my-repo> \
    --build-arg DD_GIT_COMMIT_SHA=$(git rev-parse HEAD)
   

Using image labels

This approach requires Docker, or containerd >= 1.5.6. It doesn’t support containers running on AWS Fargate.

Datadog can extract source code information directly from your images’ Docker labels. During build time, follow the Open Containers standard to add the git commit SHA and repository URL as Docker labels:

docker build . \
 -t my-application \
 --label org.opencontainers.image.revision=$(git rev-parse HEAD) \
 --label org.opencontainers.image.source=$(git config --get remote.origin.url)

Option 2: DD_TAGS environment variable

Configure your application with the DD_TAGS environment variable:

export DD_TAGS="git.commit.sha:<commitSha>,git.repository_url:<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Serverless

If you are using Serverless, you have two options depending on your serverless application’s setup.

Option 1: Datadog tooling

Datadog CLI tool

Use the datadog-ci client version 2.10.0 or later. You must run the CLI tool in the same directory as the code repository.

Datadog Serverless Plugin

Use the plugin version 5.60.0 or later.

Datadog CDK Construct

Use the datadog-cdk-constructs version 0.8.5 or later for AWS CDK v1.
Use the datadog-cdk-constructs version 1.4.0 or later for AWS CDK v2.

Option 2: DD_TAGS environment variable

Configure your application with the DD_TAGS environment variable:

export DD_TAGS="git.commit.sha:<commitSha>,git.repository_url:<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Host

If you are using a host, configure your application with the DD_TAGS environment variable.

Configure your application with the DD_TAGS environment variable:

export DD_TAGS="git.commit.sha:<commitSha>,git.repository_url:<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Containers

If you are using Docker containers, you have three options: embedding git properties in your build artifact, using Docker, or configuring your application with DD_GIT_* environment variables.

Option 1: Embedded git properties (recommended)

If you use Spring Boot, add a build plugin to embed git information in your JAR. The Datadog Java tracer reads the git.properties file that Spring Boot Actuator generates at startup.

Maven

Add the following plugin to your pom.xml:

<plugin>
 <groupId>io.github.git-commit-id</groupId>
 <artifactId>git-commit-id-maven-plugin</artifactId>
 <version>9.0.2</version>
 <executions>
 <execution>
 <id>get-the-git-infos</id>
 <goals>
 <goal>revision</goal>
 </goals>
 <phase>initialize</phase>
 </execution>
 </executions>
 <configuration>
 <generateGitPropertiesFile>true</generateGitPropertiesFile>
 <generateGitPropertiesFilename>${project.build.outputDirectory}/git.properties</generateGitPropertiesFilename>
 <commitIdGenerationMode>full</commitIdGenerationMode>
 </configuration>
</plugin>

Gradle

Add the following to your build.gradle.kts:

plugins {
 id("org.springframework.boot") version "2.5.7" // required
 // ...
 id("com.gorylenko.gradle-git-properties") version "2.5.7"
}

Option 2: Docker

You can embed git information in your Docker image using either build arguments with environment variables, or image labels.

Using build arguments and environment variables

1. Add the following lines to your application’s Dockerfile:

   ARG DD_GIT_REPOSITORY_URLARG DD_GIT_COMMIT_SHAENV DD_GIT_REPOSITORY_URL=${DD_GIT_REPOSITORY_URL} ENV DD_GIT_COMMIT_SHA=${DD_GIT_COMMIT_SHA}

2. Add the following arguments to your Docker build command:

   docker build . \
    -t my-application \
    --build-arg DD_GIT_REPOSITORY_URL=<git-provider.example/me/my-repo> \
    --build-arg DD_GIT_COMMIT_SHA=$(git rev-parse HEAD)
   

Using image labels

This approach requires Docker, or containerd >= 1.5.6. It doesn’t support containers running on AWS Fargate.

Datadog can extract source code information directly from your images’ Docker labels. During build time, follow the Open Containers standard to add the git commit SHA and repository URL as Docker labels:

docker build . \
 -t my-application \
 --label org.opencontainers.image.revision=$(git rev-parse HEAD) \
 --label org.opencontainers.image.source=$(git config --get remote.origin.url)

Option 3: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Serverless

If you are using Serverless, you have three options depending on your serverless application’s setup.

Option 1: Embedded git properties (recommended)

If you use Spring Boot, add a build plugin to embed git information in your JAR. The Datadog Java tracer reads the git.properties file that Spring Boot Actuator generates at startup.

Maven

Add the following plugin to your pom.xml:

<plugin>
 <groupId>io.github.git-commit-id</groupId>
 <artifactId>git-commit-id-maven-plugin</artifactId>
 <version>9.0.2</version>
 <executions>
 <execution>
 <id>get-the-git-infos</id>
 <goals>
 <goal>revision</goal>
 </goals>
 <phase>initialize</phase>
 </execution>
 </executions>
 <configuration>
 <generateGitPropertiesFile>true</generateGitPropertiesFile>
 <generateGitPropertiesFilename>${project.build.outputDirectory}/git.properties</generateGitPropertiesFilename>
 <commitIdGenerationMode>full</commitIdGenerationMode>
 </configuration>
</plugin>

Gradle

Add the following to your build.gradle.kts:

plugins {
 id("org.springframework.boot") version "2.5.7" // required
 // ...
 id("com.gorylenko.gradle-git-properties") version "2.5.7"
}

Option 2: Datadog tooling

Datadog CLI tool

Use the datadog-ci client version 2.10.0 or later. You must run the CLI tool in the same directory as the code repository.

Datadog Serverless Plugin

Use the plugin version 5.60.0 or later.

Datadog CDK Construct

Use the datadog-cdk-constructs version 0.8.5 or later for AWS CDK v1.
Use the datadog-cdk-constructs version 1.4.0 or later for AWS CDK v2.

Option 3: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Host

If you are using a host, you have two options.

Option 1: Embedded git properties (recommended)

If you use Spring Boot, add a build plugin to embed git information in your JAR. The Datadog Java tracer reads the git.properties file that Spring Boot Actuator generates at startup.

Maven

Add the following plugin to your pom.xml:

<plugin>
 <groupId>io.github.git-commit-id</groupId>
 <artifactId>git-commit-id-maven-plugin</artifactId>
 <version>9.0.2</version>
 <executions>
 <execution>
 <id>get-the-git-infos</id>
 <goals>
 <goal>revision</goal>
 </goals>
 <phase>initialize</phase>
 </execution>
 </executions>
 <configuration>
 <generateGitPropertiesFile>true</generateGitPropertiesFile>
 <generateGitPropertiesFilename>${project.build.outputDirectory}/git.properties</generateGitPropertiesFilename>
 <commitIdGenerationMode>full</commitIdGenerationMode>
 </configuration>
</plugin>

Gradle

Add the following to your build.gradle.kts:

plugins {
 id("org.springframework.boot") version "2.5.7" // required
 // ...
 id("com.gorylenko.gradle-git-properties") version "2.5.7"
}

Option 2: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Containers

If you are using Docker containers, you have two options: using Docker or configuring your application with DD_GIT_* environment variables.

Option 1: Docker

You can embed git information in your Docker image using either build arguments with environment variables, or image labels.

Using build arguments and environment variables

1. Add the following lines to your application’s Dockerfile:

   ARG DD_GIT_REPOSITORY_URLARG DD_GIT_COMMIT_SHAENV DD_GIT_REPOSITORY_URL=${DD_GIT_REPOSITORY_URL} ENV DD_GIT_COMMIT_SHA=${DD_GIT_COMMIT_SHA}

2. Add the following arguments to your Docker build command:

   docker build . \
    -t my-application \
    --build-arg DD_GIT_REPOSITORY_URL=<git-provider.example/me/my-repo> \
    --build-arg DD_GIT_COMMIT_SHA=$(git rev-parse HEAD)
   

Using image labels

This approach requires Docker, or containerd >= 1.5.6. It doesn’t support containers running on AWS Fargate.

Datadog can extract source code information directly from your images’ Docker labels. During build time, follow the Open Containers standard to add the git commit SHA and repository URL as Docker labels:

docker build . \
 -t my-application \
 --label org.opencontainers.image.revision=$(git rev-parse HEAD) \
 --label org.opencontainers.image.source=$(git config --get remote.origin.url)

Option 2: DD_GIT_* environment variables

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.

Host

If you are using a host, configure your application with DD_GIT_* environment variables.

Configure your application with the DD_GIT_* environment variables:

exportDD_GIT_COMMIT_SHA="<commitSha>"exportDD_GIT_REPOSITORY_URL="<git-provider.example/me/my-repo>"

Replace <commitSha> with the commit SHA used to build your application. You can retrieve this by running git rev-parse HEAD at build time, and it needs to be passed into the runtime environment variables.