datadog_api_client 2.58.0 → 2.59.1

data/examples/v2/elastic-cloud-integration-accounts/UpdateElasticCloudIntegrationAccount.rb

@@ -0,0 +1,50 @@
+# Update an Elastic Cloud integration account returns "OK" response
+
+require "datadog_api_client"
+DatadogAPIClient.configure do |config|
+  config.unstable_operations["v2.update_elastic_cloud_integration_account".to_sym] = true
+end
+api_instance = DatadogAPIClient::V2::ElasticCloudIntegrationAccountsAPI.new
+
+body = DatadogAPIClient::V2::ElasticCloudIntegrationAccountUpdateRequest.new({
+  data: DatadogAPIClient::V2::ElasticCloudIntegrationAccountUpdateData.new({
+    attributes: DatadogAPIClient::V2::ElasticCloudIntegrationAccountUpdateAttributes.new({
+      authentication: DatadogAPIClient::V2::IntegrationAccountBasicAuthUpdate.new({
+        auth_type: DatadogAPIClient::V2::IntegrationAccountBasicAuthType::BASIC,
+        password: "your-password",
+        username: "datadog",
+      }),
+      dataflows: DatadogAPIClient::V2::ElasticCloudIntegrationDataflowsRequest.new({
+        elastic_cloud_detailed_index_stats: DatadogAPIClient::V2::ElasticCloudDetailedIndexStatsIntegrationDataflowRequest.new({
+          enabled: true,
+        }),
+        elastic_cloud_index_stats: DatadogAPIClient::V2::ElasticCloudIndexStatsIntegrationDataflowRequest.new({
+          enabled: true,
+        }),
+        elastic_cloud_pending_task_stats: DatadogAPIClient::V2::ElasticCloudPendingTaskStatsIntegrationDataflowRequest.new({
+          enabled: true,
+        }),
+        elastic_cloud_primary_shard_graceful_timeout: DatadogAPIClient::V2::ElasticCloudPrimaryShardGracefulTimeoutIntegrationDataflowRequest.new({
+          enabled: true,
+        }),
+        elastic_cloud_primary_shard_stats: DatadogAPIClient::V2::ElasticCloudPrimaryShardStatsIntegrationDataflowRequest.new({
+          enabled: true,
+        }),
+        elastic_cloud_shard_allocation_stats: DatadogAPIClient::V2::ElasticCloudShardAllocationStatsIntegrationDataflowRequest.new({
+          enabled: true,
+        }),
+        elastic_cloud_slm_stats: DatadogAPIClient::V2::ElasticCloudSlmStatsIntegrationDataflowRequest.new({
+          enabled: true,
+        }),
+      }),
+      name: "elastic-cloud-prod",
+      settings: DatadogAPIClient::V2::ElasticCloudIntegrationAccountSettingsUpdate.new({
+        tags: "env:prod,team:saasint",
+        url: "https://example.es.us-central1.gcp.cloud.es.io:9243",
+      }),
+    }),
+    id: "953a0060-81ec-4221-aed4-d4733b59cd96",
+    type: DatadogAPIClient::V2::IntegrationAccountType::INTEGRATION_ACCOUNT,
+  }),
+})
+p api_instance.update_elastic_cloud_integration_account("account_id", body)

data/examples/v2/execution-policy/CreateExecutionPolicy.rb

@@ -0,0 +1,24 @@
+# Create an execution policy returns "Created" response
+
+require "datadog_api_client"
+DatadogAPIClient.configure do |config|
+  config.unstable_operations["v2.create_execution_policy".to_sym] = true
+end
+api_instance = DatadogAPIClient::V2::ExecutionPolicyAPI.new
+
+body = DatadogAPIClient::V2::ExecutionPolicyCreateRequest.new({
+  data: DatadogAPIClient::V2::ExecutionPolicyCreateRequestData.new({
+    type: DatadogAPIClient::V2::ExecutionPolicyType::EXECUTION_POLICY,
+    attributes: DatadogAPIClient::V2::ExecutionPolicyWriteAttributes.new({
+      name: "Cassette Execution Policy exampleexecutionpolicy",
+      effect: DatadogAPIClient::V2::ExecutionPolicyEffect::ALLOW,
+      action_pattern: DatadogAPIClient::V2::ExecutionPolicyActionPattern.new({
+        integration: DatadogAPIClient::V2::ExecutionPolicyIntegration::INTEGRATION_SCRIPT,
+        action_fqns: [
+          "com.datadoghq.script.*",
+        ],
+      }),
+    }),
+  }),
+})
+p api_instance.create_execution_policy(body)

data/examples/v2/execution-policy/CreateExecutionPolicy_1075977289.rb

@@ -0,0 +1,43 @@
+# Create an execution policy with scope and targets returns "Created" response
+
+require "datadog_api_client"
+DatadogAPIClient.configure do |config|
+  config.unstable_operations["v2.create_execution_policy".to_sym] = true
+end
+api_instance = DatadogAPIClient::V2::ExecutionPolicyAPI.new
+
+body = DatadogAPIClient::V2::ExecutionPolicyCreateRequest.new({
+  data: DatadogAPIClient::V2::ExecutionPolicyCreateRequestData.new({
+    type: DatadogAPIClient::V2::ExecutionPolicyType::EXECUTION_POLICY,
+    attributes: DatadogAPIClient::V2::ExecutionPolicyWriteAttributes.new({
+      name: "Cassette Execution Policy exampleexecutionpolicy",
+      effect: DatadogAPIClient::V2::ExecutionPolicyEffect::ALLOW,
+      action_pattern: DatadogAPIClient::V2::ExecutionPolicyActionPattern.new({
+        integration: DatadogAPIClient::V2::ExecutionPolicyIntegration::INTEGRATION_SCRIPT,
+        action_fqns: [
+          "com.datadoghq.script.*",
+        ],
+      }),
+      scope: DatadogAPIClient::V2::ExecutionPolicyScope.new({
+        scripts: DatadogAPIClient::V2::ExecutionPolicyScriptScope.new({
+          rules: [
+            DatadogAPIClient::V2::ExecutionPolicyScriptScopeRule.new({
+              target_script_names: [
+                "restart_service.sh",
+              ],
+            }),
+          ],
+        }),
+      }),
+      targets: [
+        DatadogAPIClient::V2::ExecutionPolicyTarget.new({
+          name: "Production hosts",
+          agent_tags: [
+            "env:prod",
+          ],
+        }),
+      ],
+    }),
+  }),
+})
+p api_instance.create_execution_policy(body)

data/examples/v2/execution-policy/DeleteExecutionPolicy.rb

@@ -0,0 +1,11 @@
+# Delete an execution policy returns "No Content" response
+
+require "datadog_api_client"
+DatadogAPIClient.configure do |config|
+  config.unstable_operations["v2.delete_execution_policy".to_sym] = true
+end
+api_instance = DatadogAPIClient::V2::ExecutionPolicyAPI.new
+
+# there is a valid "execution_policy" in the system
+EXECUTION_POLICY_DATA_ID = ENV["EXECUTION_POLICY_DATA_ID"]
+api_instance.delete_execution_policy(EXECUTION_POLICY_DATA_ID)

data/examples/v2/execution-policy/GetExecutionPolicy.rb

@@ -0,0 +1,11 @@
+# Get an execution policy returns "OK" response
+
+require "datadog_api_client"
+DatadogAPIClient.configure do |config|
+  config.unstable_operations["v2.get_execution_policy".to_sym] = true
+end
+api_instance = DatadogAPIClient::V2::ExecutionPolicyAPI.new
+
+# there is a valid "execution_policy" in the system
+EXECUTION_POLICY_DATA_ID = ENV["EXECUTION_POLICY_DATA_ID"]
+p api_instance.get_execution_policy(EXECUTION_POLICY_DATA_ID)

data/examples/v2/execution-policy/ListExecutionPolicies.rb

@@ -0,0 +1,8 @@
+# List execution policies returns "OK" response
+
+require "datadog_api_client"
+DatadogAPIClient.configure do |config|
+  config.unstable_operations["v2.list_execution_policies".to_sym] = true
+end
+api_instance = DatadogAPIClient::V2::ExecutionPolicyAPI.new
+p api_instance.list_execution_policies()

data/examples/v2/execution-policy/ListExecutionPolicies_1745885519.rb

@@ -0,0 +1,33 @@
+# List execution policies with query parameters returns "OK" response
+
+require "datadog_api_client"
+DatadogAPIClient.configure do |config|
+  config.unstable_operations["v2.list_execution_policies".to_sym] = true
+end
+api_instance = DatadogAPIClient::V2::ExecutionPolicyAPI.new
+
+# there is a valid "execution_policy" in the system
+EXECUTION_POLICY_DATA_ATTRIBUTES_CREATED_BY = ENV["EXECUTION_POLICY_DATA_ATTRIBUTES_CREATED_BY"]
+EXECUTION_POLICY_DATA_ATTRIBUTES_NAME = ENV["EXECUTION_POLICY_DATA_ATTRIBUTES_NAME"]
+EXECUTION_POLICY_DATA_ID = ENV["EXECUTION_POLICY_DATA_ID"]
+opts = {
+  page_size: 10,
+  page_number: 0,
+  filter_name: EXECUTION_POLICY_DATA_ATTRIBUTES_NAME,
+  filter_ids: [
+    EXECUTION_POLICY_DATA_ID,
+  ],
+  filter_integration: [
+    ExecutionPolicyIntegration::INTEGRATION_SCRIPT,
+  ],
+  filter_effects: [
+    ExecutionPolicyEffect::ALLOW,
+  ],
+  filter_creator_ids: [
+    EXECUTION_POLICY_DATA_ATTRIBUTES_CREATED_BY,
+  ],
+  sort: [
+    "-created_at",
+  ],
+}
+p api_instance.list_execution_policies(opts)

data/examples/v2/execution-policy/UpdateExecutionPolicy.rb

@@ -0,0 +1,28 @@
+# Update an execution policy returns "OK" response
+
+require "datadog_api_client"
+DatadogAPIClient.configure do |config|
+  config.unstable_operations["v2.update_execution_policy".to_sym] = true
+end
+api_instance = DatadogAPIClient::V2::ExecutionPolicyAPI.new
+
+# there is a valid "execution_policy" in the system
+EXECUTION_POLICY_DATA_ID = ENV["EXECUTION_POLICY_DATA_ID"]
+
+body = DatadogAPIClient::V2::ExecutionPolicyUpdateRequest.new({
+  data: DatadogAPIClient::V2::ExecutionPolicyUpdateRequestData.new({
+    id: EXECUTION_POLICY_DATA_ID,
+    type: DatadogAPIClient::V2::ExecutionPolicyType::EXECUTION_POLICY,
+    attributes: DatadogAPIClient::V2::ExecutionPolicyWriteAttributes.new({
+      name: "Cassette Execution Policy Updated",
+      effect: DatadogAPIClient::V2::ExecutionPolicyEffect::ALLOW,
+      action_pattern: DatadogAPIClient::V2::ExecutionPolicyActionPattern.new({
+        integration: DatadogAPIClient::V2::ExecutionPolicyIntegration::INTEGRATION_SCRIPT,
+        action_fqns: [
+          "com.datadoghq.script.*",
+        ],
+      }),
+    }),
+  }),
+})
+p api_instance.update_execution_policy(EXECUTION_POLICY_DATA_ID, body)

data/examples/v2/feature-flags/CreateFeatureFlag.rb

@@ -8,9 +8,14 @@ body = DatadogAPIClient::V2::CreateFeatureFlagRequest.new({
     type: DatadogAPIClient::V2::CreateFeatureFlagDataType::FEATURE_FLAGS,
     attributes: DatadogAPIClient::V2::CreateFeatureFlagAttributes.new({
       default_variant_key: "variant-Example-Feature-Flag-1",
-      description: "Test feature flag for BDD scenarios",
+      distribution_channel: DatadogAPIClient::V2::FeatureFlagDistributionChannel::SERVER,
       key: "test-feature-flag-Example-Feature-Flag",
       name: "Test Feature Flag Example-Feature-Flag",
+      require_approval: false,
+      staleness_status: DatadogAPIClient::V2::CreateFeatureFlagStalenessStatus::PERMANENT,
+      tags: [
+        "env:api-client-test",
+      ],
       value_type: DatadogAPIClient::V2::ValueType::BOOLEAN,
       variants: [
         DatadogAPIClient::V2::CreateVariant.new({

data/examples/v2/monitors/CreateMonitorNotificationRule_678042569.rb

@@ -0,0 +1,25 @@
+# Create a monitor notification rule with bundle config returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::MonitorsAPI.new
+
+body = DatadogAPIClient::V2::MonitorNotificationRuleCreateRequest.new({
+  data: DatadogAPIClient::V2::MonitorNotificationRuleCreateRequestData.new({
+    attributes: DatadogAPIClient::V2::MonitorNotificationRuleAttributes.new({
+      filter: DatadogAPIClient::V2::MonitorNotificationRuleFilterTags.new({
+        tags: [
+          "test:example-monitor",
+        ],
+      }),
+      name: "test rule",
+      recipients: [
+        "slack-test-channel",
+      ],
+      bundle_config: DatadogAPIClient::V2::MonitorNotificationRuleBundleConfig.new({
+        duration: 3600,
+      }),
+    }),
+    type: DatadogAPIClient::V2::MonitorNotificationRuleResourceType::MONITOR_NOTIFICATION_RULE,
+  }),
+})
+p api_instance.create_monitor_notification_rule(body)

data/examples/v2/monitors/UpdateMonitorNotificationRule_752032728.rb

@@ -0,0 +1,29 @@
+# Update a monitor notification rule with bundle config returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::MonitorsAPI.new
+
+# there is a valid "monitor_notification_rule" in the system
+MONITOR_NOTIFICATION_RULE_DATA_ID = ENV["MONITOR_NOTIFICATION_RULE_DATA_ID"]
+
+body = DatadogAPIClient::V2::MonitorNotificationRuleUpdateRequest.new({
+  data: DatadogAPIClient::V2::MonitorNotificationRuleUpdateRequestData.new({
+    attributes: DatadogAPIClient::V2::MonitorNotificationRuleAttributes.new({
+      filter: DatadogAPIClient::V2::MonitorNotificationRuleFilterTags.new({
+        tags: [
+          "test:example-monitor",
+        ],
+      }),
+      name: "updated rule",
+      recipients: [
+        "slack-test-channel",
+      ],
+      bundle_config: DatadogAPIClient::V2::MonitorNotificationRuleBundleConfig.new({
+        duration: 3600,
+      }),
+    }),
+    id: MONITOR_NOTIFICATION_RULE_DATA_ID,
+    type: DatadogAPIClient::V2::MonitorNotificationRuleResourceType::MONITOR_NOTIFICATION_RULE,
+  }),
+})
+p api_instance.update_monitor_notification_rule(MONITOR_NOTIFICATION_RULE_DATA_ID, body)

data/examples/v2/observability-pipelines/ValidatePipeline_1874470273.rb

@@ -0,0 +1,51 @@
+# Validate an observability pipeline with Splunk HEC destination endpoint_target returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::ObservabilityPipelinesAPI.new
+
+body = DatadogAPIClient::V2::ObservabilityPipelineSpec.new({
+  data: DatadogAPIClient::V2::ObservabilityPipelineSpecData.new({
+    attributes: DatadogAPIClient::V2::ObservabilityPipelineDataAttributes.new({
+      config: DatadogAPIClient::V2::ObservabilityPipelineConfig.new({
+        destinations: [
+          DatadogAPIClient::V2::ObservabilityPipelineSplunkHecDestination.new({
+            id: "splunk-hec-destination",
+            inputs: [
+              "my-processor-group",
+            ],
+            type: DatadogAPIClient::V2::ObservabilityPipelineSplunkHecDestinationType::SPLUNK_HEC,
+            token_key: "SPLUNK_HEC_TOKEN",
+            endpoint_target: DatadogAPIClient::V2::ObservabilityPipelineSplunkHecDestinationEndpointTarget::RAW,
+          }),
+        ],
+        processor_groups: [
+          DatadogAPIClient::V2::ObservabilityPipelineConfigProcessorGroup.new({
+            enabled: true,
+            id: "my-processor-group",
+            include: "service:my-service",
+            inputs: [
+              "datadog-agent-source",
+            ],
+            processors: [
+              DatadogAPIClient::V2::ObservabilityPipelineFilterProcessor.new({
+                enabled: true,
+                id: "filter-processor",
+                include: "status:error",
+                type: DatadogAPIClient::V2::ObservabilityPipelineFilterProcessorType::FILTER,
+              }),
+            ],
+          }),
+        ],
+        sources: [
+          DatadogAPIClient::V2::ObservabilityPipelineDatadogAgentSource.new({
+            id: "datadog-agent-source",
+            type: DatadogAPIClient::V2::ObservabilityPipelineDatadogAgentSourceType::DATADOG_AGENT,
+          }),
+        ],
+      }),
+      name: "Pipeline with Splunk HEC endpoint_target",
+    }),
+    type: "pipelines",
+  }),
+})
+p api_instance.validate_pipeline(body)

data/examples/v2/observability-pipelines/ValidatePipeline_3116312807.rb

@@ -0,0 +1,50 @@
+# Validate an observability pipeline with Splunk TCP source max_connection_duration_secs returns "OK" response
+
+require "datadog_api_client"
+api_instance = DatadogAPIClient::V2::ObservabilityPipelinesAPI.new
+
+body = DatadogAPIClient::V2::ObservabilityPipelineSpec.new({
+  data: DatadogAPIClient::V2::ObservabilityPipelineSpecData.new({
+    attributes: DatadogAPIClient::V2::ObservabilityPipelineDataAttributes.new({
+      config: DatadogAPIClient::V2::ObservabilityPipelineConfig.new({
+        destinations: [
+          DatadogAPIClient::V2::ObservabilityPipelineDatadogLogsDestination.new({
+            id: "datadog-logs-destination",
+            inputs: [
+              "my-processor-group",
+            ],
+            type: DatadogAPIClient::V2::ObservabilityPipelineDatadogLogsDestinationType::DATADOG_LOGS,
+          }),
+        ],
+        processor_groups: [
+          DatadogAPIClient::V2::ObservabilityPipelineConfigProcessorGroup.new({
+            enabled: true,
+            id: "my-processor-group",
+            include: "service:my-service",
+            inputs: [
+              "splunk-tcp-source",
+            ],
+            processors: [
+              DatadogAPIClient::V2::ObservabilityPipelineFilterProcessor.new({
+                enabled: true,
+                id: "filter-processor",
+                include: "status:error",
+                type: DatadogAPIClient::V2::ObservabilityPipelineFilterProcessorType::FILTER,
+              }),
+            ],
+          }),
+        ],
+        sources: [
+          DatadogAPIClient::V2::ObservabilityPipelineSplunkTcpSource.new({
+            id: "splunk-tcp-source",
+            type: DatadogAPIClient::V2::ObservabilityPipelineSplunkTcpSourceType::SPLUNK_TCP,
+            max_connection_duration_secs: 3600,
+          }),
+        ],
+      }),
+      name: "Pipeline with Splunk TCP max connection duration",
+    }),
+    type: "pipelines",
+  }),
+})
+p api_instance.validate_pipeline(body)

data/examples/v2/org-groups/UpdateOrgGroupPolicy.rb

@@ -13,6 +13,7 @@ body = DatadogAPIClient::V2::OrgGroupPolicyUpdateRequest.new({
         "value": "UTC",
       },
       enforcement_tier: DatadogAPIClient::V2::OrgGroupPolicyEnforcementTier::OVERRIDE_ALLOWED,
+      policy_name: "monitor_timezone",
     }),
     id: "1a2b3c4d-5e6f-7890-abcd-ef0123456789",
     type: DatadogAPIClient::V2::OrgGroupPolicyType::ORG_GROUP_POLICIES,

data/examples/v2/product-analytics/QueryProductAnalyticsJourneyFunnel.rb

@@ -0,0 +1,90 @@
+# Compute journey funnel analysis returns "OK" response
+
+require "datadog_api_client"
+DatadogAPIClient.configure do |config|
+  config.unstable_operations["v2.query_product_analytics_journey_funnel".to_sym] = true
+end
+api_instance = DatadogAPIClient::V2::ProductAnalyticsAPI.new
+
+body = DatadogAPIClient::V2::ProductAnalyticsJourneyFunnelRequest.new({
+  data: DatadogAPIClient::V2::ProductAnalyticsJourneyFunnelRequestData.new({
+    attributes: DatadogAPIClient::V2::ProductAnalyticsJourneyFunnelRequestAttributes.new({
+      exclude_anonymous_traffic: false,
+      from: 1756425600000,
+      query: DatadogAPIClient::V2::ProductAnalyticsJourneyFunnelQuery.new({
+        compute: DatadogAPIClient::V2::ProductAnalyticsJourneyFunnelCompute.new({}),
+        group_by: [
+          DatadogAPIClient::V2::ProductAnalyticsGraphQueryGroupBy.new({
+            facet: "@geo.country",
+            should_exclude_missing: false,
+            sort: DatadogAPIClient::V2::ProductAnalyticsGroupBySort.new({
+              aggregation: "count",
+              order: DatadogAPIClient::V2::QuerySortOrder::DESC,
+            }),
+            source: DatadogAPIClient::V2::ProductAnalyticsGraphQueryGroupBySource::USERS,
+            target: DatadogAPIClient::V2::ProductAnalyticsJourneyNodeTarget.new({
+              type: DatadogAPIClient::V2::ProductAnalyticsJourneyNodeTargetType::NODE,
+              value: "A",
+            }),
+            value_filters: [],
+          }),
+        ],
+        search: DatadogAPIClient::V2::ProductAnalyticsJourneySearch.new({
+          expression: "A -> B",
+          filters: DatadogAPIClient::V2::ProductAnalyticsJourneySearchFilters.new({
+            audience_filters: DatadogAPIClient::V2::ProductAnalyticsJourneyAudienceFilters.new({
+              accounts: [
+                DatadogAPIClient::V2::ProductAnalyticsJourneyAudienceAccountQuery.new({
+                  name: "enterprise_accounts",
+                }),
+              ],
+              formula: "power_users AND NOT trial_segment",
+              segments: [
+                DatadogAPIClient::V2::ProductAnalyticsJourneyAudienceSegmentQuery.new({
+                  name: "trial_segment",
+                  segment_id: "00000000-0000-0000-0000-000000000000",
+                }),
+              ],
+              users: [
+                DatadogAPIClient::V2::ProductAnalyticsJourneyAudienceUserQuery.new({
+                  name: "power_users",
+                }),
+              ],
+            }),
+            graph_filters: [
+              DatadogAPIClient::V2::ProductAnalyticsJourneySearchGraphFilter.new({
+                name: DatadogAPIClient::V2::ProductAnalyticsJourneySearchGraphFilterName::TIME_TO_CONVERT,
+                operator: DatadogAPIClient::V2::ProductAnalyticsJourneySearchGraphFilterOperator::LESS_THAN_OR_EQUAL,
+                target: DatadogAPIClient::V2::ProductAnalyticsJourneyNodeTarget.new({
+                  type: DatadogAPIClient::V2::ProductAnalyticsJourneyNodeTargetType::NODE,
+                  value: "A",
+                }),
+                value: 60000,
+              }),
+            ],
+          }),
+          join_keys: DatadogAPIClient::V2::ProductAnalyticsJoinKeys.new({
+            primary: "@session.id",
+            secondary: [],
+          }),
+          node_objects: {
+            A: DatadogAPIClient::V2::ProductAnalyticsEventQuery.new({
+              data_source: DatadogAPIClient::V2::ProductAnalyticsEventQueryDataSource::PRODUCT_ANALYTICS,
+              search: DatadogAPIClient::V2::ProductAnalyticsEventSearch.new({
+                query: "@type:view @view.name:Login",
+              }),
+            }), B: DatadogAPIClient::V2::ProductAnalyticsEventQuery.new({
+              data_source: DatadogAPIClient::V2::ProductAnalyticsEventQueryDataSource::PRODUCT_ANALYTICS,
+              search: DatadogAPIClient::V2::ProductAnalyticsEventSearch.new({
+                query: "@type:action @action.target.name:Submit",
+              }),
+            }),
+          },
+        }),
+      }),
+      to: 1756857600000,
+    }),
+    type: DatadogAPIClient::V2::ProductAnalyticsJourneyRequestType::JOURNEY_REQUEST,
+  }),
+})
+p api_instance.query_product_analytics_journey_funnel(body)

data/examples/v2/product-analytics/QueryProductAnalyticsJourneyList.rb

@@ -0,0 +1,102 @@
+# List journey entities returns "OK" response
+
+require "datadog_api_client"
+DatadogAPIClient.configure do |config|
+  config.unstable_operations["v2.query_product_analytics_journey_list".to_sym] = true
+end
+api_instance = DatadogAPIClient::V2::ProductAnalyticsAPI.new
+
+body = DatadogAPIClient::V2::ProductAnalyticsJourneyListRequest.new({
+  data: DatadogAPIClient::V2::ProductAnalyticsJourneyListRequestData.new({
+    attributes: DatadogAPIClient::V2::ProductAnalyticsJourneyListRequestAttributes.new({
+      from: 1756425600000,
+      query: DatadogAPIClient::V2::ProductAnalyticsJourneyListQuery.new({
+        computed_columns: [
+          DatadogAPIClient::V2::ProductAnalyticsJourneyComputedColumn.new({
+            name: DatadogAPIClient::V2::ProductAnalyticsJourneyComputedColumnName::FIRST_CONVERSION_TIMESTAMPS,
+          }),
+        ],
+        conversion_type: DatadogAPIClient::V2::ProductAnalyticsJourneyConversionType::CONVERSION,
+        entity_columns: [],
+        group_by: [
+          DatadogAPIClient::V2::ProductAnalyticsGraphQueryGroupBy.new({
+            facet: "@geo.country",
+            should_exclude_missing: false,
+            sort: DatadogAPIClient::V2::ProductAnalyticsGroupBySort.new({
+              aggregation: "count",
+              order: DatadogAPIClient::V2::QuerySortOrder::DESC,
+            }),
+            source: DatadogAPIClient::V2::ProductAnalyticsGraphQueryGroupBySource::USERS,
+            target: DatadogAPIClient::V2::ProductAnalyticsJourneyNodeTarget.new({
+              type: DatadogAPIClient::V2::ProductAnalyticsJourneyNodeTargetType::NODE,
+              value: "A",
+            }),
+            value_filters: [],
+          }),
+        ],
+        search: DatadogAPIClient::V2::ProductAnalyticsJourneySearch.new({
+          expression: "A -> B",
+          filters: DatadogAPIClient::V2::ProductAnalyticsJourneySearchFilters.new({
+            audience_filters: DatadogAPIClient::V2::ProductAnalyticsJourneyAudienceFilters.new({
+              accounts: [
+                DatadogAPIClient::V2::ProductAnalyticsJourneyAudienceAccountQuery.new({
+                  name: "enterprise_accounts",
+                }),
+              ],
+              formula: "power_users AND NOT trial_segment",
+              segments: [
+                DatadogAPIClient::V2::ProductAnalyticsJourneyAudienceSegmentQuery.new({
+                  name: "trial_segment",
+                  segment_id: "00000000-0000-0000-0000-000000000000",
+                }),
+              ],
+              users: [
+                DatadogAPIClient::V2::ProductAnalyticsJourneyAudienceUserQuery.new({
+                  name: "power_users",
+                }),
+              ],
+            }),
+            graph_filters: [
+              DatadogAPIClient::V2::ProductAnalyticsJourneySearchGraphFilter.new({
+                name: DatadogAPIClient::V2::ProductAnalyticsJourneySearchGraphFilterName::TIME_TO_CONVERT,
+                operator: DatadogAPIClient::V2::ProductAnalyticsJourneySearchGraphFilterOperator::LESS_THAN_OR_EQUAL,
+                target: DatadogAPIClient::V2::ProductAnalyticsJourneyNodeTarget.new({
+                  type: DatadogAPIClient::V2::ProductAnalyticsJourneyNodeTargetType::NODE,
+                  value: "A",
+                }),
+                value: 60000,
+              }),
+            ],
+          }),
+          join_keys: DatadogAPIClient::V2::ProductAnalyticsJoinKeys.new({
+            primary: "@session.id",
+            secondary: [],
+          }),
+          node_objects: {
+            A: DatadogAPIClient::V2::ProductAnalyticsEventQuery.new({
+              data_source: DatadogAPIClient::V2::ProductAnalyticsEventQueryDataSource::PRODUCT_ANALYTICS,
+              search: DatadogAPIClient::V2::ProductAnalyticsEventSearch.new({
+                query: "@type:view @view.name:Login",
+              }),
+            }), B: DatadogAPIClient::V2::ProductAnalyticsEventQuery.new({
+              data_source: DatadogAPIClient::V2::ProductAnalyticsEventQueryDataSource::PRODUCT_ANALYTICS,
+              search: DatadogAPIClient::V2::ProductAnalyticsEventSearch.new({
+                query: "@type:action @action.target.name:Submit",
+              }),
+            }),
+          },
+        }),
+        sort: DatadogAPIClient::V2::ProductAnalyticsJourneyListSort.new({
+          order: DatadogAPIClient::V2::QuerySortOrder::DESC,
+        }),
+        target: DatadogAPIClient::V2::ProductAnalyticsJourneyNodeTarget.new({
+          type: DatadogAPIClient::V2::ProductAnalyticsJourneyNodeTargetType::NODE,
+          value: "A",
+        }),
+      }),
+      to: 1756857600000,
+    }),
+    type: DatadogAPIClient::V2::ProductAnalyticsJourneyListRequestType::JOURNEY_LIST_REQUEST,
+  }),
+})
+p api_instance.query_product_analytics_journey_list(body)