[lttng-ust.git] /

/*
 * Copyright (C) 2015 - EfficiOS Inc., Alexandre Montplaisir <alexmonthy@efficios.com>
 *
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License, version 2.1 only,
 * as published by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

package org.lttng.ust.agent.session;

/**
 * Log level filtering element, which is part of an {@link EventRule}.
 *
 * @author Alexandre Montplaisir
 */
public class LogLevelSelector {

        /**
         * The type of log level filter that is enabled.
         *
         * Defined from lttng-tools' include/lttng/event.h.
         */
        public enum LogLevelType {
                /**
                 * All log levels are enabled. This overrides the value of
                 * {@link LogLevelSelector#getLogLevel}.
                 */
                LTTNG_EVENT_LOGLEVEL_ALL(0),

                /** This log level along with all log levels of higher severity are enabled. */
                LTTNG_EVENT_LOGLEVEL_RANGE(1),

                /** Only this exact log level is enabled. */
                LTTNG_EVENT_LOGLEVEL_SINGLE(2);

                private final int value;

                private LogLevelType(int value) {
                        this.value = value;
                }

                /**
                 * Get the numerical (int) value representing this log level type in the
                 * communication protocol.
                 *
                 * @return The int value
                 */
                public int getValue() {
                        return value;
                }

                static LogLevelType fromValue(int val) {
                        switch (val) {
                        case 0:
                                return LTTNG_EVENT_LOGLEVEL_ALL;
                        case 1:
                                return LTTNG_EVENT_LOGLEVEL_RANGE;
                        case 2:
                                return LTTNG_EVENT_LOGLEVEL_SINGLE;
                        default:
                                throw new IllegalArgumentException();
                        }
                }
        }

        private final int logLevel;
        private final LogLevelType logLevelType;

        /**
         * Constructor using numerical values straight from the communication
         * protocol.
         *
         * @param logLevel
         *            The numerical value of the log level. The exact value depends
         *            on the tracing domain, see include/lttng/event.h in the
         *            lttng-tools tree for the complete enumeration.
         * @param logLevelType
         *            The numerical value of the log level type. It will be
         *            converted to a {@link LogLevelType} by this constructor.
         * @throws IllegalArgumentException
         *             If the 'logLevelType' does not correspond to a valid value.
         */
        public LogLevelSelector(int logLevel, int logLevelType) {
                this.logLevel = logLevel;
                this.logLevelType = LogLevelType.fromValue(logLevelType);
        }

        /**
         * "Manual" constructor, specifying the {@link LogLevelType} directly.
         *
         * @param logLevel
         *            The numerical value of the log level. The exact value depends
         *            on the tracing domain, see include/lttng/event.h in the
         *            lttng-tools tree for the complete enumeration.
         * @param type
         *            The log level filter type.
         */
        public LogLevelSelector(int logLevel, LogLevelType type) {
                this.logLevel = logLevel;
                this.logLevelType = type;
        }

        /**
         * Get the numerical value of the log level element. Does not apply if
         * {@link #getLogLevelType} returns
         * {@link LogLevelType#LTTNG_EVENT_LOGLEVEL_ALL}.
         *
         * @return The numerical value of the log level
         */
        public int getLogLevel() {
                return logLevel;
        }

        /**
         * Get the log level filter type.
         *
         * @return The log level filter type
         */
        public LogLevelType getLogLevelType() {
                return logLevelType;
        }

        /**
         * Helper method to determine if an event with the given log level should be
         * traced when considering this filter.
         *
         * For example, if this filter object represents "higher severity than 5",
         * and the log level passed in parameter is "8", it will return that it
         * matches (higher value means higher severity).
         *
         * @param targetLogLevel
         *            The log level value of the event to check for
         * @return Should this event be traced, or not
         */
        public boolean matches(int targetLogLevel) {
                switch (logLevelType) {
                case LTTNG_EVENT_LOGLEVEL_ALL:
                        return true;
                case LTTNG_EVENT_LOGLEVEL_RANGE:
                        return (targetLogLevel >= logLevel);
                case LTTNG_EVENT_LOGLEVEL_SINGLE:
                        return (targetLogLevel == logLevel);
                default:
                        throw new IllegalStateException();
                }
        }

        // ------------------------------------------------------------------------
        // Methods from Object
        // ------------------------------------------------------------------------

        @Override
        public int hashCode() {
                final int prime = 31;
                int result = 1;
                result = prime * result + logLevel;
                result = prime * result + ((logLevelType == null) ? 0 : logLevelType.hashCode());
                return result;
        }

        @Override
        public boolean equals(Object obj) {
                if (this == obj) {
                        return true;
                }
                if (obj == null) {
                        return false;
                }
                if (getClass() != obj.getClass()) {
                        return false;
                }
                LogLevelSelector other = (LogLevelSelector) obj;

                if (logLevel != other.logLevel) {
                        return false;
                }
                if (logLevelType != other.logLevelType) {
                        return false;
                }
                return true;
        }

        @Override
        public String toString() {
                if (getLogLevelType() == LogLevelType.LTTNG_EVENT_LOGLEVEL_ALL) {
                        return LogLevelType.LTTNG_EVENT_LOGLEVEL_ALL.toString();
                }
                return String.valueOf(getLogLevel()) + ", " + getLogLevelType().toString();
        }
}