io.wizzie.normalizer.funcs.impl.FormatterFlatMapper Maven / Gradle / Ivy

Go to download
package io.wizzie.normalizer.funcs.impl;

import io.wizzie.metrics.MetricsManager;
import io.wizzie.normalizer.funcs.FilterFunc;
import io.wizzie.normalizer.funcs.FlatMapperFunction;
import org.apache.kafka.streams.KeyValue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class FormatterFlatMapper extends FlatMapperFunction {
    private static final Logger log = LoggerFactory.getLogger(FormatterFlatMapper.class);

    private enum Type {CONSTANT, FIELDVALUE}

    List commonFields;
    Map filters = new HashMap<>();
    List> generators;
    Boolean passIfNotApply = false;

    @Override
    public void prepare(Map properties, MetricsManager metricsManager) {
        commonFields = (List) properties.getOrDefault("commonFields", new ArrayList<>());
        List> filterMaps = (List>) properties.getOrDefault("filters", new ArrayList<>());
        passIfNotApply = (Boolean) properties.getOrDefault("passIfNotApply", false);

        for (Map filterDefinition : filterMaps) {
            String filterName = (String) filterDefinition.get("name");
            String className = (String) filterDefinition.get("className");

            try {
                Class funcClass = Class.forName(className);
                FilterFunc func = (FilterFunc) funcClass.newInstance();
                func.init((Map) filterDefinition.get("properties"), metricsManager);
                filters.put(filterName, func);
            } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }

        generators = (List>) properties.getOrDefault("generators", new ArrayList<>());
    }


    @Override
    public Iterable>> process(String key, Map value) {
        List>> toSend = new ArrayList<>();

        if (value != null) {
            Map base = new HashMap<>();
            commonFields.forEach(field -> {
                if (value.containsKey(field)) base.put(field, value.get(field));
            });

            Boolean someApply = false;

            for (Map generator : generators) {
                String filter = (String) generator.get("filter");

                if (filters.containsKey(filter) && filters.get(filter).test(key, value)) {
                    List> definitions = (List>) generator.get("definitions");
                    someApply = true;

                    for (Map definition : definitions) {
                        List> fields = (List>) definition.get("apply");
                        Map message = new HashMap<>();
                        message.putAll(base);

                        boolean isNullValue = false;

                        for (Map field : fields) {
                            String fieldName = (String) field.get("field");
                            Object contentValue = null;
                            Map content = (Map) field.get("content");
                            Type type = Type.valueOf(content.get("type").toString().toUpperCase());

                            switch (type) {
                                case CONSTANT:
                                    contentValue = content.get("value");
                                    break;
                                case FIELDVALUE:
                                    contentValue = value.get(content.get("value"));
                                    break;
                            }

                            if (contentValue == null) {
                                log.warn("Detected null value for field [{}]", content.get("value"));
                                isNullValue = true;
                                break;
                            }

                            message.put(fieldName, contentValue);
                        }

                        if (!isNullValue)
                            toSend.add(new KeyValue<>(key, message));
                    }
                }
            }

            if (passIfNotApply && !someApply) {
                toSend.add(new KeyValue<>(key, value));
            }
        }

        return toSend;
    }

    @Override
    public void stop() {
    }
}