Create AWS Integrations v2 API spec #2516

api-clients-generation-pipeline · 2024-06-06T15:36:52Z

See DataDog/datadog-api-spec#2813
Test branch datadog-api-spec/test/jon.vanbriesen/aws-v2-spec

github-actions · 2024-07-07T00:16:00Z

This issue has been automatically marked as stale because it has not had activity in the last 30 days.
Note that the issue will not be automatically closed, but this notification will remind us to investigate why there's been inactivity.

datadog-datadog-prod-us1 · 2024-10-15T19:16:01Z

api/datadogV2/model_aws_account_patch_request_data.go

+func NewAWSAccountPatchRequestData(attributes AWSAccountPatchRequestAttributes) *AWSAccountPatchRequestData {
+ this := AWSAccountPatchRequestData{}
+ this.Attributes = attributes
+ var typeVar string = "account"


🔵 Code Quality Violation

Suggested change

var typeVar string = "account"

var typeVar = "account"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-15T19:16:01Z

api/datadogV2/model_aws_account_response_data.go

+func NewAWSAccountResponseData(attributes AWSAccountResponseAttributes) *AWSAccountResponseData {
+ this := AWSAccountResponseData{}
+ this.Attributes = attributes
+ var typeVar string = "account"


🔵 Code Quality Violation

Suggested change

var typeVar string = "account"

var typeVar = "account"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-15T19:16:01Z

api/datadogV2/model_aws_account_create_request_data.go

+func NewAWSAccountCreateRequestData(attributes AWSAccountCreateRequestAttributes) *AWSAccountCreateRequestData {
+ this := AWSAccountCreateRequestData{}
+ this.Attributes = attributes
+ var typeVar string = "account"


🔵 Code Quality Violation

Suggested change

var typeVar string = "account"

var typeVar = "account"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-15T19:16:02Z

api/datadogV2/api_aws_integration.go

+ }
+
+ localVarPath := localBasePath + "/api/v2/integration/aws/accounts/{aws_account_id}"
+ localVarPath = strings.Replace(localVarPath, "{"+"aws_account_id"+"}", _neturl.PathEscape(datadog.ParameterToString(awsAccountId, "")), -1)


🟠 Code Quality Violation

Suggested change

localVarPath = strings.Replace(localVarPath, "{"+"aws_account_id"+"}", _neturl.PathEscape(datadog.ParameterToString(awsAccountId, "")), -1)

localVarPath = strings.ReplaceAll(localVarPath, "{"+"aws_account_id"+"}", _neturl.PathEscape(datadog.ParameterToString(awsAccountId, "")))

Do not call Replace with a negative limit, use ReplaceAll instead (...read more)

In Go, the strings.Replace() function is used to replace a certain substring within a string with another substring. The function takes in four parameters: the original string, the old substring to be replaced, the new substring that will replace the old one, and an integer limit dictating how many replacements to be made.

Calling strings.Replace() with a negative limit doesn't really make sense. According to the Go documentation, if limit is negative, there is no limit on the number of replacements. Which means it will replace all instances of old substring in the original string with a new substring.

For example:

fmt.Println(strings.Replace("oink oink oink", "k", "ky", -2))

In this example, Replace returns a copy of the string "oink oink oink" where "k" is replaced by "ky" everywhere it appears, because limit is -2.

So it's not necessarily "incorrect" to use a negative limit, but it can create misunderstandings in your code. It's best to use a limit of -1 when you want to replace all instances, as this convention is more commonly understood to mean "no limit".

But if you specifically want to avoid using negative limit for Replace or looking for replace method with better efficiency, using strings.NewReplacer() could be a better option when there are multiple string pairs need to be replaced, where you can specify a list of old-new string pairs.

Or you can use strings.ReplaceAll(). It is equivalent to Replace with a limit of -1. It's arguably clearer and more self-explanatory than using a negative limit with strings.Replace().

For example:

fmt.Println(strings.ReplaceAll("oink oink oink", "o", "ky"))

It replaces all instances of "o" in the string "oink oink oink" by "ky".

datadog-datadog-prod-us1 · 2024-10-16T20:50:58Z

api/datadogV2/model_aws_account_response_data.go

+// but it doesn't guarantee that properties required by API are set.
+func NewAWSAccountResponseDataWithDefaults() *AWSAccountResponseData {
+ this := AWSAccountResponseData{}
+ var typeVar string = "account"


🔵 Code Quality Violation

Suggested change

var typeVar string = "account"

var typeVar = "account"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-16T20:50:58Z

api/datadogV2/model_aws_account_create_request_data.go

+// but it doesn't guarantee that properties required by API are set.
+func NewAWSAccountCreateRequestDataWithDefaults() *AWSAccountCreateRequestData {
+ this := AWSAccountCreateRequestData{}
+ var typeVar string = "account"


🔵 Code Quality Violation

Suggested change

var typeVar string = "account"

var typeVar = "account"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-16T20:50:58Z

api/datadogV2/model_aws_account_patch_request_data.go

+// but it doesn't guarantee that properties required by API are set.
+func NewAWSAccountPatchRequestDataWithDefaults() *AWSAccountPatchRequestData {
+ this := AWSAccountPatchRequestData{}
+ var typeVar string = "account"


🔵 Code Quality Violation

Suggested change

var typeVar string = "account"

var typeVar = "account"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-16T21:02:10Z

api/datadogV2/api_aws_integration.go

+ }
+
+ localVarPath := localBasePath + "/api/v2/integration/aws/accounts/{aws_account_config_id}"
+ localVarPath = strings.Replace(localVarPath, "{"+"aws_account_config_id"+"}", _neturl.PathEscape(datadog.ParameterToString(awsAccountConfigId, "")), -1)


🟠 Code Quality Violation

Suggested change

localVarPath = strings.Replace(localVarPath, "{"+"aws_account_config_id"+"}", _neturl.PathEscape(datadog.ParameterToString(awsAccountConfigId, "")), -1)

localVarPath = strings.ReplaceAll(localVarPath, "{"+"aws_account_config_id"+"}", _neturl.PathEscape(datadog.ParameterToString(awsAccountConfigId, "")))

Do not call Replace with a negative limit, use ReplaceAll instead (...read more)

In Go, the strings.Replace() function is used to replace a certain substring within a string with another substring. The function takes in four parameters: the original string, the old substring to be replaced, the new substring that will replace the old one, and an integer limit dictating how many replacements to be made.

Calling strings.Replace() with a negative limit doesn't really make sense. According to the Go documentation, if limit is negative, there is no limit on the number of replacements. Which means it will replace all instances of old substring in the original string with a new substring.

For example:

fmt.Println(strings.Replace("oink oink oink", "k", "ky", -2))

In this example, Replace returns a copy of the string "oink oink oink" where "k" is replaced by "ky" everywhere it appears, because limit is -2.

So it's not necessarily "incorrect" to use a negative limit, but it can create misunderstandings in your code. It's best to use a limit of -1 when you want to replace all instances, as this convention is more commonly understood to mean "no limit".

But if you specifically want to avoid using negative limit for Replace or looking for replace method with better efficiency, using strings.NewReplacer() could be a better option when there are multiple string pairs need to be replaced, where you can specify a list of old-new string pairs.

Or you can use strings.ReplaceAll(). It is equivalent to Replace with a limit of -1. It's arguably clearer and more self-explanatory than using a negative limit with strings.Replace().

For example:

fmt.Println(strings.ReplaceAll("oink oink oink", "o", "ky"))

It replaces all instances of "o" in the string "oink oink oink" by "ky".

datadog-datadog-prod-us1 · 2024-10-17T14:16:44Z

api/datadogV2/api_aws_integration.go

+ }
+
+ localVarPath := localBasePath + "/api/v2/integration/aws/accounts/{aws_account_config_id}"
+ localVarPath = strings.Replace(localVarPath, "{"+"aws_account_config_id"+"}", _neturl.PathEscape(datadog.ParameterToString(awsAccountConfigId, "")), -1)


🟠 Code Quality Violation

Suggested change

localVarPath = strings.Replace(localVarPath, "{"+"aws_account_config_id"+"}", _neturl.PathEscape(datadog.ParameterToString(awsAccountConfigId, "")), -1)

localVarPath = strings.ReplaceAll(localVarPath, "{"+"aws_account_config_id"+"}", _neturl.PathEscape(datadog.ParameterToString(awsAccountConfigId, "")))

Do not call Replace with a negative limit, use ReplaceAll instead (...read more)

In Go, the strings.Replace() function is used to replace a certain substring within a string with another substring. The function takes in four parameters: the original string, the old substring to be replaced, the new substring that will replace the old one, and an integer limit dictating how many replacements to be made.

Calling strings.Replace() with a negative limit doesn't really make sense. According to the Go documentation, if limit is negative, there is no limit on the number of replacements. Which means it will replace all instances of old substring in the original string with a new substring.

For example:

fmt.Println(strings.Replace("oink oink oink", "k", "ky", -2))

In this example, Replace returns a copy of the string "oink oink oink" where "k" is replaced by "ky" everywhere it appears, because limit is -2.

So it's not necessarily "incorrect" to use a negative limit, but it can create misunderstandings in your code. It's best to use a limit of -1 when you want to replace all instances, as this convention is more commonly understood to mean "no limit".

But if you specifically want to avoid using negative limit for Replace or looking for replace method with better efficiency, using strings.NewReplacer() could be a better option when there are multiple string pairs need to be replaced, where you can specify a list of old-new string pairs.

Or you can use strings.ReplaceAll(). It is equivalent to Replace with a limit of -1. It's arguably clearer and more self-explanatory than using a negative limit with strings.Replace().

For example:

fmt.Println(strings.ReplaceAll("oink oink oink", "o", "ky"))

It replaces all instances of "o" in the string "oink oink oink" by "ky".

datadog-datadog-prod-us1 · 2024-10-17T21:38:44Z

api/datadogV2/model_aws_logs_services_response_data.go

+// will change when the set of required properties is changed.
+func NewAWSLogsServicesResponseData() *AWSLogsServicesResponseData {
+ this := AWSLogsServicesResponseData{}
+ var id string = "get_logs_services"


🔵 Code Quality Violation

Suggested change

var id string = "get_logs_services"

var id = "get_logs_services"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-17T21:38:44Z

api/datadogV2/model_aws_new_external_id_response_data.go

+ this := AWSNewExternalIDResponseData{}
+ var id string = "generate_new_external_id"
+ this.Id = &id
+ var typeVar string = "generate_new_external_id"


🔵 Code Quality Violation

Suggested change

var typeVar string = "generate_new_external_id"

var typeVar = "generate_new_external_id"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-17T21:38:44Z

api/datadogV2/model_aws_namespaces_response_data.go

+// will change when the set of required properties is changed.
+func NewAWSNamespacesResponseData() *AWSNamespacesResponseData {
+ this := AWSNamespacesResponseData{}
+ var typeVar string = "namespace"


🔵 Code Quality Violation

Suggested change

var typeVar string = "namespace"

var typeVar = "namespace"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-17T21:38:44Z

api/datadogV2/model_aws_logs_services_response_data.go

+ this := AWSLogsServicesResponseData{}
+ var id string = "get_logs_services"
+ this.Id = &id
+ var typeVar string = "logs_services"


🔵 Code Quality Violation

Suggested change

var typeVar string = "logs_services"

var typeVar = "logs_services"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-17T21:38:44Z

api/datadogV2/model_aws_new_external_id_response_data.go

+// will change when the set of required properties is changed.
+func NewAWSNewExternalIDResponseData() *AWSNewExternalIDResponseData {
+ this := AWSNewExternalIDResponseData{}
+ var id string = "generate_new_external_id"


🔵 Code Quality Violation

Suggested change

var id string = "generate_new_external_id"

var id = "generate_new_external_id"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-17T21:56:06Z

api/datadogV2/model_aws_namespaces_response_data.go

+// but it doesn't guarantee that properties required by API are set.
+func NewAWSNamespacesResponseDataWithDefaults() *AWSNamespacesResponseData {
+ this := AWSNamespacesResponseData{}
+ var typeVar string = "namespace"


🔵 Code Quality Violation

Suggested change

var typeVar string = "namespace"

var typeVar = "namespace"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-17T21:56:06Z

api/datadogV2/model_aws_new_external_id_response_data.go

+ this := AWSNewExternalIDResponseData{}
+ var id string = "generate_new_external_id"
+ this.Id = &id
+ var typeVar string = "generate_new_external_id"


🔵 Code Quality Violation

Suggested change

var typeVar string = "generate_new_external_id"

var typeVar = "generate_new_external_id"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-17T21:56:06Z

api/datadogV2/model_aws_new_external_id_response_data.go

+// but it doesn't guarantee that properties required by API are set.
+func NewAWSNewExternalIDResponseDataWithDefaults() *AWSNewExternalIDResponseData {
+ this := AWSNewExternalIDResponseData{}
+ var id string = "generate_new_external_id"


🔵 Code Quality Violation

Suggested change

var id string = "generate_new_external_id"

var id = "generate_new_external_id"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-17T21:56:06Z

api/datadogV2/model_aws_logs_services_response_data.go

+ this := AWSLogsServicesResponseData{}
+ var id string = "get_logs_services"
+ this.Id = &id
+ var typeVar string = "logs_services"


🔵 Code Quality Violation

Suggested change

var typeVar string = "logs_services"

var typeVar = "logs_services"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-17T21:56:06Z

api/datadogV2/api_aws_integration.go

+ }
+
+ localVarPath := localBasePath + "/api/v2/integration/aws/accounts/{aws_account_config_id}"
+ localVarPath = strings.Replace(localVarPath, "{"+"aws_account_config_id"+"}", _neturl.PathEscape(datadog.ParameterToString(awsAccountConfigId, "")), -1)


🟠 Code Quality Violation

Suggested change

localVarPath = strings.Replace(localVarPath, "{"+"aws_account_config_id"+"}", _neturl.PathEscape(datadog.ParameterToString(awsAccountConfigId, "")), -1)

localVarPath = strings.ReplaceAll(localVarPath, "{"+"aws_account_config_id"+"}", _neturl.PathEscape(datadog.ParameterToString(awsAccountConfigId, "")))

Do not call Replace with a negative limit, use ReplaceAll instead (...read more)

In Go, the strings.Replace() function is used to replace a certain substring within a string with another substring. The function takes in four parameters: the original string, the old substring to be replaced, the new substring that will replace the old one, and an integer limit dictating how many replacements to be made.

Calling strings.Replace() with a negative limit doesn't really make sense. According to the Go documentation, if limit is negative, there is no limit on the number of replacements. Which means it will replace all instances of old substring in the original string with a new substring.

For example:

fmt.Println(strings.Replace("oink oink oink", "k", "ky", -2))

In this example, Replace returns a copy of the string "oink oink oink" where "k" is replaced by "ky" everywhere it appears, because limit is -2.

So it's not necessarily "incorrect" to use a negative limit, but it can create misunderstandings in your code. It's best to use a limit of -1 when you want to replace all instances, as this convention is more commonly understood to mean "no limit".

But if you specifically want to avoid using negative limit for Replace or looking for replace method with better efficiency, using strings.NewReplacer() could be a better option when there are multiple string pairs need to be replaced, where you can specify a list of old-new string pairs.

Or you can use strings.ReplaceAll(). It is equivalent to Replace with a limit of -1. It's arguably clearer and more self-explanatory than using a negative limit with strings.Replace().

For example:

fmt.Println(strings.ReplaceAll("oink oink oink", "o", "ky"))

It replaces all instances of "o" in the string "oink oink oink" by "ky".

datadog-datadog-prod-us1 · 2024-10-21T21:01:03Z

api/datadogV2/model_aws_logs_services_response_data.go

+// but it doesn't guarantee that properties required by API are set.
+func NewAWSLogsServicesResponseDataWithDefaults() *AWSLogsServicesResponseData {
+ this := AWSLogsServicesResponseData{}
+ var id string = "get_logs_services"


🔵 Code Quality Violation

Suggested change

var id string = "get_logs_services"

var id = "get_logs_services"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-21T21:01:03Z

api/datadogV2/model_aws_namespaces_response_data.go

+ this := AWSNamespacesResponseData{}
+ var id string = "namespaces"
+ this.Id = &id
+ var typeVar string = "namespaces"


🔵 Code Quality Violation

Suggested change

var typeVar string = "namespaces"

var typeVar = "namespaces"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-22T17:10:08Z

api/datadogV2/model_aws_namespaces_response_data.go

+// but it doesn't guarantee that properties required by API are set.
+func NewAWSNamespacesResponseDataWithDefaults() *AWSNamespacesResponseData {
+ this := AWSNamespacesResponseData{}
+ var id string = "namespaces"


🔵 Code Quality Violation

Suggested change

var id string = "namespaces"

var id = "namespaces"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

datadog-datadog-prod-us1 · 2024-10-22T17:10:09Z

api/datadogV2/model_aws_namespaces_response_data.go

+ this := AWSNamespacesResponseData{}
+ var id string = "namespaces"
+ this.Id = &id
+ var typeVar string = "namespaces"


🔵 Code Quality Violation

Suggested change

var typeVar string = "namespaces"

var typeVar = "namespaces"

redundant type declaration (...read more)

In Go, it is considered good practice to avoid declaring the type when it is obvious or when the type can be inferred from the assignment. This is known as type inference, and it offers several benefits:

Readability: By omitting the explicit type declaration, the code becomes more concise and easier to read. Redundant type declarations can clutter the code and introduce unnecessary noise. When the type is obvious from the assigned value, omitting the type declaration can improve code readability and make it more expressive.

Flexibility and maintainability: Using type inference allows for easier changes to the underlying type without manually updating every instance where it is declared. If the type needs to be changed in the future, you only need to modify the assignment, and Go's type inference mechanism will handle the rest. This reduces the maintenance effort required and improves code maintainability.

Clean code appearance: Omitting the type declaration when it is obvious results in cleaner code syntax. Code that is free from excessive explicit type declarations tends to look more elegant and consistent. It minimizes redundancy and focuses on the essential logic, contributing to a cleaner and more streamlined codebase.

Compatibility: Go's type inference mechanism ensures compatibility with future changes to the type of the assigned value. If the assigned value is changed to a type-compatible value, the code will continue to compile and run without any modifications. This allows for flexibility in your code while maintaining correctness.

That being said, it is important to strike a balance and avoid excessive use of type inference. Clear and explicit type declarations are still valuable when they enhance code clarity, such as when documenting or expressing the intent of the code. It is essential to find the right balance between brevity and clarity in your codebase.

By utilizing Go's type inference mechanism and avoiding explicit type declarations when the type is obvious, you can achieve more readable, maintainable, and concise code that adheres to Go's idiomatic style.

api-clients-generation-pipeline bot requested a review from a team as a code owner June 6, 2024 15:36

api-clients-generation-pipeline bot added the changelog/Added Added features results into a minor version bump label Jun 6, 2024

api-clients-generation-pipeline bot force-pushed the datadog-api-spec/generated/2813 branch 2 times, most recently from 34609c4 to 492dfc2 Compare June 6, 2024 20:19

github-actions bot added the stale Stale - Bot reminder label Jul 7, 2024

api-clients-generation-pipeline bot force-pushed the datadog-api-spec/generated/2813 branch from 7427d29 to 742331b Compare August 12, 2024 19:02

api-clients-generation-pipeline bot requested a review from a team as a code owner August 12, 2024 19:02

api-clients-generation-pipeline bot force-pushed the datadog-api-spec/generated/2813 branch 2 times, most recently from bfdd058 to 87fc0bb Compare August 12, 2024 20:25

github-actions bot removed the stale Stale - Bot reminder label Aug 13, 2024

api-clients-generation-pipeline bot force-pushed the datadog-api-spec/generated/2813 branch 8 times, most recently from 14aa259 to b378646 Compare August 14, 2024 19:04

api-clients-generation-pipeline bot force-pushed the datadog-api-spec/generated/2813 branch 3 times, most recently from 7b4b781 to 0ab8a75 Compare August 26, 2024 19:33

api-clients-generation-pipeline bot force-pushed the datadog-api-spec/generated/2813 branch from f2ebb50 to c649648 Compare August 30, 2024 20:30

api-clients-generation-pipeline bot force-pushed the datadog-api-spec/generated/2813 branch from c649648 to 1f638b5 Compare October 15, 2024 18:54

datadog-datadog-prod-us1 bot reviewed Oct 15, 2024

View reviewed changes

api-clients-generation-pipeline bot force-pushed the datadog-api-spec/generated/2813 branch from 1f638b5 to 231bda2 Compare October 16, 2024 20:45

datadog-datadog-prod-us1 bot reviewed Oct 16, 2024

View reviewed changes

api-clients-generation-pipeline bot changed the title ~~adding v2 api spec~~ Create AWS Integrations v2 API spec Oct 16, 2024

api-clients-generation-pipeline bot force-pushed the datadog-api-spec/generated/2813 branch from 231bda2 to 8556d57 Compare October 16, 2024 20:53

datadog-datadog-prod-us1 bot reviewed Oct 16, 2024

View reviewed changes

api-clients-generation-pipeline bot force-pushed the datadog-api-spec/generated/2813 branch 2 times, most recently from 1852b9d to 2d2d073 Compare October 17, 2024 14:12

datadog-datadog-prod-us1 bot reviewed Oct 17, 2024

View reviewed changes

api-clients-generation-pipeline bot force-pushed the datadog-api-spec/generated/2813 branch 3 times, most recently from 70b8f14 to 09af02f Compare October 17, 2024 21:37

datadog-datadog-prod-us1 bot reviewed Oct 17, 2024

View reviewed changes

api-clients-generation-pipeline bot force-pushed the datadog-api-spec/generated/2813 branch from 09af02f to bdb4601 Compare October 17, 2024 21:55

datadog-datadog-prod-us1 bot reviewed Oct 17, 2024

View reviewed changes

api-clients-generation-pipeline bot force-pushed the datadog-api-spec/generated/2813 branch from bdb4601 to f59b34b Compare October 21, 2024 20:59

datadog-datadog-prod-us1 bot reviewed Oct 21, 2024

View reviewed changes

Regenerate client from commit 92b93d26 of spec repo

8b80f65

api-clients-generation-pipeline bot force-pushed the datadog-api-spec/generated/2813 branch from f59b34b to 8b80f65 Compare October 22, 2024 17:04

datadog-datadog-prod-us1 bot reviewed Oct 22, 2024

View reviewed changes

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Create AWS Integrations v2 API spec #2516

Create AWS Integrations v2 API spec #2516

api-clients-generation-pipeline bot commented Jun 6, 2024

github-actions bot commented Jul 7, 2024

datadog-datadog-prod-us1 bot Oct 15, 2024

datadog-datadog-prod-us1 bot Oct 15, 2024

datadog-datadog-prod-us1 bot Oct 15, 2024

datadog-datadog-prod-us1 bot Oct 15, 2024

datadog-datadog-prod-us1 bot Oct 16, 2024

datadog-datadog-prod-us1 bot Oct 16, 2024

datadog-datadog-prod-us1 bot Oct 16, 2024

datadog-datadog-prod-us1 bot Oct 16, 2024

datadog-datadog-prod-us1 bot Oct 17, 2024

datadog-datadog-prod-us1 bot Oct 17, 2024

datadog-datadog-prod-us1 bot Oct 17, 2024

datadog-datadog-prod-us1 bot Oct 17, 2024

datadog-datadog-prod-us1 bot Oct 17, 2024

datadog-datadog-prod-us1 bot Oct 17, 2024

datadog-datadog-prod-us1 bot Oct 17, 2024

datadog-datadog-prod-us1 bot Oct 17, 2024

datadog-datadog-prod-us1 bot Oct 17, 2024

datadog-datadog-prod-us1 bot Oct 17, 2024

datadog-datadog-prod-us1 bot Oct 17, 2024

datadog-datadog-prod-us1 bot Oct 21, 2024

datadog-datadog-prod-us1 bot Oct 21, 2024

datadog-datadog-prod-us1 bot Oct 22, 2024

datadog-datadog-prod-us1 bot Oct 22, 2024

	localVarPath = strings.Replace(localVarPath, "{"+"aws_account_id"+"}", _neturl.PathEscape(datadog.ParameterToString(awsAccountId, "")), -1)
	localVarPath = strings.ReplaceAll(localVarPath, "{"+"aws_account_id"+"}", _neturl.PathEscape(datadog.ParameterToString(awsAccountId, "")))

	var id string = "get_logs_services"
	var id = "get_logs_services"

	var typeVar string = "generate_new_external_id"
	var typeVar = "generate_new_external_id"

	var typeVar string = "logs_services"
	var typeVar = "logs_services"

	var id string = "generate_new_external_id"
	var id = "generate_new_external_id"

Create AWS Integrations v2 API spec #2516

Are you sure you want to change the base?

Create AWS Integrations v2 API spec #2516

Conversation

api-clients-generation-pipeline bot commented Jun 6, 2024

github-actions bot commented Jul 7, 2024

datadog-datadog-prod-us1 bot Oct 15, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 15, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 15, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 15, 2024

Choose a reason for hiding this comment

🟠 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 16, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 16, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 16, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 16, 2024

Choose a reason for hiding this comment

🟠 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 17, 2024

Choose a reason for hiding this comment

🟠 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 17, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 17, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 17, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 17, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 17, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 17, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 17, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 17, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 17, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 17, 2024

Choose a reason for hiding this comment

🟠 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 21, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 21, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 22, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation

datadog-datadog-prod-us1 bot Oct 22, 2024

Choose a reason for hiding this comment

🔵 Code Quality Violation