मेट्रिक कॉन्फ़िगरेशन जनरेट करने के अनुरोध का JSON फ़ॉर्मैट

इस गाइड में, Metrics Configuration Generator (MCG) टूल के /api/v1/generate_metrics_config एंडपॉइंट के लिए, JSON अनुरोध फ़ॉर्मैट के बारे में बताया गया है. इस फ़ॉर्मैट की मदद से, टेलीमेट्री कैंपेन को तय किया जा सकता है. जैसे, डेटा कलेक्शन, डिवाइस पर प्रोसेसिंग, और रिपोर्ट जनरेशन. यह सब, ऐसे स्ट्रक्चर में किया जा सकता है जिसे कोई भी व्यक्ति आसानी से पढ़ सकता है.

MCG टूल इस JSON ऑब्जेक्ट की पुष्टि करता है. साथ ही, टाइप के मेल न खाने, सर्कुलर डिपेंडेंसी या अपरिभाषित रेफ़रंस जैसी समस्याओं की जांच करता है. इसके बाद, इसे MetricsConfig प्रोटोकॉल बफ़र (protobuf) मैसेज में कंपाइल करता है. यह MetricsConfig मैसेज, बाइनरी फ़ॉर्मैट में होता है. इसे उपयोगकर्ता के डिवाइस पर मौजूद टेलीमेट्री सेवा, कैंपेन चलाने के लिए इस्तेमाल करती है.

ज़रूरी शर्तें: आपको JSON स्कीमा, प्रोटोबफ़, और बुनियादी डेटा स्ट्रक्चर के बारे में जानकारी होनी चाहिए. कॉन्सेप्ट के बारे में खास जानकारी के लिए, मेट्रिक कॉन्फ़िगरेशन के कॉन्सेप्ट देखें.

कॉन्फ़िगरेशन के ब्यौरे को लिखने का तरीका

मेट्रिक कलेक्शन कैंपेन डिज़ाइन करने के लिए, इस लॉजिकल फ़्लो का पालन करें:

1. डेटा सोर्स तय करना: यह तय करें कि आपका डेटा कहां से आता है.
2. लॉजिक और प्रोसेसिंग तय करना: डेटा इकट्ठा करने और उसे प्रोसेस करने के लिए नियम सेट अप करें.
3. जवाब तैयार करना: प्रोसेस किए गए डेटा को फ़ाइनल मैसेज में पैकेज करना.
4. टॉप-लेवल फ़ील्ड: यूयूआईडी, सिग्नल डेफ़िनिशन, और लाइफ़साइकल कंट्रोल जैसे टॉप-लेवल फ़ील्ड जोड़ें.

डेटा सोर्स तय करना

टेलीमेट्री, SDV सेवाओं (SDV मिडलवेयर के ज़रिए) और कॉन्फ़िगर किए जा सकने वाले पब्लिशर रजिस्ट्री पर आधारित पब्लिशर से डेटा इकट्ठा करने की सुविधा देती है.

• SDV सेवाएं (पब्लिश/सब्सक्राइब पर आधारित): डेटा, VSIDL में तय किए गए pub/sub चैनलों से मिलता है.

• एसडीवी सेवाएं (आरपीसी पर आधारित): अगर सेवा CreateSubscription या GetLatestMessage आरपीसी को दिखाती है, तो डेटा उपलब्ध होता है.

• कॉन्फ़िगर की जा सकने वाली पब्लिशर रजिस्ट्री पर आधारित पब्लिशर: डेटा तब उपलब्ध होता है, जब ऐप्लिकेशन Telemetry SDK से IConfigurablePublisherRegistryAndroid Binder इंटरफ़ेस या कॉन्फ़िगर की जा सकने वाली पब्लिशर रजिस्ट्री लाइब्रेरी का इस्तेमाल करके खुद को रजिस्टर करता है.

एसडीवी में डेटा का इस्तेमाल करने के लिए, डेटा सोर्स (कॉन्सेप्ट) तय करें और उसे data_sources ऐरे में जोड़ें.

सभी तरह के डेटा सोर्स के लिए, सभी विकल्प उपलब्ध नहीं होते. ज़्यादा जानकारी के लिए, डेटा सोर्स इंटिग्रेशन गाइड देखें.

source_identifier का फ़ॉर्मैट

टेलीमेट्री सेवा, सोर्स आइडेंटिफ़ायर के कई फ़ॉर्मैट स्वीकार करती है. खास जानकारी के लिए, मेट्रिक कॉन्फ़िगरेशन में डेटा सोर्स की परिभाषा देखें.

एमसीजी, source_identifier से प्रोटोटाइप मैसेज टाइप का अनुमान सिर्फ़ तब लगाता है, जब वह यूनिट टाइप नेम फ़ॉर्मैट का इस्तेमाल करता है. अगर आपने FQIN या कस्टम नाम (कॉन्फ़िगर किए जा सकने वाले पब्लिशर रजिस्टर से) का इस्तेमाल किया है, तो एमसीजी टाइप का अनुमान नहीं लगा सकता. ऐसे मामलों में, आपको data_source_message_types देना होगा. अगर टाइप आपके कैटलॉग में नहीं है, तो आपको descriptor_protos में उसकी परिभाषा भी देनी होगी.

{
  "name": "SpeedSource",
  "source_identifier": "mcg.test.subpkg.speed_msg",
  "connection_type": "SUBSCRIPTION",
  "sub_sampling_interval_ms": 1000 // Limit updates to 1 per second
}

लॉजिक और प्रोसेसिंग तय करना

लॉजिक को दो कॉम्पोनेंट एक साथ हैंडल करते हैं: ट्रिगर (कॉन्सेप्ट) यह तय करते हैं कि कोई कार्रवाई कब होगी. एग्रीगेटर (कॉन्सेप्ट) यह तय करते हैं कि उन ट्रिगर के आधार पर डेटा को कैसे प्रोसेस किया जाएगा. एक्सप्रेशन (कॉन्सेप्ट) ट्रिगर की शर्तों और एग्रीगेशन लॉजिक के लिए ज़रूरी होते हैं. इसलिए, इस सेक्शन में सबसे पहले यह बताया गया है कि इन्हें कैसे लिखा जाता है.

एक्सप्रेशन

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

एक्सप्रेशन से अंकगणित की कैलकुलेशन, लॉजिकल शर्तें, और डेटा की तुलना की जा सकती है. ऑपरेटर और फ़ंक्शन के साथ-साथ पूरे सिंटैक्स के लिए, एक्सप्रेशन का सिंटैक्स देखें.

डेटा के अपडेट होने की दर: जब कोई एक्सप्रेशन किसी डेटा सोर्स को ऐक्सेस करता है, तो डेटा को फिर से पाने का तरीका कनेक्शन टाइप पर निर्भर करता है:

• SUBSCRIPTION: यह टेलीमेट्री सेवा से कैश किए गए आखिरी बार मिले मैसेज का इस्तेमाल करता है. (ध्यान दें: अगर sub_sampling_interval_ms सेट है, तो यह पब्लिश किए गए सबसे नए मैसेज से अलग हो सकता है.)
• ON_DEMAND: यह विकल्प, सेवा से नया मैसेज तुरंत फ़ेच करने के लिए कॉल ट्रिगर करता है.

टाइप कंस्ट्रेंट

• ऐरे: ऐरे इंडेक्स को सीधे तौर पर ऐक्सेस करने की सुविधा (उदाहरण के लिए, my_data_source.my_array[0]) उपलब्ध नहीं है.
• टाइप सेफ़्टी: पक्का करें कि तुलना के लिए, एक जैसे टाइप के फ़ील्ड इस्तेमाल किए गए हों. उदाहरण के लिए, स्ट्रिंग फ़ील्ड की तुलना पूर्णांकों की सूची से न करें.

ट्रिगर: तय करें कि कार्रवाइयां कब होंगी

ट्रिगर से यह तय होता है कि कार्रवाइयां कब लागू होंगी: एग्रीगेटर का आकलन करना, रिपोर्ट जनरेट करना या कलेक्शन के लाइफ़साइकल को कंट्रोल करना. तय किए गए सभी ट्रिगर को टॉप-लेवल triggers ऐरे में जोड़ें.

डेटा ट्रिगर

यह तब ट्रिगर होता है, जब SUBSCRIPTION डेटा सोर्स कोई नया मैसेज (कॉन्सेप्ट) उपलब्ध कराता है.

{
  "name": "OnNewSpeed",
  "data": {
    "source_name": "SpeedSource" // Reference to the defined data source
  }
}

समय-समय पर ट्रिगर होने वाला

नियमित इंटरवल पर होने वाली घटनाएं (कॉन्सेप्ट).

{
  "name": "EveryMinute",
  "periodic": {
    "period_ms": 60000 // 60,000 ms = 60 seconds
  }
}

शर्त के हिसाब से ट्रिगर करना

यह ट्रिगर, एक्सप्रेशन (कॉन्सेप्ट) के आकलन के आधार पर फ़ायर होता है. इसका आकलन शुरू करने के लिए, एक या उससे ज़्यादा पैरंट ट्रिगर की ज़रूरत होती है. यह अक्सर एक्सप्रेशन में मौजूद डेटा सोर्स या एग्रीगेटर के लिए डेटा ट्रिगर होता है. इसके अलावा, यह डेटा के लिए पोल करने वाला पीरियोडिक ट्रिगर भी हो सकता है.

शर्त के टाइप

condition_type डिक्शनरी में, उपलब्ध शर्तों में से सिर्फ़ एक शर्त को कुंजी के तौर पर शामिल किया जाना चाहिए. ज़्यादा जानकारी के लिए, शर्त के साथ ट्रिगर होने वाले टैग देखें.

किनारे के विकल्प

rising_options और falling_options ऑब्जेक्ट में ये फ़ील्ड होते हैं. अगर ट्रांज़िशन की जानकारी दी गई है, तो ट्रांज़िशन की अवधि से जुड़ी ज़रूरी शर्तें पूरी होनी चाहिए. जिन ट्रांज़िशन के लिए विकल्प तय नहीं किए गए हैं वे तुरंत ट्रिगर हो जाते हैं.

{
  "name": "SpeedingFor5Seconds",
  "conditional": {
    "triggers": ["OnNewSpeed"],
    "expression": "SpeedSource.speed > 27.7",
    "condition_type": {
      "rising_edge": {
        "rising_options": {
          "min_duration_ms": 5000 // Condition must hold for 5s in new state
        }
      }
    }
  }
}

एग्रीगेटर: यह तय करते हैं कि डेटा को कैसे प्रोसेस किया जाए

स्टेटफ़ुल और इंटरमीडिएट डेटा प्रोसेसिंग (कॉन्सेप्ट) के लिए, एग्रीगेटर का इस्तेमाल करें. एग्रीगेटर तय करें और उसे aggregators ऐरे में जोड़ें.

एग्रीगेटर, डेटा को बदलता है और उसे अन्य एग्रीगेटर और रिपोर्ट के लिए उपलब्ध कराता है.

मैसेज बिल्डर

message_builder ऑब्जेक्ट, आउटपुट मैसेज के स्ट्रक्चर और इसके फ़ील्ड की गिनती करने के लिए इस्तेमाल किए गए एग्रीगेशन लॉजिक को तय करता है. इसका इस्तेमाल एग्रीगेटर और रिपोर्ट कॉन्फ़िगरेशन, दोनों में किया जाता है.

{
  "name": "SpeedAggregator",
  "trigger_names": ["OnNewSpeed"], // Update aggregation on new speed data
  "reset_on_get": true, // Reset stats after they are read by the report configuration
  "message_builder": {
    "field_assignments": [
      {
        "field_name": "average_speed",
        "aggregation": {
          "@type": "avg",
          "expression": "SpeedSource.speed"
        }
      },
      {
        "field_name": "speed_reading_count",
        "aggregation": {
          "@type": "count" // Counts triggers (that is, processed speed readings) since last reset
        }
      },
      {
        "field_name": "speed_history_last5",
        "aggregation": {
          "@type": "vector",
          "expression": "SpeedSource.speed",
          "max_length": 5 // Keep last 5 readings
        }
      }
    ]
  }
}

आउटपुट बनाना

अपने टेलीमेट्री कैंपेन का फ़ाइनल आउटपुट तय करने के लिए, report_configs ऐरे (कॉन्सेप्ट) में ऑब्जेक्ट जोड़ें. इन कॉन्फ़िगरेशन से यह तय होता है कि प्रोसेस किए गए डेटा को कैसे पैकेज किया जाता है और इसे कब जनरेट किया जाता है. कॉम्पोनेंट का फिर से इस्तेमाल करने के लिए, एक मेट्रिक कॉन्फ़िगरेशन में कई रिपोर्ट कॉन्फ़िगरेशन तय किए जा सकते हैं.

trigger_names फ़ील्ड का इस्तेमाल करके, रिपोर्ट जनरेट करने की सुविधा को कंट्रोल किया जा सकता है. इसके अलावा, कॉन्फ़िगरेशन चालू होने पर तुरंत रिपोर्ट जनरेट करने के लिए report_initial का इस्तेमाल किया जा सकता है. साथ ही, डेटा कलेक्शन में रुकावट आने पर फ़ाइनल रिपोर्ट जनरेट करने के लिए report_incomplete का इस्तेमाल किया जा सकता है.

ध्यान दें: प्रोसेसिंग को आउटपुट से कनेक्ट करने के लिए, none एग्रीगेशन टाइप @type: "none" का इस्तेमाल करें. इससे एग्रीगेटर से पहले से कैलकुलेट की गई वैल्यू को पढ़ा जा सकता है. रिपोर्ट आम तौर पर स्टेटलेस स्नैपशॉट होती हैं. इसलिए, यह जटिल स्टेटफ़ुल लॉजिक को एग्रीगेटर के अंदर रखता है और रिपोर्ट को फ़ॉर्मैटिंग के लिए रिज़र्व करता है.

{
  "name": "MinuteReport",
  "trigger_names": ["EveryMinute"], // Generate report every minute
  "message_builder": {
    "field_assignments": [
      {
        "field_name": "average_speed",
        "aggregation": {
          "@type": "none", // Read the value directly from the aggregator
          "expression": "SpeedAggregator.average_speed"
        }
      },
      {
        "field_name": "reading_count",
        "aggregation": {
          "@type": "none",
          "expression": "SpeedAggregator.speed_reading_count"
        }
      }
    ]
  }
}

टॉप-लेवल फ़ील्ड

data_sources, aggregators, triggers, और report_configs ऐरे के अलावा, मेट्रिक कॉन्फ़िगरेशन के ब्यौरे में सिग्नल कैटलॉग का रेफ़रंस होना ज़रूरी है. किसी खास यूयूआईडी को असाइन करने और कलेक्शन के लाइफ़साइकल को मैनेज करने के लिए, वैकल्पिक फ़ील्ड भी शामिल किए जा सकते हैं.

यूयूआईडी सेट करें

हर MetricsConfig के लिए, हर जगह स्वीकार किया जाने वाला यूनीक आइडेंटिफ़ायर (यूयूआईडी) ज़रूरी है. अगर आपने existing_uuid दिया है, तो MCG इसका इस्तेमाल करता है. ऐसा न होने पर, यह कोई रैंडम आईडी बना देता है. सभी डिप्लॉयमेंट और टूल के लिए एक जैसा existing_uuid तय करें.

स्ट्रिंग, हाइफ़न वाला मान्य यूयूआईडी होना चाहिए. इसमें सिर्फ़ अंग्रेज़ी के छोटे अक्षर होने चाहिए.

"existing_uuid": "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8",

सिग्नल की परिभाषाएं

सिग्नल के नामों और टाइप की पुष्टि करने के लिए, एमसीजी को वाहन के सिग्नल कैटलॉग का ऐक्सेस चाहिए. यह एक प्रोटोबफ़ FileDescriptorSet है. इसमें आपके VSIDL .proto की परिभाषाएं शामिल हैं. इन्हें पैकेज करके MCG पर अपलोड किया जाता है. कैटलॉग बनाने और अपलोड करने के बारे में जानकारी के लिए, वाहन के सिग्नल कैटलॉग देखें.

JSON ऑब्जेक्ट के vs_version फ़ील्ड में, कैटलॉग का वर्शन तय करें:

"vs_version": "v1.0",

लाइफ़साइकल ट्रिगर तय करना

टेलीमेट्री कैंपेन के संदर्भ में, MetricsConfig की लाइफ़साइकल से यह तय होता है कि डेटा कब रिकॉर्ड किया जाएगा. कैंपेन मैनेजमेंट सिस्टम, डिवाइस पर कॉन्फ़िगरेशन को डिप्लॉय और चालू करता है. हालांकि, लाइफ़साइकल ट्रिगर का इस्तेमाल करके, यह सटीक तौर पर कंट्रोल किया जा सकता है कि डिप्लॉयमेंट के दौरान डेटा कब इकट्ठा किया जाएगा.

इससे, डेटा कलेक्शन को वाहन के इस्तेमाल के पैटर्न के साथ अलाइन किया जा सकता है. जैसे, कॉन्फ़िगरेशन को बंद किए बिना "यात्रा" (IgnitionOn से IgnitionOff) या "चार्जिंग सेशन".

• सेशन कंट्रोल (शुरू/रोकें): डेटा कलेक्शन को कंट्रोल करने के लिए, start_trigger_name और stop_trigger_name का इस्तेमाल करें. उदाहरण के लिए, अगर आपको सिर्फ़ वाहन चलाने के दौरान डेटा इकट्ठा करना है, तो IgnitionOn को स्टार्ट ट्रिगर और IgnitionOff को स्टॉप ट्रिगर के तौर पर इस्तेमाल करें. कॉन्फ़िगरेशन, डिवाइस पर चालू रहता है. हालांकि, स्टॉप ट्रिगर चालू होने पर, यह "पॉज़" हो जाता है. इसका मतलब है कि यह डेटा इकट्ठा करना और उसे प्रोसेस करना बंद कर देता है. यह सिर्फ़ तब फिर से शुरू होता है, जब स्टार्ट ट्रिगर फिर से चालू होता है.

  अहम जानकारी: इससे सिर्फ़ डेटा कलेक्शन रुकता है. इससे लॉजिकल विंडो, अलग-अलग डेटा सेट तय नहीं होते हैं. साथ ही, इसके कोई अन्य साइड इफ़ेक्ट भी नहीं होते. डेटा कलेक्शन रुकने या फिर से शुरू होने पर, एग्रीगेटर वैल्यू रीसेट नहीं होती हैं.

• एक बार पता लगाना (खत्म करें): अगर कॉन्फ़िगरेशन को सिर्फ़ एक बार चलाना है, तो deactivate_trigger_name का इस्तेमाल करें. उदाहरण के लिए, किसी खास गड़बड़ी कोड का पहली बार पता लगाने के लिए. इसके बाद, यह उस डिवाइस पर हमेशा के लिए बंद हो जाएगा. भले ही, कैंपेन तकनीकी तौर पर अब भी चालू हो.

अगर आपने लाइफ़साइकल के किसी भी ट्रिगर के बारे में नहीं बताया है, तो कैंपेन के कॉन्फ़िगरेशन के चालू होते ही डेटा कलेक्शन शुरू हो जाता है. यह तब तक जारी रहता है, जब तक कैंपेन खत्म नहीं हो जाता.

ऐडवांस: कस्टम प्रोटो डेफ़िनिशन

दो मुख्य मामलों में, MCG को मेट्रिक कॉन्फ़िगरेशन के ब्यौरे में मौजूद सभी तरह के मैसेज समझने के लिए, सिर्फ़ vs_version काफ़ी नहीं होता:

1. टाइप का अनुमान नहीं लगाया जा सका: source_identifier फ़ॉर्मैट में बताए गए तरीके के मुताबिक, जब source_identifier में FQIN या कस्टम नाम का इस्तेमाल किया जाता है, तब MCG टाइप का अनुमान नहीं लगा पाता.
2. कस्टम मैसेज: मेट्रिक कॉन्फ़िगरेशन के ब्यौरे में, ऐसे प्रोटोबफ़ मैसेज का इस्तेमाल किया जाता है जो vs_version में दिए गए VSIDL कैटलॉग में नहीं मिलते. ऐसा तब होता है, जब कस्टम रिपोर्ट फ़ॉर्मैट के लिए message_builder में message_type सेट किया जाता है.

ऐसे मामलों में, data_source_message_types का इस्तेमाल करके एमसीजी को टाइप का अनुमान लगाने में मदद करें. साथ ही, descriptor_protos का इस्तेमाल करके मैसेज की परिभाषाएं दें.

data_source_message_types

source_identifier स्ट्रिंग को उसके पूरी तरह से क्वालिफ़ाइड प्रोटोबफ़ मैसेज टाइप पर मैप करें. data_source_message_types में मौजूद कुंजी, data_sources एंट्री में मौजूद source_identifier वैल्यू से मेल खानी चाहिए:

"data_source_message_types": {
  "MyCustomSpeedService": "com.sdv.example.SampleMessage"
}

descriptor_protos

data_source_message_types या message_builder में इस्तेमाल किए गए किसी भी मैसेज टाइप की परिभाषाएं दें. ये परिभाषाएं, कॉन्फ़िगर किए गए vs_version में मौजूद नहीं होनी चाहिए.

descriptor_protos ऐरे में, base64-encoded descriptorpb.FileDescriptorSet पास करें. इसे Protobuf कंपाइलर protoc का इस्तेमाल करके, .proto फ़ाइलों से जनरेट करें.

"descriptor_protos": [
  "Cu8BCiZtY2cvdGVzdGRhdGEvbWF4YXZnY3..." // Base64 string
]

{
  "existing_uuid": "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8", // Unique identifier for the configuration
  "vs_version": "example_version", // Version of the VSIDL catalog to use
  "data_sources": [
    {
      "name": "SpeedSource",
      "source_identifier": "mcg.test.subpkg.speed_msg",
      "connection_type": "SUBSCRIPTION",
      "sub_sampling_interval_ms": 1000
    }
  ],
  "aggregators": [
    {
      "name": "SpeedAggregator",
      "trigger_names": ["OnNewSpeed"],
      "reset_on_get": true,
      "message_builder": {
        "field_assignments": [
          {
            "field_name": "average_speed",
            "aggregation": {
              "@type": "avg",
              "expression": "SpeedSource.speed"
            }
          },
          {
            "field_name": "speed_reading_count",
            "aggregation": { "@type": "count" }
          },
          {
            "field_name": "speed_history_last5",
            "aggregation": {
              "@type": "vector",
              "expression": "SpeedSource.speed",
              "max_length": 5
            }
          }
        ]
      }
    }
  ],
  "triggers": [
    {
      "name": "OnNewSpeed",
      "data": { "source_name": "SpeedSource" }
    },
    {
      "name": "EveryMinute",
      "periodic": { "period_ms": 60000 }
    }
  ],
  "report_configs": [
    {
      "name": "MinuteReport",
      "trigger_names": ["EveryMinute"],
      "message_builder": {
        "field_assignments": [
          {
            "field_name": "average_speed",
            "aggregation": {
              "@type": "none",
              "expression": "SpeedAggregator.average_speed"
            }
          },
          {
            "field_name": "reading_count",
            "aggregation": {
              "@type": "none",
              "expression": "SpeedAggregator.speed_reading_count"
            }
          }
        ]
      }
    }
  ]
}

रेफ़रंस टेंप्लेट

एपीआई की परिभाषा के लिए, MCG API के बारे में जानकारी देखें.

यहां दिए गए सेक्शन में, मेट्रिक कॉन्फ़िगरेशन के ब्यौरे का पूरा रेफ़रंस दिया गया है. इसका इस्तेमाल, मेट्रिक कॉन्फ़िगरेशन के बारे में खुद जानकारी लिखने के लिए एक गाइड के तौर पर करें.

टॉप-लेवल फ़ील्ड

{
  "existing_uuid": "00000000-0000-0000-0000-000000000000", // Optional
  "vs_version": "example_version", // Optional
  "descriptor_protos": ["..."], // Optional. Base64 encoded FileDescriptorSet
  "data_source_message_types": {
    "ExampleServiceName": "com.example.ProtoMessage"
  }, // Optional
  "start_trigger_name": "DataTriggerExample", // Optional
  "stop_trigger_name": "ConditionalTriggerExample", // Optional
  "deactivate_trigger_name": "PeriodicTriggerExample" // Optional
}

इनपुट: डेटा सोर्स और एग्रीगेटर

{
  "data_sources": [
    {
      "name": "SubscriptionExample",
      "source_identifier": "com.example.sdv.ExampleMessage|example-unit",
      "connection_type": "SUBSCRIPTION", // Options: SUBSCRIPTION (default), ON_DEMAND
      "sub_sampling_interval_ms": 100, // Optional
      "fetch_last_message": false // Optional. Default: false
    },
    {
      "name": "RegistryExample",
      // Configurable Publisher Registry-based publisher (matches data_source_message_types)
      "source_identifier": "ExampleServiceName",
      "connection_type": "SUBSCRIPTION"
    },
    {
      "name": "GetterExample",
      "source_identifier": "com.example.sdv.ExampleConfig|example-unit",
      "connection_type": "ON_DEMAND",
      "configuration": {
        "type_url": "type.googleapis.com/example.Config",
        "value_json": {} // Or value_textproto, value (base64)
      }
    }
  ],
  "aggregators": [
    {
      "name": "AggregatorExample",
      "trigger_names": ["DataTriggerExample"],
      "reset_on_get": false, // Optional. Default: false. If true, resets state after it's read
      "message_builder": {
        "message_type": "com.example.AggregatedMessage", // Optional
        "field_assignments": [
          {
            "field_name": "avg_example",
            "aggregation": {
              // Options: avg, count, min, max, sum, stddev, delta, vector, none
              "@type": "avg",
              "expression": "SubscriptionExample.value"
            }
          },
          {
            "field_name": "count_example",
            "aggregation": {
              "@type": "count" // Counts number of evaluations. No expression needed
            }
          },
          {
            "field_name": "vector_example",
            "aggregation": {
              "@type": "vector",
              "expression": "SubscriptionExample.value",
              "max_length": 10 // Optional. If set, creates a ring buffer
            }
          }
        ]
      }
    }
  ]
}

लॉजिक और प्रोसेसिंग: ट्रिगर

{
  "triggers": [
    {
      "name": "PeriodicTriggerExample",
      "periodic": { "period_ms": 1000 }
    },
    {
      "name": "DataTriggerExample",
      "data": { "source_name": "SubscriptionExample" }
    },
    {
      "name": "ConditionalTriggerExample",
      "conditional": {
        "triggers": ["PeriodicTriggerExample"],
        "expression": "SubscriptionExample.value > 0",
        "condition_type": {
          // Options: is_true, is_false, rising_edge, falling_edge, all_changes
          "rising_edge": {
            "rising_options": { "min_duration_ms": 0, "require_exact": false }
          }
        }
      }
    }
  ]
}

आउटपुट: रिपोर्ट कॉन्फ़िगरेशन

{
  "report_configs": [
    {
      "name": "ReportExample",
      "trigger_names": ["PeriodicTriggerExample"],
      "report_incomplete": false, // Optional. Default: false
      "report_initial": false, // Optional. Default: false
      "message_builder": {
        "message_type": "com.example.ReportMessage", // Optional. Must be defined in VSIDL catalog or descriptor_protos. Message type will be inferred if not provided
        "field_assignments": [
          {
            "field_name": "avg_example",
            "aggregation": {
              "@type": "none", // Passthrough since aggregation is done in AggregatorExample
              "expression": "AggregatorExample.avg_example"
            }
          }
        ]
      }
    }
  ]
}

एक्सप्रेशन सिंटैक्स