modules/core/src/test/java/org/apache/ignite/internal/SensitiveInfoTestLoggerProxy.java - ignite - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.apache.ignite.internal;

 import java.io.BufferedReader;
 import java.io.Externalizable;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.InvalidObjectException;
 import java.io.ObjectInput;
 import java.io.ObjectOutput;
 import java.io.ObjectStreamException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.UUID;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import org.apache.ignite.IgniteLogger;
 import org.apache.ignite.IgniteSystemProperties;
 import org.apache.ignite.internal.util.tostring.GridToStringInclude;
 import org.apache.ignite.internal.util.typedef.internal.S;
 import org.apache.ignite.internal.util.typedef.internal.U;
 import org.apache.ignite.lang.IgniteBiTuple;
 import org.apache.ignite.lifecycle.LifecycleAware;
 import org.jetbrains.annotations.Nullable;

 import static org.apache.ignite.IgniteSystemProperties.IGNITE_LOG_GRID_NAME;

 /**
  *
  */
 public class SensitiveInfoTestLoggerProxy implements IgniteLogger, LifecycleAware, Externalizable {
     /**
      * If this system property is present the Ignite will test all strings passed into log.
      * It's a special mode for testing purposes. All debug information will be generated,
      * but only suspicious will be written into log with "error" level and special prefix SENSITIVE>
      */
     public static final String IGNITE_LOG_TEST_SENSITIVE = "IGNITE_LOG_TEST_SENSITIVE";

     /** Unique number for key. */
     public static final long SENSITIVE_KEY_MARKER = UUID.randomUUID().getLeastSignificantBits() | (1L << 63) & ~(0xFFL);

     /** Unique string sequence for value. */
     public static final String SENSITIVE_VAL_MARKER = UUID.randomUUID().toString();

     /** String prefix of unique number for key. */
     private static final String SENSITIVE_KEY_MARKER_PREFIX;

     /** Indicating whether sensitive marker assertions enabled. */
     private static final AtomicBoolean ENABLE_SENSITIVE_MARKER_ASSERTIONS = new AtomicBoolean();

     /** */
     private static final long serialVersionUID = 0L;

     /** Whether or not to log grid name. */
     private static final boolean logGridName = System.getProperty(IGNITE_LOG_GRID_NAME) != null;

     /** Test sensitive mode. */
     public static final boolean TEST_SENSITIVE = System.getProperty(IGNITE_LOG_TEST_SENSITIVE) != null;

     /** Prefix for all suspicious sensitive data. */
     private static final String SENSITIVE_PREFIX = "SENSITIVE> ";

     /** Sensitive patterns: excluding. */
     private static final Pattern[] EXCLUDE_PATTERNS;

     /** Sensitive patterns: including. */
     private static final Pattern[] INCLUDE_PATTERNS;

     /** Excluding logger categories */
     private static final Pattern EXCLUDE_CATEGORY_P = Pattern.compile("Test(Task|Job)?($|\\$)|\\.tests?\\.");

     /** */
     private static ThreadLocal<IgniteBiTuple<String, Object>> stash = new ThreadLocal<IgniteBiTuple<String, Object>>() {
         @Override protected IgniteBiTuple<String, Object> initialValue() {
             return new IgniteBiTuple<>();
         }
     };

     /** */
     private static ThreadLocal<StringBuilder> sbLoc = new ThreadLocal<StringBuilder>() {
         @Override protected StringBuilder initialValue() {
             return new StringBuilder(SENSITIVE_PREFIX);
         }
     };

     static {
         String prefix = Long.toString(SENSITIVE_KEY_MARKER);
         SENSITIVE_KEY_MARKER_PREFIX = prefix.substring(0, prefix.length() - 3);
     }

     static {
         EXCLUDE_PATTERNS = readFromResource("_Exclude.txt");
         INCLUDE_PATTERNS = readFromResource("_Include.txt");
     }

     /** */
     @GridToStringInclude
     private IgniteLogger impl;

     /** */
     private String gridName;

     /** */
     private String id8;

     /** */
     @GridToStringInclude
     private Object ctgr;

     /** Whether testing sensitive is enabled for the logger */
     private boolean testSensitive;

     /**
      * No-arg constructor is required by externalization.
      */
     public SensitiveInfoTestLoggerProxy() {
         // No-op.
     }

     /**
      * @param impl Logger implementation to proxy to.
      * @param ctgr Optional logger category.
      * @param gridName Grid name (can be {@code null} for default grid).
      * @param id8 Node ID.
      */
     public SensitiveInfoTestLoggerProxy(IgniteLogger impl,
         @Nullable Object ctgr,
         @Nullable String gridName,
         String id8) {
         assert impl != null;

         this.impl = impl;
         this.ctgr = ctgr;
         this.gridName = gridName;
         this.id8 = id8;
         this.testSensitive = TEST_SENSITIVE && (ctgr == null || !EXCLUDE_CATEGORY_P.matcher(ctgr.toString()).find());

         if (TEST_SENSITIVE && ctgr == null && gridName == null && id8 == null)
             impl.warning("Test sensitive mode is enabled");
     }

     /**
      * Sets sensitive marker assertions flag.
      *
      * @param enable Flag value.
      */
     public static void enableSensitiveMarkerAssertions(boolean enable) {
         ENABLE_SENSITIVE_MARKER_ASSERTIONS.set(enable);
     }

     /**
      * Reads sensitive patterns from resource.
      *
      * @param suffix File name suffix.
      * @return Read patterns.
      */
     private static Pattern[] readFromResource(String suffix) {
         ArrayList<Pattern> lst = new ArrayList<>();

         final Class<SensitiveInfoTestLoggerProxy> cls = SensitiveInfoTestLoggerProxy.class;

         String resPath = cls.getSimpleName() + suffix;

         try (InputStream inStr = cls.getResourceAsStream(resPath);
              BufferedReader rdr = new BufferedReader(new InputStreamReader(inStr))) {
             String ln;
             boolean skipComment = false;

             while ((ln = rdr.readLine()) != null) {
                 ln = ln.trim();

                 if (ln.isEmpty())
                     continue;

                 if (ln.startsWith("/*")) {
                     skipComment = true;
                     continue;
                 }

                 if (ln.endsWith("*/")) {
                     skipComment = false;
                     continue;
                 }

                 if (skipComment)
                     continue;

                 lst.add(Pattern.compile(ln));
             }
         }
         catch (Exception ex) {
             System.err.println("Error loading sensitive patterns from resource " + resPath + ": " + ex);

             ex.printStackTrace();
         }

         return lst.toArray(new Pattern[lst.size()]);
     }

     /**
      * @return Whether testing sensitive is enabled for the logger.
      */
     private boolean testSensitiveEnabled() {
         return testSensitive || ENABLE_SENSITIVE_MARKER_ASSERTIONS.get();
     }

     /** {@inheritDoc} */
     @Override public void start() {
         if (impl instanceof LifecycleAware)
             ((LifecycleAware)impl).start();
     }

     /** {@inheritDoc} */
     @Override public void stop() {
         U.stopLifecycleAware(this, Collections.singleton(impl));
     }

     /** {@inheritDoc} */
     @Override public IgniteLogger getLogger(Object ctgr) {
         assert ctgr != null;

         return new SensitiveInfoTestLoggerProxy(impl.getLogger(ctgr), ctgr, gridName, id8);
     }

     /** {@inheritDoc} */
     @Nullable @Override public String fileName() {
         return impl.fileName();
     }

     /** {@inheritDoc} */
     @Override public void trace(String msg) {
         if (testSensitiveEnabled()) {
             testSensitive(msg);

             if (impl.isTraceEnabled())
                 impl.trace(enrich(msg));
         }
         else
             impl.trace(enrich(msg));
     }

     /** {@inheritDoc} */
     @Override public void debug(String msg) {
         if (testSensitiveEnabled()) {
             testSensitive(msg);

             if (impl.isDebugEnabled())
                 impl.debug(enrich(msg));
         }
         else
             impl.debug(enrich(msg));
     }

     /** {@inheritDoc} */
     @Override public void info(String msg) {
         if (testSensitiveEnabled()) {
             testSensitive(msg);

             if (impl.isInfoEnabled())
                 impl.info(enrich(msg));
         }
         else
             impl.info(enrich(msg));
     }

     /** {@inheritDoc} */
     @Override public void warning(String msg) {
         if (testSensitiveEnabled())
             testSensitive(msg);

         impl.warning(enrich(msg));
     }

     /** {@inheritDoc} */
     @Override public void warning(String msg, Throwable e) {
         if (testSensitiveEnabled())
             testSensitive(msg, e);

         impl.warning(enrich(msg), e);
     }

     /** {@inheritDoc} */
     @Override public void error(String msg) {
         if (testSensitiveEnabled())
             testSensitive(msg);

         impl.error(enrich(msg));
     }

     /** {@inheritDoc} */
     @Override public void error(String msg, Throwable e) {
         if (testSensitiveEnabled())
             testSensitive(msg, e);

         impl.error(enrich(msg), e);
     }

     /** {@inheritDoc} */
     @Override public boolean isTraceEnabled() {
         return testSensitiveEnabled() || impl.isTraceEnabled();
     }

     /** {@inheritDoc} */
     @Override public boolean isDebugEnabled() {
         return testSensitiveEnabled() || impl.isDebugEnabled();
     }

     /** {@inheritDoc} */
     @Override public boolean isInfoEnabled() {
         return testSensitiveEnabled() || impl.isInfoEnabled();
     }

     /** {@inheritDoc} */
     @Override public boolean isQuiet() {
         return !testSensitiveEnabled() && impl.isQuiet();
     }

     /**
      * Enriches the log message with grid name if {@link IgniteSystemProperties#IGNITE_LOG_GRID_NAME}
      * system property is set.
      *
      * @param m Message to enrich.
      * @return Enriched message or the original one.
      */
     private String enrich(@Nullable String m) {
         return logGridName && m != null ? "<" + gridName + '-' + id8 + "> " + m : m;
     }

     /**
      * Testing the message by sensitive patterns.<br>
      * All sensitive data will be logged with {@link #SENSITIVE_PREFIX}
      *
      * @param m Log message.
      */
     private void testSensitive(String m) {
         String f = findSensitive(m);

         if (f != null)
             logSensitive(f, m);
     }

     /**
      * Testing the message and exceptions chain by sensitive patterns.<br>
      * All sensitive data will be logged with {@link #SENSITIVE_PREFIX}
      *
      * @param m Log message.
      * @param e Log error.
      */
     private void testSensitive(String m, Throwable e) {
         String f = findSensitive(m);

         if (f != null)
             logSensitive(f, m, e);

         while (e != null) {
             f = findSensitive(e.getMessage());

             if (f != null)
                 logSensitive(f, m, e);

             e = e.getCause();
         }
     }

     /**
      * Check the message by sensitive patterns
      *
      * @param msg Log message.
      * @return Matching string was found or {@code null} if not match.
      */
     private String findSensitive(String msg) {
         if (msg == null || msg.isEmpty())
             return null;

         if (ENABLE_SENSITIVE_MARKER_ASSERTIONS.get() &&
             msg.contains(SENSITIVE_KEY_MARKER_PREFIX) || msg.contains(SENSITIVE_VAL_MARKER)) {

             logSensitive("<MARKER>", msg);

             msg = msg.replace(SENSITIVE_KEY_MARKER_PREFIX, "<SENSITIVE_KEY_MARKER>").
                 replace(SENSITIVE_VAL_MARKER, "<SENSITIVE_VAL_MARKER>");

             throw new AssertionError("Found sensitive marker: " + msg);
         }

         for (Pattern p : EXCLUDE_PATTERNS) {
             Matcher m = p.matcher(msg);

             if (m.find())
                 return null;
         }

         for (Pattern p : INCLUDE_PATTERNS) {
             Matcher m = p.matcher(msg);

             if (m.find())
                 return m.group();
         }

         return null;
     }

     /**
      * Logging the message with {@link #SENSITIVE_PREFIX}.
      *
      * @param f Found problem message.
      * @param m Logged message.
      */
     private void logSensitive(String f, String m) {
         logSensitive(f, m, null);
     }

     /**
      * Logging the message and the exception with {@link #SENSITIVE_PREFIX}.
      *
      * @param f Found problem message.
      * @param m Logged message.
      * @param e Logged exception.
      */
     private void logSensitive(String f, String m, Throwable e) {
         StringBuilder sb = sbLoc.get();

         sb.setLength(SENSITIVE_PREFIX.length());

         sb.append("Found: ").append(f).
             append(", category = ").append(ctgr).
             append(", message:\n").append(m);

         if (e != null)
             sb.append("exception:\n").append(e.getClass()).append(": ").append(e.getMessage());

         impl.error(sb.toString());
     }

     /** {@inheritDoc} */
     @Override public void writeExternal(ObjectOutput out) throws IOException {
         U.writeString(out, gridName);
         out.writeObject(ctgr);
     }

     /** {@inheritDoc} */
     @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
         IgniteBiTuple<String, Object> t = stash.get();

         t.set1(U.readString(in));
         t.set2(in.readObject());
     }

     /**
      * Reconstructs object on unmarshalling.
      *
      * @return Reconstructed object.
      * @throws ObjectStreamException Thrown in case of unmarshalling error.
      */
     protected Object readResolve() throws ObjectStreamException {
         try {
             IgniteBiTuple<String, Object> t = stash.get();

             Object ctgrR = t.get2();

             IgniteLogger log = IgnitionEx.localIgnite().log();

             return ctgrR != null ? log.getLogger(ctgrR) : log;
         }
         catch (IllegalStateException e) {
             throw U.withCause(new InvalidObjectException(e.getMessage()), e);
         }
         finally {
             stash.remove();
         }
     }

     /** {@inheritDoc} */
     @Override public String toString() {
         return S.toString(SensitiveInfoTestLoggerProxy.class, this);
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.apache.ignite.internal;

	import java.io.BufferedReader;
	import java.io.Externalizable;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.InvalidObjectException;
	import java.io.ObjectInput;
	import java.io.ObjectOutput;
	import java.io.ObjectStreamException;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.UUID;
	import java.util.concurrent.atomic.AtomicBoolean;
	import java.util.regex.Matcher;
	import java.util.regex.Pattern;
	import org.apache.ignite.IgniteLogger;
	import org.apache.ignite.IgniteSystemProperties;
	import org.apache.ignite.internal.util.tostring.GridToStringInclude;
	import org.apache.ignite.internal.util.typedef.internal.S;
	import org.apache.ignite.internal.util.typedef.internal.U;
	import org.apache.ignite.lang.IgniteBiTuple;
	import org.apache.ignite.lifecycle.LifecycleAware;
	import org.jetbrains.annotations.Nullable;

	import static org.apache.ignite.IgniteSystemProperties.IGNITE_LOG_GRID_NAME;

	/**
	*
	*/
	public class SensitiveInfoTestLoggerProxy implements IgniteLogger, LifecycleAware, Externalizable {
	/**
	* If this system property is present the Ignite will test all strings passed into log.
	* It's a special mode for testing purposes. All debug information will be generated,
	* but only suspicious will be written into log with "error" level and special prefix SENSITIVE>
	*/
	public static final String IGNITE_LOG_TEST_SENSITIVE = "IGNITE_LOG_TEST_SENSITIVE";

	/** Unique number for key. */
	public static final long SENSITIVE_KEY_MARKER = UUID.randomUUID().getLeastSignificantBits() \| (1L << 63) & ~(0xFFL);

	/** Unique string sequence for value. */
	public static final String SENSITIVE_VAL_MARKER = UUID.randomUUID().toString();

	/** String prefix of unique number for key. */
	private static final String SENSITIVE_KEY_MARKER_PREFIX;

	/** Indicating whether sensitive marker assertions enabled. */
	private static final AtomicBoolean ENABLE_SENSITIVE_MARKER_ASSERTIONS = new AtomicBoolean();

	/** */
	private static final long serialVersionUID = 0L;

	/** Whether or not to log grid name. */
	private static final boolean logGridName = System.getProperty(IGNITE_LOG_GRID_NAME) != null;

	/** Test sensitive mode. */
	public static final boolean TEST_SENSITIVE = System.getProperty(IGNITE_LOG_TEST_SENSITIVE) != null;

	/** Prefix for all suspicious sensitive data. */
	private static final String SENSITIVE_PREFIX = "SENSITIVE> ";

	/** Sensitive patterns: excluding. */
	private static final Pattern[] EXCLUDE_PATTERNS;

	/** Sensitive patterns: including. */
	private static final Pattern[] INCLUDE_PATTERNS;

	/** Excluding logger categories */
	private static final Pattern EXCLUDE_CATEGORY_P = Pattern.compile("Test(Task\|Job)?($\|\\$)\|\\.tests?\\.");

	/** */
	private static ThreadLocal<IgniteBiTuple<String, Object>> stash = new ThreadLocal<IgniteBiTuple<String, Object>>() {
	@Override protected IgniteBiTuple<String, Object> initialValue() {
	return new IgniteBiTuple<>();
	}
	};

	/** */
	private static ThreadLocal<StringBuilder> sbLoc = new ThreadLocal<StringBuilder>() {
	@Override protected StringBuilder initialValue() {
	return new StringBuilder(SENSITIVE_PREFIX);
	}
	};

	static {
	String prefix = Long.toString(SENSITIVE_KEY_MARKER);
	SENSITIVE_KEY_MARKER_PREFIX = prefix.substring(0, prefix.length() - 3);
	}

	static {
	EXCLUDE_PATTERNS = readFromResource("_Exclude.txt");
	INCLUDE_PATTERNS = readFromResource("_Include.txt");
	}

	/** */
	@GridToStringInclude
	private IgniteLogger impl;

	/** */
	private String gridName;

	/** */
	private String id8;

	/** */
	@GridToStringInclude
	private Object ctgr;

	/** Whether testing sensitive is enabled for the logger */
	private boolean testSensitive;

	/**
	* No-arg constructor is required by externalization.
	*/
	public SensitiveInfoTestLoggerProxy() {
	// No-op.
	}

	/**
	* @param impl Logger implementation to proxy to.
	* @param ctgr Optional logger category.
	* @param gridName Grid name (can be {@code null} for default grid).
	* @param id8 Node ID.
	*/
	public SensitiveInfoTestLoggerProxy(IgniteLogger impl,
	@Nullable Object ctgr,
	@Nullable String gridName,
	String id8) {
	assert impl != null;

	this.impl = impl;
	this.ctgr = ctgr;
	this.gridName = gridName;
	this.id8 = id8;
	this.testSensitive = TEST_SENSITIVE && (ctgr == null \|\| !EXCLUDE_CATEGORY_P.matcher(ctgr.toString()).find());

	if (TEST_SENSITIVE && ctgr == null && gridName == null && id8 == null)
	impl.warning("Test sensitive mode is enabled");
	}

	/**
	* Sets sensitive marker assertions flag.
	*
	* @param enable Flag value.
	*/
	public static void enableSensitiveMarkerAssertions(boolean enable) {
	ENABLE_SENSITIVE_MARKER_ASSERTIONS.set(enable);
	}

	/**
	* Reads sensitive patterns from resource.
	*
	* @param suffix File name suffix.
	* @return Read patterns.
	*/
	private static Pattern[] readFromResource(String suffix) {
	ArrayList<Pattern> lst = new ArrayList<>();

	final Class<SensitiveInfoTestLoggerProxy> cls = SensitiveInfoTestLoggerProxy.class;

	String resPath = cls.getSimpleName() + suffix;

	try (InputStream inStr = cls.getResourceAsStream(resPath);
	BufferedReader rdr = new BufferedReader(new InputStreamReader(inStr))) {
	String ln;
	boolean skipComment = false;

	while ((ln = rdr.readLine()) != null) {
	ln = ln.trim();

	if (ln.isEmpty())
	continue;

	if (ln.startsWith("/*")) {
	skipComment = true;
	continue;
	}

	if (ln.endsWith("*/")) {
	skipComment = false;
	continue;
	}

	if (skipComment)
	continue;

	lst.add(Pattern.compile(ln));
	}
	}
	catch (Exception ex) {
	System.err.println("Error loading sensitive patterns from resource " + resPath + ": " + ex);

	ex.printStackTrace();
	}

	return lst.toArray(new Pattern[lst.size()]);
	}

	/**
	* @return Whether testing sensitive is enabled for the logger.
	*/
	private boolean testSensitiveEnabled() {
	return testSensitive \|\| ENABLE_SENSITIVE_MARKER_ASSERTIONS.get();
	}

	/** {@inheritDoc} */
	@Override public void start() {
	if (impl instanceof LifecycleAware)
	((LifecycleAware)impl).start();
	}

	/** {@inheritDoc} */
	@Override public void stop() {
	U.stopLifecycleAware(this, Collections.singleton(impl));
	}

	/** {@inheritDoc} */
	@Override public IgniteLogger getLogger(Object ctgr) {
	assert ctgr != null;

	return new SensitiveInfoTestLoggerProxy(impl.getLogger(ctgr), ctgr, gridName, id8);
	}

	/** {@inheritDoc} */
	@Nullable @Override public String fileName() {
	return impl.fileName();
	}

	/** {@inheritDoc} */
	@Override public void trace(String msg) {
	if (testSensitiveEnabled()) {
	testSensitive(msg);

	if (impl.isTraceEnabled())
	impl.trace(enrich(msg));
	}
	else
	impl.trace(enrich(msg));
	}

	/** {@inheritDoc} */
	@Override public void debug(String msg) {
	if (testSensitiveEnabled()) {
	testSensitive(msg);

	if (impl.isDebugEnabled())
	impl.debug(enrich(msg));
	}
	else
	impl.debug(enrich(msg));
	}

	/** {@inheritDoc} */
	@Override public void info(String msg) {
	if (testSensitiveEnabled()) {
	testSensitive(msg);

	if (impl.isInfoEnabled())
	impl.info(enrich(msg));
	}
	else
	impl.info(enrich(msg));
	}

	/** {@inheritDoc} */
	@Override public void warning(String msg) {
	if (testSensitiveEnabled())
	testSensitive(msg);

	impl.warning(enrich(msg));
	}

	/** {@inheritDoc} */
	@Override public void warning(String msg, Throwable e) {
	if (testSensitiveEnabled())
	testSensitive(msg, e);

	impl.warning(enrich(msg), e);
	}

	/** {@inheritDoc} */
	@Override public void error(String msg) {
	if (testSensitiveEnabled())
	testSensitive(msg);

	impl.error(enrich(msg));
	}

	/** {@inheritDoc} */
	@Override public void error(String msg, Throwable e) {
	if (testSensitiveEnabled())
	testSensitive(msg, e);

	impl.error(enrich(msg), e);
	}

	/** {@inheritDoc} */
	@Override public boolean isTraceEnabled() {
	return testSensitiveEnabled() \|\| impl.isTraceEnabled();
	}

	/** {@inheritDoc} */
	@Override public boolean isDebugEnabled() {
	return testSensitiveEnabled() \|\| impl.isDebugEnabled();
	}

	/** {@inheritDoc} */
	@Override public boolean isInfoEnabled() {
	return testSensitiveEnabled() \|\| impl.isInfoEnabled();
	}

	/** {@inheritDoc} */
	@Override public boolean isQuiet() {
	return !testSensitiveEnabled() && impl.isQuiet();
	}

	/**
	* Enriches the log message with grid name if {@link IgniteSystemProperties#IGNITE_LOG_GRID_NAME}
	* system property is set.
	*
	* @param m Message to enrich.
	* @return Enriched message or the original one.
	*/
	private String enrich(@Nullable String m) {
	return logGridName && m != null ? "<" + gridName + '-' + id8 + "> " + m : m;
	}

	/**
	* Testing the message by sensitive patterns.<br>
	* All sensitive data will be logged with {@link #SENSITIVE_PREFIX}
	*
	* @param m Log message.
	*/
	private void testSensitive(String m) {
	String f = findSensitive(m);

	if (f != null)
	logSensitive(f, m);
	}

	/**
	* Testing the message and exceptions chain by sensitive patterns.<br>
	* All sensitive data will be logged with {@link #SENSITIVE_PREFIX}
	*
	* @param m Log message.
	* @param e Log error.
	*/
	private void testSensitive(String m, Throwable e) {
	String f = findSensitive(m);

	if (f != null)
	logSensitive(f, m, e);

	while (e != null) {
	f = findSensitive(e.getMessage());

	if (f != null)
	logSensitive(f, m, e);

	e = e.getCause();
	}
	}

	/**
	* Check the message by sensitive patterns
	*
	* @param msg Log message.
	* @return Matching string was found or {@code null} if not match.
	*/
	private String findSensitive(String msg) {
	if (msg == null \|\| msg.isEmpty())
	return null;

	if (ENABLE_SENSITIVE_MARKER_ASSERTIONS.get() &&
	msg.contains(SENSITIVE_KEY_MARKER_PREFIX) \|\| msg.contains(SENSITIVE_VAL_MARKER)) {

	logSensitive("<MARKER>", msg);

	msg = msg.replace(SENSITIVE_KEY_MARKER_PREFIX, "<SENSITIVE_KEY_MARKER>").
	replace(SENSITIVE_VAL_MARKER, "<SENSITIVE_VAL_MARKER>");

	throw new AssertionError("Found sensitive marker: " + msg);
	}

	for (Pattern p : EXCLUDE_PATTERNS) {
	Matcher m = p.matcher(msg);

	if (m.find())
	return null;
	}

	for (Pattern p : INCLUDE_PATTERNS) {
	Matcher m = p.matcher(msg);

	if (m.find())
	return m.group();
	}

	return null;
	}

	/**
	* Logging the message with {@link #SENSITIVE_PREFIX}.
	*
	* @param f Found problem message.
	* @param m Logged message.
	*/
	private void logSensitive(String f, String m) {
	logSensitive(f, m, null);
	}

	/**
	* Logging the message and the exception with {@link #SENSITIVE_PREFIX}.
	*
	* @param f Found problem message.
	* @param m Logged message.
	* @param e Logged exception.
	*/
	private void logSensitive(String f, String m, Throwable e) {
	StringBuilder sb = sbLoc.get();

	sb.setLength(SENSITIVE_PREFIX.length());

	sb.append("Found: ").append(f).
	append(", category = ").append(ctgr).
	append(", message:\n").append(m);

	if (e != null)
	sb.append("exception:\n").append(e.getClass()).append(": ").append(e.getMessage());

	impl.error(sb.toString());
	}

	/** {@inheritDoc} */
	@Override public void writeExternal(ObjectOutput out) throws IOException {
	U.writeString(out, gridName);
	out.writeObject(ctgr);
	}

	/** {@inheritDoc} */
	@Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
	IgniteBiTuple<String, Object> t = stash.get();

	t.set1(U.readString(in));
	t.set2(in.readObject());
	}

	/**
	* Reconstructs object on unmarshalling.
	*
	* @return Reconstructed object.
	* @throws ObjectStreamException Thrown in case of unmarshalling error.
	*/
	protected Object readResolve() throws ObjectStreamException {
	try {
	IgniteBiTuple<String, Object> t = stash.get();

	Object ctgrR = t.get2();

	IgniteLogger log = IgnitionEx.localIgnite().log();

	return ctgrR != null ? log.getLogger(ctgrR) : log;
	}
	catch (IllegalStateException e) {
	throw U.withCause(new InvalidObjectException(e.getMessage()), e);
	}
	finally {
	stash.remove();
	}
	}

	/** {@inheritDoc} */
	@Override public String toString() {
	return S.toString(SensitiveInfoTestLoggerProxy.class, this);
	}
	}