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

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 तरीके का इस्तेमाल करें.

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

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

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

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

अगर एडमिन एपीआई क्लाइंट लाइब्रेरी में से किसी एक का इस्तेमाल किया जा रहा है, तो अनुरोध यूआरएल पाथ को मैन्युअल तरीके से बदलने की ज़रूरत नहीं है. ज़्यादातर एपीआई क्लाइंट, 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 डाइमेंशन, प्रॉपर्टी को ऐक्सेस करने वाले हर उपयोगकर्ता के लिए डेटा ऐक्सेस रिकॉर्ड इकट्ठा करता है और हर लाइन के लिए, पिछली बार ऐक्सेस करने का समय (यूनिक्स माइक्रोसेकंड में, इकट्ठा होने के समय से) दिखाता है.

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

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

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

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

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

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

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

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

व्यक्तिगत डेटा का ऐक्सेस

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

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

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