The Kafka Consumer origin
      processes data differently based on the data format. Kafka Consumer can process the following
      types of data:
  
      
                              - Avro
- Generates a record for every message. Includes a
                                          precisionandscalefield attribute for each Decimal field.
- The origin includes the Avro schema in an
                                          avroSchemarecord header attribute. You can use one of the
                                    following methods to specify the location of the Avro schema
                                          definition:
- Using a schema in the stage configuration or retrieving a schema
                                    from Confluent Schema Registry overrides any schema that might
                                    be included in the message and can improve performance.
- Binary
- Generates a record with a single byte
                                          array field at the root of the record.
                              
- When the data exceeds the user-defined
                                          maximum data size, the origin cannot process the data.
                                          Because the record is not created, the origin cannot pass
                                          the record to the pipeline to be written as an error
                                          record. Instead, the origin generates a stage error.
                              
- Datagram
- Generates a record for every
                                          message. The origin can process collectd messages, NetFlow 5 and NetFlow 9 messages, and the
                        following types of syslog messages:
                                    
                        - RFC 5424
- RFC 3164
- Non-standard common messages, such as RFC 3339 dates with no version
                              digit
 
- When processing NetFlow messages, the stage generates
                        different records based on the NetFlow version. When processing NetFlow 9,
                        the records are generated based on the NetFlow 9 configuration properties.
                        For more information, see NetFlow Data Processing.
- Delimited
- Generates a record for each delimited line. 
- The CSV parser that you choose
                                          determines the delimiter properties that you configure and
                                          how the stage handles parsing errors. You can specify if
                                          the data includes a header line and whether to use it. You
                                          can define the number of lines to skip before reading, the
                                          character set of the data, and the root field type to use
                                          for the generated record.
- You can also configure the stage
                                          to replace a string constant with null values and to
                                          ignore control characters.
- For more information about reading
                                          delimited data, see Reading Delimited Data.
- JSON
- Generates a record for each JSON object. You can process JSON
                                    files that include multiple JSON objects or a single JSON
                                    array.
- When an object exceeds the maximum object length defined for the
                                    origin, the origin processes the object based on the error
                                    handling configured for the stage. 
- Log
- Generates a record for every log line. 
- When a line exceeds the user-defined maximum line length, the
                                    origin truncates longer lines. 
- You can include the processed log line as a field in the record.
                                    If the log line is truncated, and you request the log line in
                                    the record, the origin includes the truncated line.
- You can define the log format or type to be read.
- Protobuf
- Generates a record for every protobuf message. By default, the
                                    origin assumes messages contain multiple protobuf messages.
- Protobuf messages must match the specified message type and be
                                    described in the descriptor file. 
- When the data for a record exceeds 1 MB, the origin cannot
                                    continue processing data in the message. The origin handles the
                                    message based on the stage error handling property and continues
                                    reading the next message. 
- For information about generating the descriptor file, see Protobuf Data Format Prerequisites.
- SDC Record
- Generates a record for every record. Use to process records
                                    generated by a Data Collector
                                    pipeline using the SDC Record data format.
- For error records, the origin provides the original record as read
                                    from the origin in the original pipeline, as well as error
                                    information that you can use to correct the record. 
- When processing error records, the origin expects the error file
                                    names and contents as generated by the original pipeline.
- Text
- Generates a record for each line of text or for each section of
                                    text based on a custom delimiter.
- When a line or section exceeds the maximum line length defined for
                                    the origin, the origin truncates it. The origin adds a boolean
                                    field named Truncated to indicate if the line was
                                    truncated.
- For more information about processing text with a custom
                                    delimiter, see Text Data Format with Custom Delimiters.
- XML
- Generates records based on a user-defined delimiter element. Use
                                    an XML element directly under the root element or define a
                                    simplified XPath expression. If you do not define a delimiter
                                    element, the origin treats the XML file as a single record.
- Generated records include XML attributes and namespace
                                    declarations as fields in the record by default. You can
                                    configure the stage to include them in the record as field
                                    attributes. 
- You can include XPath information for each parsed XML element and
                                    XML attribute in field attributes. This also places each
                                    namespace in an xmlns record header attribute. Note: Field attributes and record header attributes are
                        written to destination systems automatically only when you use the SDC RPC
                        data format in destinations. For more information about working with field
                        attributes and record header attributes, and how to include them in records,
                        see Field Attributes and Record Header Attributes. 
- When a record exceeds the user-defined maximum record length, the
                                    origin skips the record and continues processing with the next
                                    record. It sends the skipped record to the pipeline for error
                                    handling. 
- Use the XML data format to process valid XML documents. For more
                                    information about XML processing, see Reading and Processing XML Data.
-