ch.qos.logback.classic.gaffer.ConfigurationDelegate.groovy Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of logback-groovy-config Show documentation
This library provides the Groovy DSL for configuration Log back and adds some security to the DSL
The newest version!
/**
 * Logback: the reliable, generic, fast and flexible logging framework.
 * Copyright (C) 1999-2015, QOS.ch. All rights reserved.
 *
 * This program and the accompanying materials are dual-licensed under
 * either the terms of the Eclipse Public License v1.0 as published by
 * the Eclipse Foundation
 *
 *   or (per the licensee's choosing)
 *
 * under the terms of the GNU Lesser General Public License version 2.1
 * as published by the Free Software Foundation.
 */
package ch.qos.logback.classic.gaffer

import ch.qos.logback.classic.Level
import ch.qos.logback.classic.Logger
import ch.qos.logback.classic.LoggerContext
import ch.qos.logback.classic.joran.ReconfigureOnChangeTask
import ch.qos.logback.classic.net.ReceiverBase
import ch.qos.logback.classic.turbo.TurboFilter
import ch.qos.logback.core.Appender
import ch.qos.logback.core.CoreConstants
import ch.qos.logback.core.spi.ContextAware
import ch.qos.logback.core.spi.ContextAwareBase
import ch.qos.logback.core.spi.LifeCycle
import ch.qos.logback.core.status.StatusListener
import ch.qos.logback.core.util.CachingDateFormatter
import ch.qos.logback.core.util.Duration

import java.util.concurrent.ScheduledExecutorService
import java.util.concurrent.ScheduledFuture
import java.util.concurrent.TimeUnit
/**
 * @author Ceki Gücü
 */

public class ConfigurationDelegate extends ContextAwareBase {

    List appenderList = [];

    Object getDeclaredOrigin() {
        return this;
    }

    void scan(String scanPeriodStr = null) {
        if (scanPeriodStr) {
            ReconfigureOnChangeTask rocTask = new ReconfigureOnChangeTask();
            rocTask.setContext(context);
            context.putObject(CoreConstants.RECONFIGURE_ON_CHANGE_TASK, rocTask);
            try {
                Duration duration = Duration.valueOf(scanPeriodStr);
                ScheduledExecutorService scheduledExecutorService = context.getScheduledExecutorService();

                ScheduledFuture scheduledFuture = scheduledExecutorService.scheduleAtFixedRate(rocTask, duration.getMilliseconds(), duration.getMilliseconds(), TimeUnit.MILLISECONDS);
                context.addScheduledFuture(scheduledFuture);
                addInfo("Setting ReconfigureOnChangeTask scanning period to " + duration);
            } catch (NumberFormatException nfe) {
                addError("Error while converting [" + scanPeriodStr + "] to long", nfe);
            }
        }
    }

    void statusListener(Class listenerClass) {
        StatusListener statusListener = listenerClass.newInstance()
        context.statusManager.add(statusListener)
        if(statusListener instanceof ContextAware) {
            ((ContextAware) statusListener).setContext(context);
        }
        if(statusListener instanceof LifeCycle) {
            ((LifeCycle) statusListener).start();
        }
        addInfo("Added status listener of type [${listenerClass.canonicalName}]");
    }

    void conversionRule(String conversionWord, Class converterClass) {
        String converterClassName = converterClass.getName();

        Map ruleRegistry = (Map) context.getObject(CoreConstants.PATTERN_RULE_REGISTRY);
        if (ruleRegistry == null) {
            ruleRegistry = new HashMap();
            context.putObject(CoreConstants.PATTERN_RULE_REGISTRY, ruleRegistry);
        }
        // put the new rule into the rule registry
        addInfo("registering conversion word " + conversionWord + " with class [" + converterClassName + "]");
        ruleRegistry.put(conversionWord, converterClassName);
    }

    void root(Level level, List appenderNames = []) {
        if (level == null) {
            addError("Root logger cannot be set to level null");
        } else {
            logger(org.slf4j.Logger.ROOT_LOGGER_NAME, level, appenderNames);
        }
    }

    void logger(String name, Level level, List appenderNames = [], Boolean additivity = null) {
        if (name) {
            Logger logger = ((LoggerContext) context).getLogger(name);
            addInfo("Setting level of logger [${name}] to " + level);
            logger.level = level;

            for (aName in appenderNames) {
                Appender appender = appenderList.find { it -> it.name == aName };
                if (appender != null) {
                    addInfo("Attaching appender named [${aName}] to " + logger);
                    logger.addAppender(appender);
                } else {
                    addError("Failed to find appender named [${aName}]");
                }
            }

            if (additivity != null) {
                logger.additive = additivity;
            }
        } else {
            addInfo("No name attribute for logger");
        }
    }

    void appender(String name, Class clazz, Closure closure = null) {
        addInfo("About to instantiate appender of type [" + clazz.name + "]");
        Appender appender = clazz.newInstance();
        addInfo("Naming appender as [" + name + "]");
        appender.name = name
        appender.context = context
        appenderList.add(appender)
        if (closure != null) {
            AppenderDelegate ad = new AppenderDelegate(appender, appenderList)
            copyContributions(ad, appender)
            ad.context = context;
            closure.delegate = ad;
            closure.resolveStrategy = Closure.DELEGATE_FIRST
            closure();
        }
        try {
            appender.start()
        } catch (RuntimeException e) {
            addError("Failed to start apppender named [" + name + "]", e)
        }
    }

    void receiver(String name, Class aClass, Closure closure = null) {
        addInfo("About to instantiate receiver of type [" + clazz.name + "]");
        ReceiverBase receiver = aClass.newInstance();
        receiver.context = context;
        if(closure != null) {
            ComponentDelegate componentDelegate = new ComponentDelegate(receiver);
            componentDelegate.context = context;
            closure.delegate = componentDelegate;
            closure.resolveStrategy = Closure.DELEGATE_FIRST
            closure();
        }
        try {
            receiver.start()
        } catch (RuntimeException e) {
            addError("Failed to start receiver of type [" + aClass.getName() + "]", e)
        }
    }

    private void copyContributions(AppenderDelegate appenderDelegate, Appender appender) {
        if (appender instanceof ConfigurationContributor) {
            ConfigurationContributor cc = (ConfigurationContributor) appender;
            cc.getMappings().each() { oldName, newName ->
                appenderDelegate.metaClass."${newName}" = appender.&"$oldName"
            }
        }
    }

    void turboFilter(Class clazz, Closure closure = null) {
        addInfo("About to instantiate turboFilter of type [" + clazz.name + "]");
        TurboFilter turboFilter = clazz.newInstance();
        turboFilter.context = context

        if (closure != null) {
            ComponentDelegate componentDelegate = new ComponentDelegate(turboFilter);
            componentDelegate.context = context;
            closure.delegate = componentDelegate;
            closure.resolveStrategy = Closure.DELEGATE_FIRST
            closure();
        }
        turboFilter.start();
        addInfo("Adding aforementioned turbo filter to context");
        context.addTurboFilter(turboFilter)
    }

    String timestamp(String datePattern, long timeReference = -1) {
        long now = -1;

        if (timeReference == -1) {
            addInfo("Using current interpretation time, i.e. now, as time reference.");
            now = System.currentTimeMillis()
        } else {
            now = timeReference
            addInfo("Using " + now + " as time reference.");
        }
        CachingDateFormatter sdf = new CachingDateFormatter(datePattern);
        sdf.format(now)
    }

}