डेटा ऐक्सेस की रिपोर्ट

Admin API v1 runAccessReport तरीके का इस्तेमाल करके, डेटा ऐक्सेस करने की रिपोर्ट बनाई जा सकती हैं. इस रिपोर्ट से पता चलता है कि कोई उपयोगकर्ता, Google Analytics का डेटा कब-कब पढ़ता है. डेटा ऐक्सेस करने के रिकॉर्ड, दो साल तक रखे जाते हैं. डेटा ऐक्सेस करने की रिपोर्ट सिर्फ़ एडमिन की भूमिका वाले उपयोगकर्ताओं के लिए उपलब्ध होती हैं.

क्लाइंट लाइब्रेरी का इस्तेमाल करके, डेटा ऐक्सेस करने की रिपोर्ट का अनुरोध करना

डेटा ऐक्सेस करने की रिपोर्ट का इस्तेमाल शुरू करने का सबसे आसान तरीका है कि क्लाइंट लाइब्रेरी का इस्तेमाल किया जाए.

Google Analytics की क्लाइंट लाइब्रेरी इंस्टॉल और कॉन्फ़िगर करने के तरीके के बारे में जानने के लिए, आसानी से बताने/सिखाने वाली गाइड देखें.

यहां Python क्लाइंट लाइब्रेरी का इस्तेमाल करके एक उदाहरण दिया गया है. इसमें, डेटा ऐक्सेस करने के लिए क्वेरी चलाई जाती है और जवाब प्रिंट किया जाता है.

from datetime import datetime

from google.analytics.admin import AnalyticsAdminServiceClient
from google.analytics.admin_v1alpha.types import (
    AccessDateRange,
    AccessDimension,
    AccessMetric,
    RunAccessReportRequest,
)


def run_sample():
    """Runs the sample."""
    # TODO(developer): Replace this variable with your Google Analytics 4
    #  property ID (e.g. "123456") before running the sample.
    property_id = "YOUR-GA4-PROPERTY-ID"
    run_access_report(property_id)


def run_access_report(property_id: str, transport: str = None):
    """
    Runs an access report for a Google Analytics property. The report will
    aggregate over dimensions `userEmail`, `accessedPropertyId`,
    `reportType`, `revenueDataReturned`, `costDataReturned`,
    `userIP`, and return the access count, as well as the most recent access
    time for each combination.
    See https://developers.google.com/analytics/devguides/config/admin/v1/access-api-schema
    for the description of each field used in a data access report query.
    Args:
        property_id(str): The Google Analytics Property ID.
        transport(str): The transport to use. For example, "grpc"
            or "rest". If set to None, a transport is chosen automatically.
    """
    client = AnalyticsAdminServiceClient(transport=transport)
    request = RunAccessReportRequest(
        entity=f"properties/{property_id}",
        dimensions=[
            AccessDimension(dimension_name="userEmail"),
            AccessDimension(dimension_name="accessedPropertyId"),
            AccessDimension(dimension_name="reportType"),
            AccessDimension(dimension_name="revenueDataReturned"),
            AccessDimension(dimension_name="costDataReturned"),
            AccessDimension(dimension_name="userIP"),
            AccessDimension(dimension_name="mostRecentAccessEpochTimeMicros"),
        ],
        metrics=[AccessMetric(metric_name="accessCount")],
        date_ranges=[AccessDateRange(start_date="yesterday", end_date="today")],
    )

    access_report = client.run_access_report(request)

    print("Result:")
    print_access_report(access_report)


def print_access_report(response):
    """Prints the access report."""
    print(f"{response.row_count} rows received")
    for dimensionHeader in response.dimension_headers:
        print(f"Dimension header name: {dimensionHeader.dimension_name}")
    for metricHeader in response.metric_headers:
        print(f"Metric header name: {metricHeader.metric_name})")

    for rowIdx, row in enumerate(response.rows):
        print(f"\nRow {rowIdx}")
        for i, dimension_value in enumerate(row.dimension_values):
            dimension_name = response.dimension_headers[i].dimension_name
            if dimension_name.endswith("Micros"):
                # Convert microseconds since Unix Epoch to datetime object.
                dimension_value_formatted = datetime.utcfromtimestamp(
                    int(dimension_value.value) / 1000000
                )
            else:
                dimension_value_formatted = dimension_value.value
            print(f"{dimension_name}: {dimension_value_formatted}")

        for i, metric_value in enumerate(row.metric_values):
            metric_name = response.metric_headers[i].metric_name
            print(f"{metric_name}: {metric_value.value}")

properties_run_access_report.py

कोर रिपोर्ट के साथ शेयर की गई सुविधाएं

डेटा ऐक्सेस करने की रिपोर्ट के अनुरोधों का सिमैंटिक, कई सामान्य सुविधाओं के लिए कोर रिपोर्ट अनुरोधों जैसा ही होता है. उदाहरण के लिए पेज पर नंबर डालना, डाइमेंशन फ़िल्टर, और तारीख की सीमाएं एक जैसी होती हैं दोनों तरह की रिपोर्ट में.

Data API v1 में कोर रिपोर्ट की खास जानकारी के बारे में जानें. इसके बाद, डेटा ऐक्सेस करने की रिपोर्ट के बारे में ज़्यादा जानने के लिए, इस पेज पर वापस आएं.

डेटा ऐक्सेस करने की रिपोर्ट का अनुरोध करने के लिए, runAccessReport तरीके का इस्तेमाल करें.

रिपोर्टिंग के लिए कोई इकाई चुनना

Google Analytics Admin API v1 के runAccessReport तरीके के लिए, Google Analytics की प्रॉपर्टी का आइडेंटिफ़ायर, यूआरएल के अनुरोध पाथ में properties/GA_PROPERTY_IDके फ़ॉर्मैट में तय करना ज़रूरी है. यह कोर रिपोर्टिंग की सुविधा की तरह ही है. जैसे:

  POST  https://analyticsadmin.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runAccessReport

डेटा ऐक्सेस करने की रिपोर्ट, तय की गई Google Analytics प्रॉपर्टी के लिए, Google Analytics के डेटा ऐक्सेस करने के रिकॉर्ड के आधार पर जनरेट की जाती है.

अगर Admin API की किसी क्लाइंट लाइब्रेरी का इस्तेमाल किया जा रहा है, तो अनुरोध के यूआरएल पाथ को मैन्युअल तरीके से बदलने की ज़रूरत नहीं है. ज़्यादातर एपीआई क्लाइंट, property पैरामीटर उपलब्ध कराते हैं. इसके लिए, properties/GA_PROPERTY_ID के फ़ॉर्मैट में स्ट्रिंग की ज़रूरत होती है. क्लाइंट लाइब्रेरी के इस्तेमाल का उदाहरण देखने के लिए, इस पेज की शुरुआत में दिया गया कोड स्निपेट देखें.

डाइमेंशन और मेट्रिक चुनना

डाइमेंशन आपकी प्रॉपर्टी के लिए ऐक्सेस डेटा की जानकारी देते हैं और उसे ग्रुप करते हैं. उदाहरण के लिए, userEmail डाइमेंशन से, रिपोर्टिंग डेटा को ऐक्सेस करने वाले उपयोगकर्ता के ईमेल के बारे में पता चलता है. रिपोर्ट के जवाबों में डाइमेंशन की वैल्यू, स्ट्रिंग होती हैं.

मेट्रिक से, रिपोर्ट के मात्रात्मक मेज़रमेंट के बारे में पता चलता है. accessCount मेट्रिक से, डेटा ऐक्सेस करने के रिकॉर्ड की कुल संख्या मिलती है.

डेटा ऐक्सेस करने की रिपोर्ट के अनुरोधों में उपलब्ध डाइमेंशन और मेट्रिक के नामों की पूरी सूची देखने के लिए, डेटा ऐक्सेस करने का स्कीमा देखें.

रिपोर्ट का अनुरोध करना

डेटा ऐक्सेस करने की रिपोर्ट का अनुरोध करने के लिए, RunAccessReportRequest ऑब्जेक्ट बनाएं. हमारा सुझाव है कि अनुरोध के इन पैरामीटर से शुरुआत करें:

• तारीख की सीमाओं वाले फ़ील्ड में, कम से कम एक मान्य एंट्री.
• डाइमेंशन वाले फ़ील्ड में, कम से कम एक मान्य एंट्री.
• अगर epochTimeMicros डाइमेंशन का इस्तेमाल नहीं किया जा रहा है, तो रिपोर्ट में डाइमेंशन की वैल्यू के हर कॉम्बिनेशन के लिए मात्रात्मक डेटा पाने के लिए, मेट्रिक वाले फ़ील्ड में कम से कम एक मान्य एंट्री.

यहां सुझाई गई फ़ील्ड के साथ, अनुरोध का एक उदाहरण दिया गया है. इस क्वेरी से, उपयोगकर्ता के ईमेल की सूची, पिछले सात दिनों में तय की गई प्रॉपर्टी को ऐक्सेस करने का सबसे हाल का समय, और ऐक्सेस की संख्या जनरेट होगी.

POST https://analyticsadmin.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runAccessReport
{
  "dateRanges": [
    {
      "startDate": "7daysAgo",
      "endDate": "today"
    }
  ],
  "dimensions": [
    {
      "dimensionName": "mostRecentAccessEpochTimeMicros"
    },
    {
      "dimensionName": "userEmail"
    }
  ],
  "metrics": [
    {
      "metricName": "accessCount"
    }
  ]
}

जवाब पढ़ना

डेटा ऐक्सेस करने की रिपोर्ट के जवाब में मुख्य तौर पर हेडर और लाइनें होती हैं. हेडर में AccessDimensionHeaders और AccessMetricHeaders शामिल होते हैं. इनमें रिपोर्ट के कॉलम की सूची होती है.

हर ऐक्सेस रिपोर्ट लाइन में, रिपोर्ट के कॉलम के लिए AccessDimensionValues और AccessMetricValues शामिल होती हैं. अनुरोध, हेडर, और हर लाइन में कॉलम का क्रम एक जैसा होता है.

यहां, पहले दिए गए अनुरोध के उदाहरण के लिए, जवाब का एक उदाहरण दिया गया है:

{
  "dimensionHeaders": [
    {
      "dimensionName": "mostRecentAccessEpochTimeMicros"
    },
    {
      "dimensionName": "userEmail"
    }
  ],
  "metricHeaders": [
    {
      "metricName": "accessCount"
    }
  ],
  "rows": [
    {
      "dimensionValues": [
        {
          "value": "1667591408427733"
        },
        {
          "value": "Bola@example.net"
        }
      ],
      "metricValues": [
        {
          "value": "1238"
        }
      ]
    },
    {
      "dimensionValues": [
        {
          "value": "1667710959827161"
        },
        {
          "value": "Alex@example.net"
        }
      ],
      "metricValues": [
        {
          "value": "475"
        }
      ]
    },
    {
      "dimensionValues": [
        {
          "value": "1667868650762743"
        },
        {
          "value": "Mahan@example.net"
        }
      ],
      "metricValues": [
        {
          "value": "96"
        }
      ]
    }
  ],
  "rowCount": 3
}

ऐक्सेस रिकॉर्ड पर फ़िल्टर करना

रिपोर्ट के जवाब को, फ़िल्टर से मैच करने वाली डाइमेंशन की खास वैल्यू तक सीमित करने के लिए, RunAccessReportRequest ऑब्जेक्ट के dimensionFilter फ़ील्ड का इस्तेमाल करें.

यहां दिया गया उदाहरण, डेटा ऐक्सेस करने के अलग-अलग रिकॉर्ड के आधार पर रिपोर्ट जनरेट करता है. इसमें, Alex@example.net ईमेल वाले किसी एक उपयोगकर्ता के ऐक्सेस रिकॉर्ड को फ़िल्टर किया जाता है. रिपोर्ट में, ऐक्सेस के हर रिकॉर्ड का समय, उपयोगकर्ता का ईमेल, और आईपी पता शामिल होता है.

POST https://analyticsadmin.googleapis.com/v1beta/properties/GA_PROPERTY_ID:runAccessReport
{
  "dateRanges": [
    {
      "startDate": "7daysAgo",
      "endDate": "today"
    }
  ],
  "dimensions": [
    {
      "dimensionName": "epochTimeMicros"
    },
    {
      "dimensionName": "userEmail"
    },
    {
      "dimensionName": "userIP"
    }
  ],
  "dimensionFilter": {
    "accessFilter": {
      "fieldName": "userEmail",
      "stringFilter": {
        "matchType": "EXACT",
        "value": "Alex@example.net"
      }
    }
  }
}

इसी तरह, रिपोर्ट के जवाब को, फ़िल्टर से मैच करने वाली मेट्रिक की खास वैल्यू तक सीमित करने के लिए, RunAccessReportRequest ऑब्जेक्ट के metricFilter फ़ील्ड का इस्तेमाल किया जा सकता है.

यहां दिया गया उदाहरण, उन सभी उपयोगकर्ताओं के ईमेल और ऐक्सेस की संख्या वाली रिपोर्ट जनरेट करता है जिन्होंने तय की गई प्रॉपर्टी को 100 से ज़्यादा बार ऐक्सेस किया है.

{
  "dateRanges": [
    {
      "startDate": "7daysAgo",
      "endDate": "today"
    }
  ],
  "dimensions": [
    {
      "dimensionName": "userEmail"
    }
  ],
  "metricFilter": {
    "accessFilter": {
      "numericFilter": {
        "operation": "GREATER_THAN",
        "value": {
          "int64Value": 100
        }
      },
      "fieldName": "accessCount"
    }
  },
  "metrics": [
    {
      "metricName": "accessCount"
    }
  ]
}

रिपोर्ट के उदाहरण

यहां कुछ सैंपल रिपोर्ट दी गई हैं, जिन्हें आज़माया जा सकता है.

सबसे हाल में ऐक्सेस करने का समय

ऐक्सेस की इस सैंपल रिपोर्ट को runAccessReport का इस्तेमाल करके बनाया जा सकता है:

इस रिपोर्ट को, डाइमेंशन mostRecentAccessEpochTimeMicros, userEmail और accessCount मेट्रिक के लिए क्वेरी करके जनरेट किया जा सकता है. रिपोर्ट में, हर उपयोगकर्ता के लिए एक लाइन होती है: mostRecentAccessEpochTimeMicros डाइमेंशन, प्रॉपर्टी को ऐक्सेस करने वाले हर उपयोगकर्ता के लिए, डेटा ऐक्सेस करने के रिकॉर्ड को एग्रीगेट करता है. साथ ही, हर लाइन के लिए, ऐक्सेस करने का सबसे हाल का समय (epoch के बाद से, Unix माइक्रोसेकंड में) दिखाता है.

उपयोगकर्ता के हिसाब से ऐक्सेस का ब्रेकडाउन

काम की एक और रिपोर्ट का उदाहरण, ऐक्सेस करने के तरीके (जैसे, Google Analytics का यूज़र इंटरफ़ेस, एपीआई वगैरह) के हिसाब से, उपयोगकर्ता के ऐक्सेस का ब्रेकडाउन है.

इस रिपोर्ट को, डाइमेंशन mostRecentAccessEpochTimeMicros, userEmail, accessMechanism, और accessCount मेट्रिक के लिए क्वेरी करके जनरेट किया जा सकता है.

रिपोर्ट में, उपयोगकर्ता/ऐक्सेस करने के तरीके के हर कॉम्बिनेशन के लिए एक लाइन होती है. mostRecentAccessEpochTimeMicros डाइमेंशन में, वह समय शामिल होता है जब किसी उपयोगकर्ता ने तय किए गए ऐक्सेस करने के तरीके का इस्तेमाल करके, प्रॉपर्टी को ऐक्सेस किया था.

प्रॉपर्टी के ऐक्सेस की खास जानकारी

किसी प्रॉपर्टी के लिए, अलग-अलग उपयोगकर्ताओं के हिसाब से ब्रेकडाउन किए बिना रिपोर्ट जनरेट की जा सकती है. उदाहरण के लिए, यहां दी गई रिपोर्ट से पता चलता है कि अलग-अलग ऐक्सेस करने के तरीकों का इस्तेमाल करके, किसी प्रॉपर्टी को कितनी बार ऐक्सेस किया जाता है:

इस रिपोर्ट को, डाइमेंशन accessedPropertyId, accessedPropertyName, accessMechanism, और accessCount मेट्रिक के लिए क्वेरी करके जनरेट किया जा सकता है.

रिपोर्ट में, प्रॉपर्टी आईडी/ऐक्सेस करने के तरीके के हर कॉम्बिनेशन के लिए एक लाइन होती है.

डेटा ऐक्सेस करने की अलग-अलग जानकारी

ऐसी रिपोर्ट जनरेट करने के लिए जिसमें हर लाइन, डेटा ऐक्सेस करने के अलग-अलग रिकॉर्ड पर आधारित हो, क्वेरी से mostRecentAccessEpochTimeMicros डाइमेंशन हटाएं और इसके बजाय epochTimeMicros डाइमेंशन का इस्तेमाल करें. accessCount मेट्रिक के लिए क्वेरी करना ज़रूरी नहीं है, क्योंकि रिपोर्ट की हर लाइन में, डेटा ऐक्सेस करने की किसी एक घटना के बारे में जानकारी होती है.

यहां दी गई रिपोर्ट में, तय की गई प्रॉपर्टी को ऐक्सेस करने के हर समय के बारे में पूरी जानकारी होती है.

इस रिपोर्ट को, डाइमेंशन epochTimeMicros, userEmail, accessedPropertyId, accessedPropertyName, userIP, accessMechanism, costDataReturned, revenueDataReturned के लिए क्वेरी करके जनरेट किया जा सकता है.