{
"Policy": "<name-of-policy>",
"Version": "<policy-version>",
"Identifier": "<data from policy file>"
"CollectionID": <id>,
"Path": <Policy Path>,  
"CollectionStartTime": <timestamp>,
"Data": { … object as above … },
"CollectionEndTime": <timestamp>,
}

• Policy, Version and Identifier are specified in the policy file.

• CollectionID is an integer that allows messages to be grouped together if data for a single path is split over multiple messages.

• Path is the base path of the corresponding data as specified in the policy file.

• CollectionStartTime and CollectionEndTime are the timestamps that indicate when the data was collected

• containers: a container has nodes that can be of different types.

• tables: a table also contains nodes, but the number of child nodes may vary, and they must be of the same type.

• leaf node: a leaf contains a data value, such as integer or string.

• Each container maps to a JSON object. The keys are strings that represent the schema names of the nodes; the values represent the values of the nodes.

• JSON objects are also used to represent tables. In this case, the keys are based on naming information that is converted to string format. Two options are provided for encoding the naming information:

  • The default is restconf-style encoding, where naming parameters are contained within the child node to which it refers.

  • The embedded-keys option uses the naming information as keys in a JSON dictionary, with the corresponding child node forming the value.

• Leaf data types are mapped in this manner:

  • Simple strings, integers, and booleans are mapped directly.

  • Enumeration values are stored as the string representation of the value.

  • Other simple data types, such as IP addresses, are mapped as strings.

Interfaces(*).Counters.Protocols(“IPv4”) 

{
  "Interfaces": [
    {
      "Name": "GigabitEthernet0/0/0/1"
      "Counters": {
        "Protocols": [
          {
            "ProtoName": "IPv4",
            "CollectionTime": 12345678,
            "InputPkts": 100,
            "InputBytes": 200,
          }
        ]
      }
    },{
      "Name": "GigabitEthernet0/0/0/2"
      "Counters": {
        "Protocols": [
          {
            "ProtoName": "IPv4",
            "CollectionTime": 12345678,
            "InputPkts": 400,
            "InputBytes": 500,
          }
        ]
      }
    }
  ]
}             

{
  "Interfaces": {
      "GigabitEthernet0/0/0/1": {
        "Counters": {
          "Protocols": {
            "IPv4": {
              "CollectionTime": 12345678,
              "InputPkts": 100,
              "InputBytes": 200,
            }
          }
        }
      },
      "GigabitEthernet0/0/0/2": {
        "Counters": {
          "Protocols": {
            "IPv4": {
              "CollectionTime": 12345678,
              "InputPkts": 400,
              "InputBytes": 500,
            }
          }
        }
      }
    }
  }
}

{
  "Foo": 
    {
    "Destination": {
        1.1.1.1: {
          2000: {
            Leaf1": 100,
          }
        }    
      }
    ]
  }
}  

• Compact GPB format stores data in a compressed and non-self-describing format. A .proto file must be generated for each path in the policy file to be used by the receiver to decode the resulting data.

• Key-value GPB format uses a single .proto file to encode data in a self-describing format. This encoding does not require a .proto file for each path. The data on the wire is much larger because key names are included.

telemetry policy-driven encoder gpb
  policy group alpha
    policy foo
    destination ipv4 192.168.1.1 port 1234
    destination ipv4 10.0.0.1 port 9876
  policy group beta
    policy bar
    policy whizz
    destination ipv4 10.20.30.40 port 3333
    transport tcp
      compression zlib
  policy group gamma
    policy bang
    destination ipv4 11.1.1.1 port 4444
    transport tcp 
      encoding-format gpb-compact

message TelemetryHeader {
  optional uint32 encoding = 1

  optional string policy_name = 2;
  optional string version = 3;
  optional string identifier = 4;

  optional uint64 start_time = 5;
  optional uint64 end_time = 6;
  
  repeated TelemetryTable tables = 7;
		}

message TelemetryTable {
  optional string policy_path = 1;
  repeated bytes  row = 2;
		}

• encoding is used by receivers to verify that the packet is valid.

• policy name, version and identifier are metadata taken from the policy file.

• start time and end time indicate the duration when the data is collected.

• tables is a list of tables within the packet. This format indicates that it is possible to receive results for multiple schema paths in a single packet.

• For each table:

  • policy path is the schema path.

  • row is one or more byte arrays that represents an encoded GPB.

message Telemetry {
  uint64   collection_id = 1;
  string   base_path = 2;	
  string   subscription_identifier = 3;
  string   model_version = 4;
  uint64   collection_start_time = 5;
  uint64   msg_timestamp = 6;
  repeated TelemetryField fields = 14;
  uint64   collection_end_time = 15;
}

message TelemetryField {
  uint64         timestamp = 1;
  string         name = 2;
  bool           augment_data = 3;
  oneof value_by_type {
    bytes          bytes_value = 4;
    string         string_value = 5;
    bool           bool_value = 6;
    uint32         uint32_value = 7;
    uint64         uint64_value = 8;
    sint32         sint32_value = 9;
    sint64         sint64_value = 10;  
    double         double_value = 11;
    float          float_value = 12;
  }
  repeated TelemetryField fields = 15;
}

• collection_id, base_path, collection_start_time and collection_end_time provide streaming details.

• subscription_identifier is a fixed value for cadence-driven telemetry. This is used to distinguish from event-driven data.

• model_version contains a string used for the version of the data model, as applicable.