func (this *KafkaAvroDecoder) Decode(bytes []byte) (interface{}, error) {
	if bytes == nil {
		return nil, nil
	} else {
		if bytes[0] != 0 {
			return nil, errors.New("Unknown magic byte!")
		}
		id := int32(binary.BigEndian.Uint32(bytes[1:]))
		schema, err := this.schemaRegistry.GetByID(id)
		if err != nil {
			return nil, err
		}

		if schema.Type() == avro.Bytes {
			return bytes[5:], nil
		} else {
			reader := avro.NewGenericDatumReader()
			reader.SetSchema(schema)
			value := avro.NewGenericRecord(schema)
			err := reader.Read(value, avro.NewBinaryDecoder(bytes[5:]))

			return value, err
		}
	}
}
func (this *MirrorMaker) AddTiming(record *avro.GenericRecord, tag string, now int64) *avro.GenericRecord {
	if !this.evolutioned.exists(record.Schema().String()) {
		currentSchema := record.Schema().(*avro.RecordSchema)
		newSchema := *record.Schema().(*avro.RecordSchema)
		for _, newField := range this.logLineSchema.Fields {
			var exists bool
			for _, currentField := range currentSchema.Fields {
				if currentField.Name == newField.Name {
					if reflect.DeepEqual(currentField, newField) {
						exists = true
						break
					}
					panic(fmt.Sprintf("Incompatible field %s in schema %s", currentField.Name, currentSchema.String()))
				}
			}
			if !exists {
				newSchema.Fields = append(newSchema.Fields, newField)
			}
		}
		newRecord := avro.NewGenericRecord(&newSchema)
		for _, field := range currentSchema.Fields {
			newRecord.Set(field.Name, record.Get(field.Name))
		}
		record = newRecord
		this.evolutioned.add(record.Schema().String())
	}

	var timings map[string]interface{}
	if record.Get("timings") == nil {
		timings = make(map[string]interface{})
	} else {
		timings = record.Get("timings").(map[string]interface{})
	}

	timings[tag] = now
	record.Set("timings", timings)

	return record
}