Analyze code

v2 (latest)

Note: This endpoint is in preview and is subject to change. If you have any feedback, contact Datadog support.

POST https://api.ap1.datadoghq.com/api/v2/static-analysis/static-analysis-server/analyzehttps://api.ap2.datadoghq.com/api/v2/static-analysis/static-analysis-server/analyzehttps://api.datadoghq.eu/api/v2/static-analysis/static-analysis-server/analyzehttps://api.ddog-gov.com/api/v2/static-analysis/static-analysis-server/analyzehttps://api.us2.ddog-gov.com/api/v2/static-analysis/static-analysis-server/analyzehttps://api.uk1.datadoghq.com/api/v2/static-analysis/static-analysis-server/analyzehttps://api.datadoghq.com/api/v2/static-analysis/static-analysis-server/analyzehttps://api.us3.datadoghq.com/api/v2/static-analysis/static-analysis-server/analyzehttps://api.us5.datadoghq.com/api/v2/static-analysis/static-analysis-server/analyze

Overview

Run static analysis rules against a source code file and return violations found.

OAuth apps require the code_analysis_read authorization scope to access this endpoint.

Request

Body Data (required)

Expand All

Field

Type

Description

_authentication_token

string

CSRF token for security, sent by browser-based clients. Ignored by the API when absent.

data [required]

object

The primary data object in the analysis request.

attributes [required]

object

The attributes of the analysis request, containing the source code and rules to apply.

rules [required]

[object]

The list of static analysis rules to apply during analysis.

{
  "_authentication_token": "string",
  "data": {
    "attributes": {
      "code": "aW1wb3J0IHN5cw==",
      "file_encoding": "utf-8",
      "filename": "test.py",
      "language": "python",
      "rules": [
        {
          "arguments": [
            {
              "description": "string",
              "name": "string"
            }
          ],
          "category": "BEST_PRACTICES",
          "checksum": "abc123def456",
          "code": "ZnVuY3Rpb24gdmlzaXQobm9kZSkge30=",
          "creation_message": "string",
          "cve": "string",
          "cwe": "string",
          "description": "string",
          "documentation_url": "string",
          "entity_checked": "string",
          "id": "python-best-practices/no-exit",
          "is_published": false,
          "is_testing": false,
          "language": "python",
          "name": "no-exit",
          "regex": "string",
          "severity": "WARNING",
          "short_description": "string",
          "should_use_ai_fix": false,
          "tags": [],
          "tests": [
            {
              "annotation_count": "integer",
              "code": "string",
              "filename": "string"
            }
          ],
          "tree_sitter_query": "KGNhbGwgbmFtZTogKGF0dHJpYnV0ZSkpQHZhbA==",
          "type": "TREE_SITTER_QUERY",
          "version_id": "integer"
        }
      ]
    },
    "id": "string",
    "type": "analysis_request"
  }
}

Response

The response payload from running static analysis on source code.

Expand All

Field

Type

Description

data [required]

object

The primary data object in the analysis response.

attributes [required]

object

The attributes of the analysis response, containing rule results and any top-level errors.

rule_responses [required]

[object]

The list of results for each static analysis rule applied during analysis.

{
  "data": {
    "attributes": {
      "errors": [
        []
      ],
      "rule_responses": [
        {
          "errors": [
            []
          ],
          "execution_error": null,
          "execution_time_ms": 42,
          "identifier": "python-best-practices/no-exit",
          "output": "",
          "violations": [
            {
              "category": "BEST_PRACTICES",
              "end": {
                "col": 5,
                "line": 10
              },
              "fixes": [
                {
                  "description": "Replace with a safe alternative.",
                  "edits": [
                    {
                      "content": "safe_alternative()",
                      "edit_type": "ADD",
                      "end": {
                        "col": 5,
                        "line": 10
                      },
                      "start": {
                        "col": 5,
                        "line": 10
                      }
                    }
                  ]
                }
              ],
              "message": "Use of sys.exit() is discouraged.",
              "severity": "WARNING",
              "start": {
                "col": 5,
                "line": 10
              }
            }
          ]
        }
      ]
    },
    "id": "abc-123",
    "type": "server_request"
  }
}

Bad Request

API error response.

Expand All

Field

Type

Description

errors [required]

[object]

A list of errors.

{
  "errors": [
    {
      "detail": "Missing required attribute in body",
      "meta": {},
      "source": {
        "header": "Authorization",
        "parameter": "limit",
        "pointer": "/data/attributes/title"
      },
      "status": "400",
      "title": "Bad Request"
    }
  ]
}

Unauthorized

API error response.

Expand All

Field

Type

Description

errors [required]

[object]

A list of errors.

{
  "errors": [
    {
      "detail": "Missing required attribute in body",
      "meta": {},
      "source": {
        "header": "Authorization",
        "parameter": "limit",
        "pointer": "/data/attributes/title"
      },
      "status": "400",
      "title": "Bad Request"
    }
  ]
}

Too many requests

API error response.

Expand All

Field

Type

Description

errors [required]

[string]

A list of errors.

{
  "errors": [
    "Bad Request"
  ]
}

Code Example

                  ## default
# 

# Use a Personal Access Token or Service Access Token
export DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>"

# Curl command
curl -X POST "https://api.ap1.datadoghq.com"https://api.ap2.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.us2.ddog-gov.com"https://api.uk1.datadoghq.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/static-analysis/static-analysis-server/analyze" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "code": "aW1wb3J0IHN5cw==",
      "file_encoding": "utf-8",
      "filename": "test.py",
      "language": "python",
      "rules": []
    },
    "type": "analysis_request"
  }
}
EOF

                

"""
Analyze code returns "OK" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.security_monitoring_api import SecurityMonitoringApi
from datadog_api_client.v2.model.analysis_request import AnalysisRequest
from datadog_api_client.v2.model.analysis_request_data import AnalysisRequestData
from datadog_api_client.v2.model.analysis_request_data_attributes import AnalysisRequestDataAttributes
from datadog_api_client.v2.model.analysis_request_data_type import AnalysisRequestDataType
from datadog_api_client.v2.model.analysis_request_rule import AnalysisRequestRule
from datadog_api_client.v2.model.analysis_request_rule_argument import AnalysisRequestRuleArgument
from datadog_api_client.v2.model.analysis_request_rule_test import AnalysisRequestRuleTest

body = AnalysisRequest(
    data=AnalysisRequestData(
        attributes=AnalysisRequestDataAttributes(
            code="aW1wb3J0IHN5cw==",
            file_encoding="utf-8",
            filename="test.py",
            language="python",
            rules=[
                AnalysisRequestRule(
                    arguments=[
                        AnalysisRequestRuleArgument(),
                    ],
                    category="BEST_PRACTICES",
                    checksum="abc123def456",
                    code="ZnVuY3Rpb24gdmlzaXQobm9kZSkge30=",
                    entity_checked=None,
                    id="python-best-practices/no-exit",
                    language="python",
                    name="no-exit",
                    regex=None,
                    severity="WARNING",
                    tags=[],
                    tests=[
                        AnalysisRequestRuleTest(),
                    ],
                    tree_sitter_query="KGNhbGwgbmFtZTogKGF0dHJpYnV0ZSkpQHZhbA==",
                    type="TREE_SITTER_QUERY",
                ),
            ],
        ),
        type=AnalysisRequestDataType.ANALYSIS_REQUEST,
    ),
)

configuration = Configuration()
configuration.access_token = environ["DD_BEARER_TOKEN"]
configuration.unstable_operations["create_static_analysis_server_analysis"] = True
with ApiClient(configuration) as api_client:
    api_instance = SecurityMonitoringApi(api_client)
    response = api_instance.create_static_analysis_server_analysis(body=body)

    print(response)

Instructions

First install the library and its dependencies and then save the example to example.py and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" python3 "example.py"

# Analyze code returns "OK" response

require "datadog_api_client"
DatadogAPIClient.configure do |config|
  config.access_token = ENV["DD_BEARER_TOKEN"]
  config.unstable_operations["v2.create_static_analysis_server_analysis".to_sym] = true
end
api_instance = DatadogAPIClient::V2::SecurityMonitoringAPI.new

body = DatadogAPIClient::V2::AnalysisRequest.new({
  data: DatadogAPIClient::V2::AnalysisRequestData.new({
    attributes: DatadogAPIClient::V2::AnalysisRequestDataAttributes.new({
      code: "aW1wb3J0IHN5cw==",
      file_encoding: "utf-8",
      filename: "test.py",
      language: "python",
      rules: [
        DatadogAPIClient::V2::AnalysisRequestRule.new({
          arguments: [
            DatadogAPIClient::V2::AnalysisRequestRuleArgument.new({}),
          ],
          category: "BEST_PRACTICES",
          checksum: "abc123def456",
          code: "ZnVuY3Rpb24gdmlzaXQobm9kZSkge30=",
          entity_checked: nil,
          id: "python-best-practices/no-exit",
          language: "python",
          name: "no-exit",
          regex: nil,
          severity: "WARNING",
          tags: [],
          tests: [
            DatadogAPIClient::V2::AnalysisRequestRuleTest.new({}),
          ],
          tree_sitter_query: "KGNhbGwgbmFtZTogKGF0dHJpYnV0ZSkpQHZhbA==",
          type: "TREE_SITTER_QUERY",
        }),
      ],
    }),
    type: DatadogAPIClient::V2::AnalysisRequestDataType::ANALYSIS_REQUEST,
  }),
})
p api_instance.create_static_analysis_server_analysis(body)

Instructions

First install the library and its dependencies and then save the example to example.rb and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" rb "example.rb"

// Analyze code returns "OK" response

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"os"

	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
	"github.com/DataDog/datadog-api-client-go/v2/api/datadogV2"
)

func main() {
	body := datadogV2.AnalysisRequest{
		Data: datadogV2.AnalysisRequestData{
			Attributes: datadogV2.AnalysisRequestDataAttributes{
				Code:         "aW1wb3J0IHN5cw==",
				FileEncoding: "utf-8",
				Filename:     "test.py",
				Language:     "python",
				Rules: []datadogV2.AnalysisRequestRule{
					{
						Arguments: []datadogV2.AnalysisRequestRuleArgument{
							{},
						},
						Category:      "BEST_PRACTICES",
						Checksum:      "abc123def456",
						Code:          "ZnVuY3Rpb24gdmlzaXQobm9kZSkge30=",
						EntityChecked: *datadog.NewNullableString(nil),
						Id:            "python-best-practices/no-exit",
						Language:      "python",
						Name:          datadog.PtrString("no-exit"),
						Regex:         *datadog.NewNullableString(nil),
						Severity:      "WARNING",
						Tags:          []string{},
						Tests: []datadogV2.AnalysisRequestRuleTest{
							{},
						},
						TreeSitterQuery: "KGNhbGwgbmFtZTogKGF0dHJpYnV0ZSkpQHZhbA==",
						Type:            "TREE_SITTER_QUERY",
					},
				},
			},
			Type: datadogV2.ANALYSISREQUESTDATATYPE_ANALYSIS_REQUEST,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	ctx = context.WithValue(ctx, datadog.ContextAccessToken, os.Getenv("DD_BEARER_TOKEN"))
	configuration := datadog.NewConfiguration()
	configuration.SetUnstableOperationEnabled("v2.CreateStaticAnalysisServerAnalysis", true)
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewSecurityMonitoringApi(apiClient)
	resp, r, err := api.CreateStaticAnalysisServerAnalysis(ctx, body)

	if err != nil {
		fmt.Fprintf(os.Stderr, "Error when calling `SecurityMonitoringApi.CreateStaticAnalysisServerAnalysis`: %v\n", err)
		fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
	}

	responseContent, _ := json.MarshalIndent(resp, "", "  ")
	fmt.Fprintf(os.Stdout, "Response from `SecurityMonitoringApi.CreateStaticAnalysisServerAnalysis`:\n%s\n", responseContent)
}

Instructions

First install the library and its dependencies and then save the example to main.go and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" go run "main.go"

// Analyze code returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.SecurityMonitoringApi;
import com.datadog.api.client.v2.model.AnalysisRequest;
import com.datadog.api.client.v2.model.AnalysisRequestData;
import com.datadog.api.client.v2.model.AnalysisRequestDataAttributes;
import com.datadog.api.client.v2.model.AnalysisRequestDataType;
import com.datadog.api.client.v2.model.AnalysisRequestRule;
import com.datadog.api.client.v2.model.AnalysisRequestRuleArgument;
import com.datadog.api.client.v2.model.AnalysisRequestRuleTest;
import com.datadog.api.client.v2.model.AnalysisResponse;
import java.util.Collections;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = ApiClient.getDefaultApiClient();
    defaultClient.setAccessToken(System.getenv("DD_BEARER_TOKEN"));
    defaultClient.setUnstableOperationEnabled("v2.createStaticAnalysisServerAnalysis", true);
    SecurityMonitoringApi apiInstance = new SecurityMonitoringApi(defaultClient);

    AnalysisRequest body =
        new AnalysisRequest()
            .data(
                new AnalysisRequestData()
                    .attributes(
                        new AnalysisRequestDataAttributes()
                            .code("aW1wb3J0IHN5cw==")
                            .fileEncoding("utf-8")
                            .filename("test.py")
                            .language("python")
                            .rules(
                                Collections.singletonList(
                                    new AnalysisRequestRule()
                                        .arguments(
                                            Collections.singletonList(
                                                new AnalysisRequestRuleArgument()))
                                        .category("BEST_PRACTICES")
                                        .checksum("abc123def456")
                                        .code("ZnVuY3Rpb24gdmlzaXQobm9kZSkge30=")
                                        .entityChecked(null)
                                        .id("python-best-practices/no-exit")
                                        .language("python")
                                        .name("no-exit")
                                        .regex(null)
                                        .severity("WARNING")
                                        .tests(
                                            Collections.singletonList(
                                                new AnalysisRequestRuleTest()))
                                        .treeSitterQuery("KGNhbGwgbmFtZTogKGF0dHJpYnV0ZSkpQHZhbA==")
                                        .type("TREE_SITTER_QUERY"))))
                    .type(AnalysisRequestDataType.ANALYSIS_REQUEST));

    try {
      AnalysisResponse result = apiInstance.createStaticAnalysisServerAnalysis(body);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println(
          "Exception when calling SecurityMonitoringApi#createStaticAnalysisServerAnalysis");
      System.err.println("Status code: " + e.getCode());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

Instructions

First install the library and its dependencies and then save the example to Example.java and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" java "Example.java"

// Analyze code returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
use datadog_api_client::datadogV2::model::AnalysisRequest;
use datadog_api_client::datadogV2::model::AnalysisRequestData;
use datadog_api_client::datadogV2::model::AnalysisRequestDataAttributes;
use datadog_api_client::datadogV2::model::AnalysisRequestDataType;
use datadog_api_client::datadogV2::model::AnalysisRequestRule;
use datadog_api_client::datadogV2::model::AnalysisRequestRuleArgument;
use datadog_api_client::datadogV2::model::AnalysisRequestRuleTest;

#[tokio::main]
async fn main() {
    let body = AnalysisRequest::new(AnalysisRequestData::new(
        AnalysisRequestDataAttributes::new(
            "aW1wb3J0IHN5cw==".to_string(),
            "utf-8".to_string(),
            "test.py".to_string(),
            "python".to_string(),
            vec![AnalysisRequestRule::new(
                "BEST_PRACTICES".to_string(),
                "abc123def456".to_string(),
                "ZnVuY3Rpb24gdmlzaXQobm9kZSkge30=".to_string(),
                "python-best-practices/no-exit".to_string(),
                "python".to_string(),
                "WARNING".to_string(),
                "KGNhbGwgbmFtZTogKGF0dHJpYnV0ZSkpQHZhbA==".to_string(),
                "TREE_SITTER_QUERY".to_string(),
            )
            .arguments(vec![AnalysisRequestRuleArgument::new()])
            .entity_checked(None)
            .name("no-exit".to_string())
            .regex(None)
            .tags(vec![])
            .tests(vec![AnalysisRequestRuleTest::new()])],
        ),
        AnalysisRequestDataType::ANALYSIS_REQUEST,
    ));
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.create_static_analysis_server_analysis", true);
    let api = SecurityMonitoringAPI::with_config(configuration);
    let resp = api.create_static_analysis_server_analysis(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

Instructions

First install the library and its dependencies and then save the example to src/main.rs and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_API_KEY="<DD_API_KEY>" DD_APP_KEY="<DD_APP_KEY>" cargo run

/**
 * Analyze code returns "OK" response
 */

import { client, v2 } from "@datadog/datadog-api-client";

const configuration = client.createConfiguration({
  authMethods: {
    AuthZ: {
      accessToken: process.env.DD_BEARER_TOKEN as string,
    },
  },
});
configuration.unstableOperations["v2.createStaticAnalysisServerAnalysis"] =
  true;
const apiInstance = new v2.SecurityMonitoringApi(configuration);

const params: v2.SecurityMonitoringApiCreateStaticAnalysisServerAnalysisRequest =
  {
    body: {
      data: {
        attributes: {
          code: "aW1wb3J0IHN5cw==",
          fileEncoding: "utf-8",
          filename: "test.py",
          language: "python",
          rules: [
            {
              arguments: [{}],
              category: "BEST_PRACTICES",
              checksum: "abc123def456",
              code: "ZnVuY3Rpb24gdmlzaXQobm9kZSkge30=",
              entityChecked: undefined,
              id: "python-best-practices/no-exit",
              language: "python",
              name: "no-exit",
              regex: undefined,
              severity: "WARNING",
              tags: [],
              tests: [{}],
              treeSitterQuery: "KGNhbGwgbmFtZTogKGF0dHJpYnV0ZSkpQHZhbA==",
              type: "TREE_SITTER_QUERY",
            },
          ],
        },
        type: "analysis_request",
      },
    },
  };

apiInstance
  .createStaticAnalysisServerAnalysis(params)
  .then((data: v2.AnalysisResponse) => {
    console.log(
      "API called successfully. Returned data: " + JSON.stringify(data)
    );
  })
  .catch((error: any) => console.error(error));

Instructions

First install the library and its dependencies and then save the example to example.ts and run following commands:

    DD_SITE="datadoghq.comus3.datadoghq.comus5.datadoghq.comdatadoghq.euap1.datadoghq.comap2.datadoghq.comuk1.datadoghq.comddog-gov.comus2.ddog-gov.com" DD_BEARER_TOKEN="<PERSONAL_ACCESS_TOKEN OR SERVICE_ACCESS_TOKEN>" tsc "example.ts"

Analyze code

Overview

Request

Body Data (required)

Response

Code Example

Analyze code

Analyze code

Instructions

Analyze code

Instructions

Analyze code

Instructions

Analyze code

Instructions

Analyze code

Instructions

Analyze code

Instructions

How can I help you today?