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

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 तरीके के लिए, Google Analytics प्रॉपर्टी आइडेंटिफ़ायर को properties/GA_PROPERTY_ID के तौर पर यूआरएल अनुरोध पाथ में शामिल करना ज़रूरी है. जैसे:

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

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

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

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

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

मेट्रिक रिपोर्ट के मात्रात्मक माप का प्रतिनिधित्व करते हैं. accessCount मेट्रिक, डेटा ऐक्सेस करने के रिकॉर्ड की कुल संख्या दिखाती है.

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

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

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

• date ranges फ़ील्ड में कम से कम एक मान्य एंट्री.
• dimensions फ़ील्ड में कम से कम एक मान्य एंट्री.
• epochTimeMicros डाइमेंशन का इस्तेमाल न करने पर, रिपोर्ट में डाइमेंशन वैल्यू के हर कॉम्बिनेशन के लिए संख्यात्मक डेटा पाने के लिए, metrics फ़ील्ड में कम से कम एक मान्य एंट्री होनी चाहिए.

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

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 के बाद से यूनिक्स माइक्रोसेकंड में) दिखाता है.

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

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

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

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

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

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

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

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

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

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

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

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