리텐션 셀 뒤에 있는 엔티티를 나열하십시오.

v2 (latest)

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

POST https://api.ap1.datadoghq.com/api/v2/product-analytics/retention/listhttps://api.ap2.datadoghq.com/api/v2/product-analytics/retention/listhttps://api.datadoghq.eu/api/v2/product-analytics/retention/listhttps://api.ddog-gov.com/api/v2/product-analytics/retention/listhttps://api.us2.ddog-gov.com/api/v2/product-analytics/retention/listhttps://api.uk1.datadoghq.com/api/v2/product-analytics/retention/listhttps://api.datadoghq.com/api/v2/product-analytics/retention/listhttps://api.us3.datadoghq.com/api/v2/product-analytics/retention/listhttps://api.us5.datadoghq.com/api/v2/product-analytics/retention/list

개요

리텐션 그리드의 한 셀에 집계된 개별 사용자 또는 계정을 나열합니다. computation_scope를 조사하려는 코호트 및 반환 기간으로 설정합니다. This endpoint requires the rum_apps_read permission.

요청

Body Data (required)

리텐션 목록 쿼리입니다.

Expand All

항목

유형

설명

data [required]

object

The single JSON:API resource carrying a retention list query. Its attributes hold the time window, the cell to list, and the columns to return for each entity.

attributes [required]

object

Attributes of a retention list request.

query [required]

object

Query definition for a retention list request.

search [required]

object

Defines the cohort and return criteria that make up a retention query.

cohort_criteria [required]

object

Defines the event that places an entity into a cohort, and how cohorts are bucketed over time.

return_criteria

object

Defines the event that counts as a return, and the window in which it must occur.

{
  "data": {
    "attributes": {
      "from": 1756425600000,
      "query": {
        "columns": [
          {
            "field": {
              "path": "@usr.email"
            }
          }
        ],
        "computation_scope": {
          "cohort_target": {
            "type": "index",
            "value": 0
          },
          "return_period_target": {
            "type": "index",
            "value": 0
          },
          "type": "cell"
        },
        "limit": 100,
        "search": {
          "cohort_criteria": {
            "base_query": {
              "data_source": "product_analytics",
              "search": {
                "query": "@type:view"
              }
            },
            "time_interval": {
              "type": "calendar",
              "value": {
                "alignment": "monday",
                "quantity": 1,
                "timezone": "UTC",
                "type": "week"
              }
            }
          },
          "filters": {
            "audience_filters": {
              "accounts": [
                {
                  "name": "",
                  "query": "string"
                }
              ],
              "formula": "u",
              "segments": [
                {
                  "name": "",
                  "segment_id": "00000000-0000-0000-0000-000000000000"
                }
              ],
              "users": [
                {
                  "name": "u",
                  "query": "*"
                }
              ]
            },
            "string_filter": "string"
          },
          "retention_entity": "@usr.id",
          "return_condition": "conversion_on_or_after",
          "return_criteria": {
            "base_query": {
              "data_source": "product_analytics",
              "search": {
                "query": "@type:view"
              }
            },
            "time_interval": {
              "type": "calendar",
              "value": {
                "alignment": "monday",
                "quantity": 1,
                "timezone": "UTC",
                "type": "week"
              }
            }
          }
        }
      },
      "to": 1756857600000
    },
    "type": "retention_list_request"
  }
}

응답

Response for a retention list query.

Expand All

항목

유형

설명

data [required]

object

The single JSON:API resource holding the entities behind one retention cell. Its attributes contain the entity whose retention was measured and one row per matching entity.

{
  "data": {
    "attributes": {
      "records": [],
      "retention_entity": "string"
    },
    "id": "00000000-0000-0000-0000-000000000000",
    "type": "retention_list_response"
  }
}

Bad Request

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

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

Not Authorized

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

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

Too many requests

API error response.

Expand All

항목

유형

설명

errors [required]

[string]

A list of errors.

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

코드 예시

                  ## default
# 

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

# Curl command
curl -X POST "https://api.ap1.datadoghq.com"https://api.ap2.datadoghq.com"https://api.datadoghq.eu"https://api.ddog-gov.com"https://api.us2.ddog-gov.com"https://api.uk1.datadoghq.com"https://api.datadoghq.com"https://api.us3.datadoghq.com"https://api.us5.datadoghq.com/api/v2/product-analytics/retention/list" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DD_BEARER_TOKEN}" \
-d @- << EOF
{
  "data": {
    "attributes": {
      "from": 1756425600000,
      "query": {
        "columns": [
          {
            "field": {
              "path": "@usr.email"
            }
          }
        ],
        "computation_scope": {
          "cohort_target": {
            "type": "index",
            "value": 0
          },
          "return_period_target": {
            "type": "index",
            "value": 1
          },
          "type": "cell"
        },
        "limit": 100,
        "search": {
          "cohort_criteria": {
            "base_query": {
              "data_source": "product_analytics",
              "search": {
                "query": "@type:view @view.name:Signup"
              }
            },
            "time_interval": {
              "type": "calendar",
              "value": {
                "quantity": 1,
                "type": "week"
              }
            }
          },
          "retention_entity": "@usr.id",
          "return_condition": "conversion_on_or_after"
        }
      },
      "to": 1756857600000
    },
    "type": "retention_list_request"
  }
}
EOF

                

"""
List the entities behind a retention cell returns "OK" response
"""

from os import environ
from datadog_api_client import ApiClient, Configuration
from datadog_api_client.v2.api.product_analytics_api import ProductAnalyticsApi
from datadog_api_client.v2.model.product_analytics_audience_account_subquery import (
    ProductAnalyticsAudienceAccountSubquery,
)
from datadog_api_client.v2.model.product_analytics_audience_filters import ProductAnalyticsAudienceFilters
from datadog_api_client.v2.model.product_analytics_audience_segment_subquery import (
    ProductAnalyticsAudienceSegmentSubquery,
)
from datadog_api_client.v2.model.product_analytics_audience_user_subquery import ProductAnalyticsAudienceUserSubquery
from datadog_api_client.v2.model.product_analytics_calendar_interval import ProductAnalyticsCalendarInterval
from datadog_api_client.v2.model.product_analytics_calendar_interval_type import ProductAnalyticsCalendarIntervalType
from datadog_api_client.v2.model.product_analytics_event_query import ProductAnalyticsEventQuery
from datadog_api_client.v2.model.product_analytics_event_query_data_source import ProductAnalyticsEventQueryDataSource
from datadog_api_client.v2.model.product_analytics_event_search import ProductAnalyticsEventSearch
from datadog_api_client.v2.model.product_analytics_retention_calendar_time_interval import (
    ProductAnalyticsRetentionCalendarTimeInterval,
)
from datadog_api_client.v2.model.product_analytics_retention_calendar_time_interval_type import (
    ProductAnalyticsRetentionCalendarTimeIntervalType,
)
from datadog_api_client.v2.model.product_analytics_retention_cell_scope import ProductAnalyticsRetentionCellScope
from datadog_api_client.v2.model.product_analytics_retention_cell_scope_type import (
    ProductAnalyticsRetentionCellScopeType,
)
from datadog_api_client.v2.model.product_analytics_retention_cohort_criteria import (
    ProductAnalyticsRetentionCohortCriteria,
)
from datadog_api_client.v2.model.product_analytics_retention_entity import ProductAnalyticsRetentionEntity
from datadog_api_client.v2.model.product_analytics_retention_filters import ProductAnalyticsRetentionFilters
from datadog_api_client.v2.model.product_analytics_retention_index_target import ProductAnalyticsRetentionIndexTarget
from datadog_api_client.v2.model.product_analytics_retention_index_target_type import (
    ProductAnalyticsRetentionIndexTargetType,
)
from datadog_api_client.v2.model.product_analytics_retention_list_column import ProductAnalyticsRetentionListColumn
from datadog_api_client.v2.model.product_analytics_retention_list_column_field import (
    ProductAnalyticsRetentionListColumnField,
)
from datadog_api_client.v2.model.product_analytics_retention_list_query import ProductAnalyticsRetentionListQuery
from datadog_api_client.v2.model.product_analytics_retention_list_request import ProductAnalyticsRetentionListRequest
from datadog_api_client.v2.model.product_analytics_retention_list_request_attributes import (
    ProductAnalyticsRetentionListRequestAttributes,
)
from datadog_api_client.v2.model.product_analytics_retention_list_request_data import (
    ProductAnalyticsRetentionListRequestData,
)
from datadog_api_client.v2.model.product_analytics_retention_list_request_type import (
    ProductAnalyticsRetentionListRequestType,
)
from datadog_api_client.v2.model.product_analytics_retention_return_condition import (
    ProductAnalyticsRetentionReturnCondition,
)
from datadog_api_client.v2.model.product_analytics_retention_return_criteria import (
    ProductAnalyticsRetentionReturnCriteria,
)
from datadog_api_client.v2.model.product_analytics_retention_search import ProductAnalyticsRetentionSearch
from uuid import UUID

body = ProductAnalyticsRetentionListRequest(
    data=ProductAnalyticsRetentionListRequestData(
        attributes=ProductAnalyticsRetentionListRequestAttributes(
            _from=1756425600000,
            query=ProductAnalyticsRetentionListQuery(
                columns=[
                    ProductAnalyticsRetentionListColumn(
                        field=ProductAnalyticsRetentionListColumnField(
                            path="@usr.email",
                        ),
                    ),
                ],
                computation_scope=ProductAnalyticsRetentionCellScope(
                    cohort_target=ProductAnalyticsRetentionIndexTarget(
                        type=ProductAnalyticsRetentionIndexTargetType.INDEX,
                        value=0,
                    ),
                    return_period_target=ProductAnalyticsRetentionIndexTarget(
                        type=ProductAnalyticsRetentionIndexTargetType.INDEX,
                        value=0,
                    ),
                    type=ProductAnalyticsRetentionCellScopeType.CELL,
                ),
                limit=100,
                search=ProductAnalyticsRetentionSearch(
                    cohort_criteria=ProductAnalyticsRetentionCohortCriteria(
                        base_query=ProductAnalyticsEventQuery(
                            data_source=ProductAnalyticsEventQueryDataSource.PRODUCT_ANALYTICS,
                            search=ProductAnalyticsEventSearch(
                                query="@type:view",
                            ),
                        ),
                        time_interval=ProductAnalyticsRetentionCalendarTimeInterval(
                            type=ProductAnalyticsRetentionCalendarTimeIntervalType.CALENDAR,
                            value=ProductAnalyticsCalendarInterval(
                                alignment="monday",
                                quantity=1,
                                timezone="UTC",
                                type=ProductAnalyticsCalendarIntervalType.WEEK,
                            ),
                        ),
                    ),
                    filters=ProductAnalyticsRetentionFilters(
                        audience_filters=ProductAnalyticsAudienceFilters(
                            accounts=[
                                ProductAnalyticsAudienceAccountSubquery(
                                    name="",
                                ),
                            ],
                            formula="u",
                            segments=[
                                ProductAnalyticsAudienceSegmentSubquery(
                                    name="",
                                    segment_id=UUID("00000000-0000-0000-0000-000000000000"),
                                ),
                            ],
                            users=[
                                ProductAnalyticsAudienceUserSubquery(
                                    name="u",
                                    query="*",
                                ),
                            ],
                        ),
                    ),
                    retention_entity=ProductAnalyticsRetentionEntity.USER_ID,
                    return_condition=ProductAnalyticsRetentionReturnCondition.CONVERSION_ON_OR_AFTER,
                    return_criteria=ProductAnalyticsRetentionReturnCriteria(
                        base_query=ProductAnalyticsEventQuery(
                            data_source=ProductAnalyticsEventQueryDataSource.PRODUCT_ANALYTICS,
                            search=ProductAnalyticsEventSearch(
                                query="@type:view",
                            ),
                        ),
                        time_interval=ProductAnalyticsRetentionCalendarTimeInterval(
                            type=ProductAnalyticsRetentionCalendarTimeIntervalType.CALENDAR,
                            value=ProductAnalyticsCalendarInterval(
                                alignment="monday",
                                quantity=1,
                                timezone="UTC",
                                type=ProductAnalyticsCalendarIntervalType.WEEK,
                            ),
                        ),
                    ),
                ),
            ),
            to=1756857600000,
        ),
        type=ProductAnalyticsRetentionListRequestType.RETENTION_LIST_REQUEST,
    ),
)

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

    print(response)

Instructions

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

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

# List the entities behind a retention cell returns "OK" response

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

body = DatadogAPIClient::V2::ProductAnalyticsRetentionListRequest.new({
  data: DatadogAPIClient::V2::ProductAnalyticsRetentionListRequestData.new({
    attributes: DatadogAPIClient::V2::ProductAnalyticsRetentionListRequestAttributes.new({
      from: 1756425600000,
      query: DatadogAPIClient::V2::ProductAnalyticsRetentionListQuery.new({
        columns: [
          DatadogAPIClient::V2::ProductAnalyticsRetentionListColumn.new({
            field: DatadogAPIClient::V2::ProductAnalyticsRetentionListColumnField.new({
              path: "@usr.email",
            }),
          }),
        ],
        computation_scope: DatadogAPIClient::V2::ProductAnalyticsRetentionCellScope.new({
          cohort_target: DatadogAPIClient::V2::ProductAnalyticsRetentionIndexTarget.new({
            type: DatadogAPIClient::V2::ProductAnalyticsRetentionIndexTargetType::INDEX,
            value: 0,
          }),
          return_period_target: DatadogAPIClient::V2::ProductAnalyticsRetentionIndexTarget.new({
            type: DatadogAPIClient::V2::ProductAnalyticsRetentionIndexTargetType::INDEX,
            value: 0,
          }),
          type: DatadogAPIClient::V2::ProductAnalyticsRetentionCellScopeType::CELL,
        }),
        limit: 100,
        search: DatadogAPIClient::V2::ProductAnalyticsRetentionSearch.new({
          cohort_criteria: DatadogAPIClient::V2::ProductAnalyticsRetentionCohortCriteria.new({
            base_query: DatadogAPIClient::V2::ProductAnalyticsEventQuery.new({
              data_source: DatadogAPIClient::V2::ProductAnalyticsEventQueryDataSource::PRODUCT_ANALYTICS,
              search: DatadogAPIClient::V2::ProductAnalyticsEventSearch.new({
                query: "@type:view",
              }),
            }),
            time_interval: DatadogAPIClient::V2::ProductAnalyticsRetentionCalendarTimeInterval.new({
              type: DatadogAPIClient::V2::ProductAnalyticsRetentionCalendarTimeIntervalType::CALENDAR,
              value: DatadogAPIClient::V2::ProductAnalyticsCalendarInterval.new({
                alignment: "monday",
                quantity: 1,
                timezone: "UTC",
                type: DatadogAPIClient::V2::ProductAnalyticsCalendarIntervalType::WEEK,
              }),
            }),
          }),
          filters: DatadogAPIClient::V2::ProductAnalyticsRetentionFilters.new({
            audience_filters: DatadogAPIClient::V2::ProductAnalyticsAudienceFilters.new({
              accounts: [
                DatadogAPIClient::V2::ProductAnalyticsAudienceAccountSubquery.new({
                  name: "",
                }),
              ],
              formula: "u",
              segments: [
                DatadogAPIClient::V2::ProductAnalyticsAudienceSegmentSubquery.new({
                  name: "",
                  segment_id: "00000000-0000-0000-0000-000000000000",
                }),
              ],
              users: [
                DatadogAPIClient::V2::ProductAnalyticsAudienceUserSubquery.new({
                  name: "u",
                  query: "*",
                }),
              ],
            }),
          }),
          retention_entity: DatadogAPIClient::V2::ProductAnalyticsRetentionEntity::USER_ID,
          return_condition: DatadogAPIClient::V2::ProductAnalyticsRetentionReturnCondition::CONVERSION_ON_OR_AFTER,
          return_criteria: DatadogAPIClient::V2::ProductAnalyticsRetentionReturnCriteria.new({
            base_query: DatadogAPIClient::V2::ProductAnalyticsEventQuery.new({
              data_source: DatadogAPIClient::V2::ProductAnalyticsEventQueryDataSource::PRODUCT_ANALYTICS,
              search: DatadogAPIClient::V2::ProductAnalyticsEventSearch.new({
                query: "@type:view",
              }),
            }),
            time_interval: DatadogAPIClient::V2::ProductAnalyticsRetentionCalendarTimeInterval.new({
              type: DatadogAPIClient::V2::ProductAnalyticsRetentionCalendarTimeIntervalType::CALENDAR,
              value: DatadogAPIClient::V2::ProductAnalyticsCalendarInterval.new({
                alignment: "monday",
                quantity: 1,
                timezone: "UTC",
                type: DatadogAPIClient::V2::ProductAnalyticsCalendarIntervalType::WEEK,
              }),
            }),
          }),
        }),
      }),
      to: 1756857600000,
    }),
    type: DatadogAPIClient::V2::ProductAnalyticsRetentionListRequestType::RETENTION_LIST_REQUEST,
  }),
})
p api_instance.query_product_analytics_retention_list(body)

Instructions

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

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

// List the entities behind a retention cell returns "OK" response

package main

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

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

func main() {
	body := datadogV2.ProductAnalyticsRetentionListRequest{
		Data: datadogV2.ProductAnalyticsRetentionListRequestData{
			Attributes: datadogV2.ProductAnalyticsRetentionListRequestAttributes{
				From: 1756425600000,
				Query: datadogV2.ProductAnalyticsRetentionListQuery{
					Columns: []datadogV2.ProductAnalyticsRetentionListColumn{
						{
							Field: &datadogV2.ProductAnalyticsRetentionListColumnField{
								Path: datadog.PtrString("@usr.email"),
							},
						},
					},
					ComputationScope: datadogV2.ProductAnalyticsRetentionCellScope{
						CohortTarget: datadogV2.ProductAnalyticsRetentionCohortTarget{
							ProductAnalyticsRetentionIndexTarget: &datadogV2.ProductAnalyticsRetentionIndexTarget{
								Type:  datadogV2.PRODUCTANALYTICSRETENTIONINDEXTARGETTYPE_INDEX,
								Value: 0,
							}},
						ReturnPeriodTarget: datadogV2.ProductAnalyticsRetentionIndexTarget{
							Type:  datadogV2.PRODUCTANALYTICSRETENTIONINDEXTARGETTYPE_INDEX,
							Value: 0,
						},
						Type: datadogV2.PRODUCTANALYTICSRETENTIONCELLSCOPETYPE_CELL,
					},
					Limit: datadog.PtrInt64(100),
					Search: datadogV2.ProductAnalyticsRetentionSearch{
						CohortCriteria: datadogV2.ProductAnalyticsRetentionCohortCriteria{
							BaseQuery: datadogV2.ProductAnalyticsBaseQuery{
								ProductAnalyticsEventQuery: &datadogV2.ProductAnalyticsEventQuery{
									DataSource: datadogV2.PRODUCTANALYTICSEVENTQUERYDATASOURCE_PRODUCT_ANALYTICS,
									Search: datadogV2.ProductAnalyticsEventSearch{
										Query: datadog.PtrString("@type:view"),
									},
								}},
							TimeInterval: datadogV2.ProductAnalyticsRetentionTimeInterval{
								ProductAnalyticsRetentionCalendarTimeInterval: &datadogV2.ProductAnalyticsRetentionCalendarTimeInterval{
									Type: datadogV2.PRODUCTANALYTICSRETENTIONCALENDARTIMEINTERVALTYPE_CALENDAR,
									Value: datadogV2.ProductAnalyticsCalendarInterval{
										Alignment: datadog.PtrString("monday"),
										Quantity:  datadog.PtrInt64(1),
										Timezone:  datadog.PtrString("UTC"),
										Type:      datadogV2.PRODUCTANALYTICSCALENDARINTERVALTYPE_WEEK,
									},
								}},
						},
						Filters: &datadogV2.ProductAnalyticsRetentionFilters{
							AudienceFilters: &datadogV2.ProductAnalyticsAudienceFilters{
								Accounts: []datadogV2.ProductAnalyticsAudienceAccountSubquery{
									{
										Name: "",
									},
								},
								Formula: datadog.PtrString("u"),
								Segments: []datadogV2.ProductAnalyticsAudienceSegmentSubquery{
									{
										Name:      "",
										SegmentId: uuid.MustParse("00000000-0000-0000-0000-000000000000"),
									},
								},
								Users: []datadogV2.ProductAnalyticsAudienceUserSubquery{
									{
										Name:  "u",
										Query: datadog.PtrString("*"),
									},
								},
							},
						},
						RetentionEntity: datadogV2.PRODUCTANALYTICSRETENTIONENTITY_USER_ID,
						ReturnCondition: datadogV2.PRODUCTANALYTICSRETENTIONRETURNCONDITION_CONVERSION_ON_OR_AFTER,
						ReturnCriteria: &datadogV2.ProductAnalyticsRetentionReturnCriteria{
							BaseQuery: datadogV2.ProductAnalyticsBaseQuery{
								ProductAnalyticsEventQuery: &datadogV2.ProductAnalyticsEventQuery{
									DataSource: datadogV2.PRODUCTANALYTICSEVENTQUERYDATASOURCE_PRODUCT_ANALYTICS,
									Search: datadogV2.ProductAnalyticsEventSearch{
										Query: datadog.PtrString("@type:view"),
									},
								}},
							TimeInterval: &datadogV2.ProductAnalyticsRetentionTimeInterval{
								ProductAnalyticsRetentionCalendarTimeInterval: &datadogV2.ProductAnalyticsRetentionCalendarTimeInterval{
									Type: datadogV2.PRODUCTANALYTICSRETENTIONCALENDARTIMEINTERVALTYPE_CALENDAR,
									Value: datadogV2.ProductAnalyticsCalendarInterval{
										Alignment: datadog.PtrString("monday"),
										Quantity:  datadog.PtrInt64(1),
										Timezone:  datadog.PtrString("UTC"),
										Type:      datadogV2.PRODUCTANALYTICSCALENDARINTERVALTYPE_WEEK,
									},
								}},
						},
					},
				},
				To: 1756857600000,
			},
			Type: datadogV2.PRODUCTANALYTICSRETENTIONLISTREQUESTTYPE_RETENTION_LIST_REQUEST,
		},
	}
	ctx := datadog.NewDefaultContext(context.Background())
	ctx = context.WithValue(ctx, datadog.ContextAccessToken, os.Getenv("DD_BEARER_TOKEN"))
	configuration := datadog.NewConfiguration()
	configuration.SetUnstableOperationEnabled("v2.QueryProductAnalyticsRetentionList", true)
	apiClient := datadog.NewAPIClient(configuration)
	api := datadogV2.NewProductAnalyticsApi(apiClient)
	resp, r, err := api.QueryProductAnalyticsRetentionList(ctx, body)

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

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

Instructions

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

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

// List the entities behind a retention cell returns "OK" response

import com.datadog.api.client.ApiClient;
import com.datadog.api.client.ApiException;
import com.datadog.api.client.v2.api.ProductAnalyticsApi;
import com.datadog.api.client.v2.model.ProductAnalyticsAudienceAccountSubquery;
import com.datadog.api.client.v2.model.ProductAnalyticsAudienceFilters;
import com.datadog.api.client.v2.model.ProductAnalyticsAudienceSegmentSubquery;
import com.datadog.api.client.v2.model.ProductAnalyticsAudienceUserSubquery;
import com.datadog.api.client.v2.model.ProductAnalyticsBaseQuery;
import com.datadog.api.client.v2.model.ProductAnalyticsCalendarInterval;
import com.datadog.api.client.v2.model.ProductAnalyticsCalendarIntervalType;
import com.datadog.api.client.v2.model.ProductAnalyticsEventQuery;
import com.datadog.api.client.v2.model.ProductAnalyticsEventQueryDataSource;
import com.datadog.api.client.v2.model.ProductAnalyticsEventSearch;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCalendarTimeInterval;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCalendarTimeIntervalType;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCellScope;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCellScopeType;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCohortCriteria;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionCohortTarget;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionEntity;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionFilters;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionIndexTarget;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionIndexTargetType;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListColumn;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListColumnField;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListQuery;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListRequest;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListRequestAttributes;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListRequestData;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListRequestType;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionListResponse;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionReturnCondition;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionReturnCriteria;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionSearch;
import com.datadog.api.client.v2.model.ProductAnalyticsRetentionTimeInterval;
import java.util.Collections;
import java.util.UUID;

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

    ProductAnalyticsRetentionListRequest body =
        new ProductAnalyticsRetentionListRequest()
            .data(
                new ProductAnalyticsRetentionListRequestData()
                    .attributes(
                        new ProductAnalyticsRetentionListRequestAttributes()
                            .from(1756425600000L)
                            .query(
                                new ProductAnalyticsRetentionListQuery()
                                    .columns(
                                        Collections.singletonList(
                                            new ProductAnalyticsRetentionListColumn()
                                                .field(
                                                    new ProductAnalyticsRetentionListColumnField()
                                                        .path("@usr.email"))))
                                    .computationScope(
                                        new ProductAnalyticsRetentionCellScope()
                                            .cohortTarget(
                                                new ProductAnalyticsRetentionCohortTarget(
                                                    new ProductAnalyticsRetentionIndexTarget()
                                                        .type(
                                                            ProductAnalyticsRetentionIndexTargetType
                                                                .INDEX)
                                                        .value(0L)))
                                            .returnPeriodTarget(
                                                new ProductAnalyticsRetentionIndexTarget()
                                                    .type(
                                                        ProductAnalyticsRetentionIndexTargetType
                                                            .INDEX)
                                                    .value(0L))
                                            .type(ProductAnalyticsRetentionCellScopeType.CELL))
                                    .limit(100L)
                                    .search(
                                        new ProductAnalyticsRetentionSearch()
                                            .cohortCriteria(
                                                new ProductAnalyticsRetentionCohortCriteria()
                                                    .baseQuery(
                                                        new ProductAnalyticsBaseQuery(
                                                            new ProductAnalyticsEventQuery()
                                                                .dataSource(
                                                                    ProductAnalyticsEventQueryDataSource
                                                                        .PRODUCT_ANALYTICS)
                                                                .search(
                                                                    new ProductAnalyticsEventSearch()
                                                                        .query("@type:view"))))
                                                    .timeInterval(
                                                        new ProductAnalyticsRetentionTimeInterval(
                                                            new ProductAnalyticsRetentionCalendarTimeInterval()
                                                                .type(
                                                                    ProductAnalyticsRetentionCalendarTimeIntervalType
                                                                        .CALENDAR)
                                                                .value(
                                                                    new ProductAnalyticsCalendarInterval()
                                                                        .alignment("monday")
                                                                        .quantity(1L)
                                                                        .timezone("UTC")
                                                                        .type(
                                                                            ProductAnalyticsCalendarIntervalType
                                                                                .WEEK)))))
                                            .filters(
                                                new ProductAnalyticsRetentionFilters()
                                                    .audienceFilters(
                                                        new ProductAnalyticsAudienceFilters()
                                                            .accounts(
                                                                Collections.singletonList(
                                                                    new ProductAnalyticsAudienceAccountSubquery()
                                                                        .name("")))
                                                            .formula("u")
                                                            .segments(
                                                                Collections.singletonList(
                                                                    new ProductAnalyticsAudienceSegmentSubquery()
                                                                        .name("")
                                                                        .segmentId(
                                                                            UUID.fromString(
                                                                                "00000000-0000-0000-0000-000000000000"))))
                                                            .users(
                                                                Collections.singletonList(
                                                                    new ProductAnalyticsAudienceUserSubquery()
                                                                        .name("u")
                                                                        .query("*")))))
                                            .retentionEntity(
                                                ProductAnalyticsRetentionEntity.USER_ID)
                                            .returnCondition(
                                                ProductAnalyticsRetentionReturnCondition
                                                    .CONVERSION_ON_OR_AFTER)
                                            .returnCriteria(
                                                new ProductAnalyticsRetentionReturnCriteria()
                                                    .baseQuery(
                                                        new ProductAnalyticsBaseQuery(
                                                            new ProductAnalyticsEventQuery()
                                                                .dataSource(
                                                                    ProductAnalyticsEventQueryDataSource
                                                                        .PRODUCT_ANALYTICS)
                                                                .search(
                                                                    new ProductAnalyticsEventSearch()
                                                                        .query("@type:view"))))
                                                    .timeInterval(
                                                        new ProductAnalyticsRetentionTimeInterval(
                                                            new ProductAnalyticsRetentionCalendarTimeInterval()
                                                                .type(
                                                                    ProductAnalyticsRetentionCalendarTimeIntervalType
                                                                        .CALENDAR)
                                                                .value(
                                                                    new ProductAnalyticsCalendarInterval()
                                                                        .alignment("monday")
                                                                        .quantity(1L)
                                                                        .timezone("UTC")
                                                                        .type(
                                                                            ProductAnalyticsCalendarIntervalType
                                                                                .WEEK)))))))
                            .to(1756857600000L))
                    .type(ProductAnalyticsRetentionListRequestType.RETENTION_LIST_REQUEST));

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

Instructions

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

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

// List the entities behind a retention cell returns "OK" response
use datadog_api_client::datadog;
use datadog_api_client::datadogV2::api_product_analytics::ProductAnalyticsAPI;
use datadog_api_client::datadogV2::model::ProductAnalyticsAudienceAccountSubquery;
use datadog_api_client::datadogV2::model::ProductAnalyticsAudienceFilters;
use datadog_api_client::datadogV2::model::ProductAnalyticsAudienceSegmentSubquery;
use datadog_api_client::datadogV2::model::ProductAnalyticsAudienceUserSubquery;
use datadog_api_client::datadogV2::model::ProductAnalyticsBaseQuery;
use datadog_api_client::datadogV2::model::ProductAnalyticsCalendarInterval;
use datadog_api_client::datadogV2::model::ProductAnalyticsCalendarIntervalType;
use datadog_api_client::datadogV2::model::ProductAnalyticsEventQuery;
use datadog_api_client::datadogV2::model::ProductAnalyticsEventQueryDataSource;
use datadog_api_client::datadogV2::model::ProductAnalyticsEventSearch;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCalendarTimeInterval;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCalendarTimeIntervalType;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCellScope;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCellScopeType;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCohortCriteria;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionCohortTarget;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionEntity;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionFilters;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionIndexTarget;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionIndexTargetType;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionListColumn;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionListColumnField;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionListQuery;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionListRequest;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionListRequestAttributes;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionListRequestData;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionListRequestType;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionReturnCondition;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionReturnCriteria;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionSearch;
use datadog_api_client::datadogV2::model::ProductAnalyticsRetentionTimeInterval;
use uuid::Uuid;

#[tokio::main]
async fn main() {
    let body =
        ProductAnalyticsRetentionListRequest::new(
            ProductAnalyticsRetentionListRequestData::new(
                ProductAnalyticsRetentionListRequestAttributes::new(
                    1756425600000,
                    ProductAnalyticsRetentionListQuery::new(
                        ProductAnalyticsRetentionCellScope::new(
                            ProductAnalyticsRetentionCohortTarget::ProductAnalyticsRetentionIndexTarget(
                                Box::new(
                                    ProductAnalyticsRetentionIndexTarget::new(
                                        ProductAnalyticsRetentionIndexTargetType::INDEX,
                                        0,
                                    ),
                                ),
                            ),
                            ProductAnalyticsRetentionIndexTarget::new(
                                ProductAnalyticsRetentionIndexTargetType::INDEX,
                                0,
                            ),
                            ProductAnalyticsRetentionCellScopeType::CELL,
                        ),
                        ProductAnalyticsRetentionSearch::new(
                            ProductAnalyticsRetentionCohortCriteria::new(
                                ProductAnalyticsBaseQuery::ProductAnalyticsEventQuery(
                                    Box::new(
                                        ProductAnalyticsEventQuery::new(
                                            ProductAnalyticsEventQueryDataSource::PRODUCT_ANALYTICS,
                                            ProductAnalyticsEventSearch::new().query("@type:view".to_string()),
                                        ),
                                    ),
                                ),
                                ProductAnalyticsRetentionTimeInterval::ProductAnalyticsRetentionCalendarTimeInterval(
                                    Box::new(
                                        ProductAnalyticsRetentionCalendarTimeInterval::new(
                                            ProductAnalyticsRetentionCalendarTimeIntervalType::CALENDAR,
                                            ProductAnalyticsCalendarInterval::new(
                                                ProductAnalyticsCalendarIntervalType::WEEK,
                                            )
                                                .alignment("monday".to_string())
                                                .quantity(1)
                                                .timezone("UTC".to_string()),
                                        ),
                                    ),
                                ),
                            ),
                            ProductAnalyticsRetentionEntity::USER_ID,
                            ProductAnalyticsRetentionReturnCondition::CONVERSION_ON_OR_AFTER,
                        )
                            .filters(
                                ProductAnalyticsRetentionFilters
                                ::new().audience_filters(
                                    ProductAnalyticsAudienceFilters::new()
                                        .accounts(vec![ProductAnalyticsAudienceAccountSubquery::new("".to_string())])
                                        .formula("u".to_string())
                                        .segments(
                                            vec![
                                                ProductAnalyticsAudienceSegmentSubquery::new(
                                                    "".to_string(),
                                                    Uuid::parse_str(
                                                        "00000000-0000-0000-0000-000000000000",
                                                    ).expect("invalid UUID"),
                                                )
                                            ],
                                        )
                                        .users(
                                            vec![
                                                ProductAnalyticsAudienceUserSubquery::new(
                                                    "u".to_string(),
                                                ).query("*".to_string())
                                            ],
                                        ),
                                ),
                            )
                            .return_criteria(
                                ProductAnalyticsRetentionReturnCriteria::new(
                                    ProductAnalyticsBaseQuery::ProductAnalyticsEventQuery(
                                        Box::new(
                                            ProductAnalyticsEventQuery::new(
                                                ProductAnalyticsEventQueryDataSource::PRODUCT_ANALYTICS,
                                                ProductAnalyticsEventSearch::new().query("@type:view".to_string()),
                                            ),
                                        ),
                                    ),
                                ).time_interval(
                                    ProductAnalyticsRetentionTimeInterval
                                    ::ProductAnalyticsRetentionCalendarTimeInterval(
                                        Box::new(
                                            ProductAnalyticsRetentionCalendarTimeInterval::new(
                                                ProductAnalyticsRetentionCalendarTimeIntervalType::CALENDAR,
                                                ProductAnalyticsCalendarInterval::new(
                                                    ProductAnalyticsCalendarIntervalType::WEEK,
                                                )
                                                    .alignment("monday".to_string())
                                                    .quantity(1)
                                                    .timezone("UTC".to_string()),
                                            ),
                                        ),
                                    ),
                                ),
                            ),
                    )
                        .columns(
                            vec![
                                ProductAnalyticsRetentionListColumn
                                ::new().field(
                                    ProductAnalyticsRetentionListColumnField::new().path("@usr.email".to_string()),
                                )
                            ],
                        )
                        .limit(100),
                    1756857600000,
                ),
                ProductAnalyticsRetentionListRequestType::RETENTION_LIST_REQUEST,
            ),
        );
    let mut configuration = datadog::Configuration::new();
    configuration.set_unstable_operation_enabled("v2.QueryProductAnalyticsRetentionList", true);
    let api = ProductAnalyticsAPI::with_config(configuration);
    let resp = api.query_product_analytics_retention_list(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

Instructions

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

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

/**
 * List the entities behind a retention cell returns "OK" response
 */

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

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

const params: v2.ProductAnalyticsApiQueryProductAnalyticsRetentionListRequest =
  {
    body: {
      data: {
        attributes: {
          from: 1756425600000,
          query: {
            columns: [
              {
                field: {
                  path: "@usr.email",
                },
              },
            ],
            computationScope: {
              cohortTarget: {
                type: "index",
                value: 0,
              },
              returnPeriodTarget: {
                type: "index",
                value: 0,
              },
              type: "cell",
            },
            limit: 100,
            search: {
              cohortCriteria: {
                baseQuery: {
                  dataSource: "product_analytics",
                  search: {
                    query: "@type:view",
                  },
                },
                timeInterval: {
                  type: "calendar",
                  value: {
                    alignment: "monday",
                    quantity: 1,
                    timezone: "UTC",
                    type: "week",
                  },
                },
              },
              filters: {
                audienceFilters: {
                  accounts: [
                    {
                      name: "",
                    },
                  ],
                  formula: "u",
                  segments: [
                    {
                      name: "",
                      segmentId: "00000000-0000-0000-0000-000000000000",
                    },
                  ],
                  users: [
                    {
                      name: "u",
                      query: "*",
                    },
                  ],
                },
              },
              retentionEntity: "@usr.id",
              returnCondition: "conversion_on_or_after",
              returnCriteria: {
                baseQuery: {
                  dataSource: "product_analytics",
                  search: {
                    query: "@type:view",
                  },
                },
                timeInterval: {
                  type: "calendar",
                  value: {
                    alignment: "monday",
                    quantity: 1,
                    timezone: "UTC",
                    type: "week",
                  },
                },
              },
            },
          },
          to: 1756857600000,
        },
        type: "retention_list_request",
      },
    },
  };

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

Instructions

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

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

리텐션 셀 뒤에 있는 엔티티를 나열하십시오.

개요

요청

Body Data (required)

응답

코드 예시

List the entities behind a retention cell

List the entities behind a retention cell

Instructions

List the entities behind a retention cell

Instructions

List the entities behind a retention cell

Instructions

List the entities behind a retention cell

Instructions

List the entities behind a retention cell

Instructions

List the entities behind a retention cell

Instructions

How can I help you today?