public void log()

in entity-store/src/main/java/jetbrains/exodus/entitystore/Explainer.java [153:229]
72 lines of code
18 McCabe index (conditional complexity)

    public void log(Object origin) {
        if (origin == null) {
            return;
        }
        Map<String, Object> query = queries.get(origin);
        if (query == null || query.get(ITERABLE_ADVANCES) == null) {
            return;
        }
        Object cursorAdvances = query.get(CURSOR_ADVANCES);
        Object cursorAdvancesForFirst = query.get(CURSOR_ADVANCES_FOR_FIRST);
        if (cursorAdvances != null && cursorAdvancesForFirst != null) {
            // not ITERABLE_ADVANCES - 1 because of some advances for the last unsuccessful hasNext
            query.put(AVERAGE_CURSOR_ADVANCES,
                    ((Integer) cursorAdvances - (Integer) cursorAdvancesForFirst) * 1.0 / (Integer) query.get(ITERABLE_ADVANCES));
        }

        List<Pair<Integer, String>> byType = new ArrayList<>();
        List<Pair<Integer, String>> byHandle = new ArrayList<>();
        Collection<String> toRemove = new HashSet<>();
        for (String parameter : query.keySet()) {
            if (parameter.startsWith(_CURSOR_ADVANCES_BY_TYPE)) {
                toRemove.add(parameter);
                byType.add(new Pair<>((Integer) query.get(parameter),
                        EntityIterableType.valueOf(parameter.substring(_CURSOR_ADVANCES_BY_TYPE.length() + 1)).toString()));
            }
            if (parameter.startsWith(_CURSOR_ADVANCES_BY_HANDLE)) {
                toRemove.add(parameter);
                byHandle.add(new Pair<>((Integer) query.get(parameter),
                        parameter.substring(_CURSOR_ADVANCES_BY_HANDLE.length() + 1)));
            }
        }
        for (String parameter : toRemove) {
            query.remove(parameter);
        }
        Comparator<Pair<Integer, String>> pairComparator = (p1, p2) -> p2.getFirst().compareTo(p1.getFirst());
        Collections.sort(byType, pairComparator);
        Collections.sort(byHandle, pairComparator);
        StringBuilder advancesByType = new StringBuilder();
        for (Pair<Integer, String> pair : byType) {
            advancesByType.append('\n').append(pair.getSecond()).append(": ").append(pair.getFirst());
        }
        StringBuilder advancesByHandle = new StringBuilder();
        for (Pair<Integer, String> pair : byHandle) {
            advancesByHandle.append('\n').append(pair.getFirst()).append(": ").append(pair.getSecond());
        }
        query.put(CURSOR_ADVANCES_BY_TYPE, advancesByType.toString());
        query.put(CURSOR_ADVANCES_BY_HANDLE, advancesByHandle.toString());

        boolean show = false;
        for (String parameter : PERFORMANCE_PARAMETERS) {
            if (query.get(parameter) == null) {
                continue;
            }
            double value = ((Number) query.get(parameter)).doubleValue();
            Double worst = WORST_VALUES.get(parameter);
            if (worst <= value * 2) {
                show = true;
                WORST_VALUES.put(parameter, Math.max(value, worst));
            }
        }

        if (show) {
            final StringBuilder stringWriter = new StringBuilder();
            stringWriter.append("Explain\n");
            for (Map.Entry<String, Object> entry : query.entrySet()) {
                stringWriter.append(entry.getKey());
                stringWriter.append(": ");
                stringWriter.append(entry.getValue().toString());
                stringWriter.append('\n');
            }
            logger.info(stringWriter.toString());
        }

        if (!isExplainForcedForThread()) {
            clean(origin);
        }
    }