001package org.javasimon.callback.logging;
002
003import org.javasimon.clock.SimonClock;
004import org.javasimon.Split;
005
006import java.util.logging.Level;
007
008/**
009 * Factory for various implementations of {@link LogTemplate}s.
010 *
011 * @author gquintana
012 */
013public class LogTemplates {
014
015        /** Produces a disabled log template which never logs anything. */
016        public static <C> LogTemplate<C> disabled() {
017                return DisabledLogTemplate.getInstance();
018        }
019
020        /**
021         * Produces a log template which logs something every N split.
022         *
023         * @param delegateLogger Concrete log template
024         * @param period N value, period
025         * @return Logger
026         */
027        public static <C> LogTemplate<C> everyNSplits(LogTemplate<C> delegateLogger, int period) {
028                return new CounterLogTemplate<>(delegateLogger, period);
029        }
030
031        /**
032         * Produces a log template which logs something at most every N milliseconds.
033         *
034         * @param delegateLogger Concrete log template
035         * @param period N value in milliseconds, maximum period
036         * @return Logger
037         */
038        public static <C> LogTemplate<C> everyNMilliseconds(LogTemplate<C> delegateLogger, long period) {
039                return new PeriodicLogTemplate<>(delegateLogger, period);
040        }
041
042        /**
043         * Produces a log template which logs something at most every N milliseconds.
044         *
045         * @param delegateLogger Concrete log template
046         * @param period N value in milliseconds, maximum period
047         * @param clock clock to get current system time
048         * @return Logger
049         */
050        static <C> LogTemplate<C> everyNMilliseconds(LogTemplate<C> delegateLogger, long period, SimonClock clock) {
051                return new PeriodicLogTemplate<>(delegateLogger, period, clock);
052        }
053
054        /**
055         * Produces a log template which logs something at most every N secoonds.
056         *
057         * @param delegateLogger Concrete log template
058         * @param period N value in seconds, maximum period
059         * @return Logger
060         */
061        public static <C> LogTemplate<C> everyNSeconds(LogTemplate<C> delegateLogger, long period) {
062                return everyNMilliseconds(delegateLogger, period * SimonClock.MILLIS_IN_SECOND);
063        }
064
065        /**
066         * Produces a concrete log template which logs messages into a SLF4J Logger.
067         *
068         * @param loggerName Logger name
069         * @param levelName Level name (info, debug, warn, etc.)
070         * @param markerName Marker name
071         * @return Logger
072         */
073        public static <C> SLF4JLogTemplate<C> toSLF4J(String loggerName, String levelName, String markerName) {
074                if ("debug".equalsIgnoreCase(levelName)) {
075                        return new SLF4JLogTemplate.Debug<>(loggerName, markerName);
076                } else if ("info".equalsIgnoreCase(levelName)) {
077                        return new SLF4JLogTemplate.Info<>(loggerName, markerName);
078                } else if ("warn".equalsIgnoreCase(levelName)) {
079                        return new SLF4JLogTemplate.Warn<>(loggerName, markerName);
080                } else {
081                        throw new IllegalArgumentException("Invalid level name " + levelName);
082                }
083        }
084
085        /**
086         * Produces a concrete log template which logs messages into a SLF4J Logger.
087         *
088         * @param loggerName Logger name
089         * @param levelName Level name (info, debug, warn, etc.)
090         * @return Logger
091         */
092        public static <C> SLF4JLogTemplate<C> toSLF4J(String loggerName, String levelName) {
093                return toSLF4J(loggerName, levelName, null);
094        }
095
096        /**
097         * Produces a concrete log template which logs messages into a Java Util Logging Logger.
098         *
099         * @param loggerName Logger name
100         * @param level Level (warn, fine, finer, etc.)
101         * @return Logger
102         */
103        public static <C> JULLogTemplate<C> toJUL(String loggerName, Level level) {
104                return new JULLogTemplate<>(loggerName, level);
105        }
106
107        /**
108         * Produces a log template which logs something when stopwatch split is longer than threshold.
109         *
110         * @param delegateLogger Concrete log template
111         * @param threshold Threshold (in nanoseconds), above which logging is enabled
112         * @return Logger
113         */
114        public static SplitThresholdLogTemplate whenSplitLongerThanNanoseconds(LogTemplate<Split> delegateLogger, long threshold) {
115                return new SplitThresholdLogTemplate(delegateLogger, threshold);
116        }
117
118        /**
119         * Produces a log template which logs something when stopwatch split is longer than threshold.
120         *
121         * @param delegateLogger Concrete log template
122         * @param threshold Threshold (in milliseconds), above which logging is enabled
123         * @return Logger
124         */
125        public static SplitThresholdLogTemplate whenSplitLongerThanMilliseconds(LogTemplate<Split> delegateLogger, long threshold) {
126                return whenSplitLongerThanNanoseconds(delegateLogger, threshold * SimonClock.NANOS_IN_MILLIS);
127        }
128}