You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@uima.apache.org by sc...@apache.org on 2017/02/27 20:24:30 UTC
svn commit: r1784650 - in /uima/uimaj/branches/experiment-v3-jcas:
uima-docbook-tutorials-and-users-guides/src/docbook/
uima-docbook-v3-users-guide/src/docbook/
Author: schor
Date: Mon Feb 27 20:24:30 2017
New Revision: 1784650
URL: http://svn.apache.org/viewvc?rev=1784650&view=rev
Log:
[UIMA-5293] logging updates
Modified:
uima/uimaj/branches/experiment-v3-jcas/uima-docbook-tutorials-and-users-guides/src/docbook/annotator_analysis_engine_guide.xml
uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.backwards_compatibility.xml
uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.logging.xml
uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.new_extended_apis.xml
uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.overview.xml
Modified: uima/uimaj/branches/experiment-v3-jcas/uima-docbook-tutorials-and-users-guides/src/docbook/annotator_analysis_engine_guide.xml
URL: http://svn.apache.org/viewvc/uima/uimaj/branches/experiment-v3-jcas/uima-docbook-tutorials-and-users-guides/src/docbook/annotator_analysis_engine_guide.xml?rev=1784650&r1=1784649&r2=1784650&view=diff
==============================================================================
--- uima/uimaj/branches/experiment-v3-jcas/uima-docbook-tutorials-and-users-guides/src/docbook/annotator_analysis_engine_guide.xml (original)
+++ uima/uimaj/branches/experiment-v3-jcas/uima-docbook-tutorials-and-users-guides/src/docbook/annotator_analysis_engine_guide.xml Mon Feb 27 20:24:30 2017
@@ -930,7 +930,9 @@ public void initialize(UimaContext aCont
<para>The UIMA SDK provides a logging facility, which is very similar to the
java.util.logging.Logger class that was introduced in Java 1.4.
- In addition, it includes the SLF4j framework <ulink url="https://www.slf4j.org/"/>.</para>
+ In addition, it includes the SLF4j framework <ulink url="https://www.slf4j.org/"/>
+ and all the methods in that framework's <code>Logger</code> API, plus
+ the Java 8 specific API extensions that take <code>Supplier</code> parameters.</para>
<para>Each logger instance is associated with a name. By
convention, this name is usually a hierarchy of simple names connected with periods,
@@ -941,50 +943,52 @@ public void initialize(UimaContext aCont
<para>The UIMA framework supports this convention using the
<literal>UimaContext</literal> object. If you access a logger instance using
- <literal>getContext().getLogger()</literal> within an Annotator, the logger
+ <literal>getContext().getLogger()</literal> or the shorter, but equivalent
+ <literal>getUimaLogger()</literal>
+ within an Annotator, the logger
name will be the fully qualified name of the Annotator implementation class.</para>
-
+
<para>Here is an example from the process method of
<literal>org.apache.uima.tutorial.ex2.RoomNumberAnnotator</literal>:
- <programlisting>getLogger().log(Level.FINEST,"Found: " + annotation);
-// or, using slf4j
-// note: this call format skips constructing the message
-// if tracing is not enabled
-getSlf4jLogger().trace("Found: {}", annotation);
-</programlisting>
+ <programlisting>getLogger().trace("Found: {}", annotation);</programlisting>
</para>
- <para>When using the UIMA logger, the first argument to the log method is the level of the log output.
- Here, a value of
- FINEST indicates that this is a highly-detailed tracing message. While useful for
+ <para>The <code>trace</code> call
+ indicates that this is a tracing message. While useful for
debugging, it is likely that real applications will not output log messages at this
- level, in order to improve their performance. Other defined levels, from lowest to
- highest importance, are FINER, FINE, CONFIG, INFO, WARNING, and SEVERE.</para>
-
- <para>When using the SLF4j logger, SEVERE is replaced by error,
- CONFIG is not present (use a config marker instead), and
- FINE, and FINER are replaced with trace and FINEST with debug.
- There are individual methods for various calls as well,
- as an alternative to specifying the level as a parameter.</para>
+ level, in order to improve their performance. Other defined levels for the UIMA logger, from lowest to
+ highest importance, are FINER, FINE, CONFIG, INFO, WARNING, and SEVERE.
+ SLF4J and other modern logging systems use a slightly different set: DEBUG, TRACE, INFO, wARN, and ERROR.
+ You may use either of these in your code, but the recommendation is to use the SLF4J tags in new code.</para>
+
+ <para>These correspond as follows: SEVERE → ERROR, CONFIG → INFO + UIMA_MARKER_CONFIG,
+ FINE → TRACE + UIMA_MARKER_FINE, FINER → TRACE + UIMA_MARKER_FINER, and
+ FINEST → DEBUG.
+ </para>
<para>Each logging backend has its own documentation for how
to configure loggers at run time, via configuration files or APIs in some cases.
Some backends even allow dynamic reconfiguration
- while running, just by updating the configuration file (it is re-loaded every so often).
+ while running, just by updating the configuration file (it is re-loaded every so often, if changed).
</para>
<para>For the built-in-to-Java logging back end, if no logging configuration file is provided (see next section),
- the Java
- Virtual Machine defaults would be used, which typically set the level to INFO and
+ the Java Virtual Machine defaults would be used, which typically set the level to INFO and
higher messages, and direct output to the console.</para>
-
- <para>When using SLF4j, you must configure a specific back end - none are defaulted.
- See the SLF4j documentation for how to do this - it typically involves
- putting into Java's classpath the appropriate back end JARs.</para>
+
+ <para>The UIMA logger is by default implemented using an SLF4J implementation; this (in turn) connects to
+ a logging back end, determined via a search of the classpath for a connector. If none can be found,
+ then a message to that effect will be printed to System.err, and no logging will be done.
+ The binary distribution for UIMA includes, in its <code>lib</code> directory, the
+ Jar which connects SLF4j to the Java-built-in logger to use as
+ its back end, so if you use the standard launchers, you will get this logging back end.
+ </para>
+
- <para>If you specify the standard UIMA SDK <literal>Logger.properties</literal>
- (found in <code>UIMA_HOME/config/</code>) with the default built-in Java logging implementation,
+ <para>Assuming you are using the Java-built-in-logger as the back-end,
+ if you specify the configuration using the standard UIMA SDK <literal>Logger.properties</literal>
+ (found in <code>UIMA_HOME/config/</code>),
the output will be directed to a file named uima.log, in the current working directory
(often the <quote>project</quote> directory when running from Eclipse, for
instance).</para>
@@ -1005,9 +1009,8 @@ getSlf4jLogger().trace("Found: {}", anno
<section id="ugr.tug.aae.logging.configuring">
<title>Specifying the Logging Configuration when using Java's built-in logger</title>
- <para>The standard UIMA logger uses the underlying Java 1.4 logging mechanism. You
- can use the APIs that come with that to configure the logging. In addition, the
- standard Java 1.4 logging initialization mechanisms will look for a Java System
+ <para>The
+ standard Java built-in logging initialization mechanisms will look for a Java System
Property named <literal>java.util.logging.config.file</literal> and if
found, will use the value of this property as the name of a standard
<quote>properties</quote> file, for setting the logging level. Please refer to
@@ -1022,7 +1025,7 @@ getSlf4jLogger().trace("Found: {}", anno
to the console. You can edit these files, or create additional ones, as described
below, to change the logging behavior.</para>
- <para>When running your own Java application, you can specify the location of the
+ <para>When running your own Java application, you can specify the location of this
logging configuration file on your Java command line by setting the Java system
property <literal>java.util.logging.config.file</literal> to be the logging
configuration filename. This file specification can be either absolute or
@@ -1138,14 +1141,15 @@ getSlf4jLogger().trace("Found: {}", anno
<title>Using loggers outside of an annotator</title>
<para>An application using UIMA may want to log its messages using the same logging
- framework. This can be done by getting a reference to the UIMA logger, as follows:
+ framework. This can be done by getting a reference to the UIMA logger, as follows:
+ <programlisting>Logger logger = UIMAFramework.getLogger(TestClass.class);</programlisting>.
+ </para>
- <programlisting>Logger logger = UIMAFramework.getLogger(TestClass.class);</programlisting>
- or getting a SLF4j logger:
- <programlisting>org.slf4j.Logger logger = LogFactory.getLogger(TestClass.class);</programlisting>
- </para>
+ <para>You can also simply get a direct reference to an Slf4j logger using the standard approach:
+ <programlisting>org.slf4j.Logger logger = org.slf4j.LogFactory.getLogger(TestClass.class);</programlisting>
+ </para>
- <para>The class argument allows filtering by class.
+ <para>The class argument specifies the name of the logger, using the fully qualified class name.
For UIMA loggers, if not specified, the name of the returned logger instance is
<quote>org.apache.uima</quote>.</para>
</section>
@@ -1153,30 +1157,51 @@ getSlf4jLogger().trace("Found: {}", anno
<section id="ugr.tug.aae.logging.change_logger_implementation">
<title>Changing the underlying UIMA logging implementation</title>
- <para>By default the UIMA framework uses, under the hood of the UIMA Logger interface, the Java logging framework
- to do logging. But it is possible to change the logging implementation that UIMA use from Java logging to
- an arbitrary logging system when specifying the system property
- <programlisting>-Dorg.apache.uima.logger.class=<loggerClass></programlisting>
- when the UIMA framework is started.
- </para>
- <para>
- The specified logger class must be available in the classpath and has to implement the
- <code>org.apache.uima.util.Logger</code> interface.
+ <para>By default the UIMA framework uses, under the hood of the UIMA Logger interface, the
+ SLF4J logging framework to do logging. This allows UIMA, when running embedded inside other frameworks,
+ to defer the choice of back-end logging frameworks to those applications.
</para>
+ <para>For backwards compatibility with Version 2, the older methods (prior to Slf4j) for switching the
+ logger implementation remains.
+ You do this by specifying the system property
+ <programlisting>-Dorg.apache.uima.logger.class=<loggerClass></programlisting>
+ when the UIMA framework is started.
+ </para>
<para>
- UIMA also provides a logging implementation that use Apache <code>Log4j 2</code>
- <ulink url="https://logging.apache.org/log4j"/> instead of Java logging. To
- use <code>Log4j 2</code> you have to provide the <code>Log4j 2</code> jars in the classpath and your application
- must specify the logging configuration as shown below.
- <programlisting><?db-font-size 80% ?>-Dorg.apache.uima.logger.class=org.apache.uima.util.impl.Log4jLogger_impl</programlisting>
+ The specified logger class must be available in the classpath and has to subclass the
+ <code>org.apache.uima.util.Logger_common_impl</code> class.
</para>
-
- <para>The SLF4j logger framework, if used, must be configured with a particular back end.
- Instructions on how to do this are in the SLF4j manual. Note that some bindings, including
- the one for <code>log4j 2</code> are provided with their individual back ends.</para>
+
+ <para>For backwards compatibility, V3 continues to provide the class
+ <code>org.apache.uima.util.impl.Log4jLogger_impl</code> as an alternative
+ which can be specified this way by this JVM argument:
+ <programlisting><?db-font-size 80% ?>-Dorg.apache.uima.logger.class=org.apache.uima.util.impl.Log4jLogger_impl</programlisting>
+ to switch to the log4j back end. This has been updated in V3 to <code>log4j 2</code>
+ (see <ulink url="https://logging.apache.org/log4j"/>).
+ If you use this, you must provide the required <code>Log4j 2</code> jars in the classpath.
+ </para>
+
</section>
+ <section id="uv3.logging.suppress_annotator_logging">
+ <title>Throttling excessive logging from Annotators</title>
+
+ <para>Sometimes, in production, you may find annotators are logging excessively, and you wish to throttle
+ this. But you may not have access to logging settings to control this,
+ perhaps because UIMA is running as a library component within another framework.
+ For this special case,
+ you can limit logging done by Annotators by passing an additional parameter to the UIMA Framework's
+ produceAnalysisEngine API, using the key name
+ <code>AnalysisEngine.PARAM_THROTTLE_EXCESSIVE_ANNOTATOR_LOGGING</code>
+ and setting the value to an Integer object equal to the the limit. Using 0 will suppress all logging.
+ Any positive number allows that many log records to be logged, per level. A limit of 10 would allow
+ 10 Errors, 10 Warnings, etc. The limit is enforced separately, per logger instance.</para>
+
+ <note><para>This only works if the logger used by Annotators is obtained from the
+ Annotator base implementation class via the <code>getLogger()</code> method.</para></note>
+
+ </section>
</section>
</section>
Modified: uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.backwards_compatibility.xml
URL: http://svn.apache.org/viewvc/uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.backwards_compatibility.xml?rev=1784650&r1=1784649&r2=1784650&view=diff
==============================================================================
--- uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.backwards_compatibility.xml (original)
+++ uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.backwards_compatibility.xml Mon Feb 27 20:24:30 2017
@@ -159,6 +159,8 @@ under the License.
UIMA Type, inside and outside of the PEAR context.
If this is detected, a runtime exception is thrown.
</para>
+
+ <para>The workaround for this is to manually merge any JCas class definitions for the same class.</para>
</section>
<section id="uv3.backards_compatibility.toString">
@@ -172,6 +174,25 @@ under the License.
</para>
</section>
+ <section id="uv3.backards_compatibility.logging">
+ <title>Logging configuration is somewhat different</title>
+
+ <para>The default logging configuration in v2 was to use Java Util Logging (the logger built into Java).
+ For v3, the default is to use SLF4J which, in turn, picks a back-end logger, depending on what it finds
+ in the class path.</para>
+
+ <para>This change was done to permit easier integration of UIMA as a library running within other frameworks.
+ </para>
+
+ <para>The technique for (optionally) reporting the class and method (and sometimes, line number)
+ was changed to conform to current logger conventions - whereby the loggers themselves obtain this
+ information from the call stack. The V2 calls which pass in the sourceClass and sourceMethod information
+ have this information ignored, but replaced with what the loggers obtain from the stack track.
+ In some cases, where the callers in V2 were not actually passing in the correct class/method information,
+ this will result in a different log record.</para>
+ <para>
+ For more details, please see the logging chapter.</para>
+ </section>
<section id="uv3.backards_compatibility.typesystem_sharing">
<title>Type System sharing</title>
@@ -189,7 +210,7 @@ under the License.
an already existing one.</para>
<para>Application code may code around this by re-acquiring references to type and feature
- objects, if the type system returned from <code>commit</code> is not identical (==) to the
+ objects, if the type system instance object returned from <code>commit</code> is not identical (==) to the
one being committed.</para>
</section>
Modified: uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.logging.xml
URL: http://svn.apache.org/viewvc/uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.logging.xml?rev=1784650&r1=1784649&r2=1784650&view=diff
==============================================================================
--- uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.logging.xml (original)
+++ uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.logging.xml Mon Feb 27 20:24:30 2017
@@ -27,14 +27,20 @@ under the License.
<chapter id="uv3.logging">
<title>Logging</title>
- <para>V3 retains the existing V2 logging facade, unchanged, for backwards compatibility.
- In addition, a new logging facade, the open source standard SLF4J is available.
- The current APIs for getting a logger get the V2 loggers; the SLF4j logger is made available
- using the standard SLF4j <code>LoggerFactory.getLogger(...)</code> API call,
- as well as via a new API on the Annotator base implementation classes, <code>getSlf4jLogger(),
- </code> which returns a named logger whose name is the fully qualified name of the
- annotator implementation class.
+ <para>V3 retains the existing V2 logging facade, for backwards compatibility.
+ It has been augmented by the methods available in the SLF4j <code>Logger</code> API,
+ plus the Java 8 enabled APIs from the Log4j implementation that support the
+ <code>Supplier</code> Functional Interface.
</para>
+
+ <para>The implementation of this facade in V2 was the built-in-to-Java logging framework.
+ For V3, this is changed to be the SLF4j facade. This is an open source, standard facade
+ which allows deferring until deployment time, the specific logging back end to use.
+ </para>
+
+ <para>If, at initialization time, SLF4J gets configuredto use a back end which is either the
+ built-in Java logger, or Log4j-2, then the UIMA logger implementation is switched to
+ UIMA's implementation of those APIs (bypassing SLF4j, for efficiency).</para>
<!--
<para>The v2 loggers support internationalization using resource bundles. The logger
@@ -55,16 +61,14 @@ under the License.
The SLF4j and other documentation (e.g.,
<ulink url="https://logging.apache.org/log4j/2.x/log4j-slf4j-impl/index.html"/> for log4j-2) describe
how to connect various logging back ends to SLF4j, by
- putting adapters and back ends into the classpath at run time. For example,
- to use the back end logger <code>log4j 2</code>, you would
- include the Jars specified in this dependency tree as "compile" dependencies:
- <ulink url="https://logging.apache.org/log4j/2.x/log4j-to-slf4j/dependencies.html#Dependency_Tree"/>.
- These are included in the binary distribution.
+ putting logging back-end implementations into the classpath at run time. For example,
+ to use the back end logger built into Java, you would
+ include the <code>slf4j-jdk14</code> Jar. This Jar is included in the UIMA binary distribution, so that
+ out-of-the-box, logging is available and configured the same as it was for V2.
</para>
- <para>The Eclipse UIMA Runtime plugin excludes the slf4j api Jar and back ends, and expects the
- Eclipse plugin install process to "hook up" the needed implementations from other resource bundles. In current
- versions of Eclipse, the standard Java version of the IDE has multiple implementations available.
+ <para>The Eclipse UIMA Runtime plugin bundle excludes the slf4j api Jar and back ends, but will
+ "hook up" the needed implementations from other bundles.
</para>
<section id="uv3.logging.new_recorded_context_data">
@@ -140,8 +144,31 @@ under the License.
<entry><emphasis role="bold">Description of logging</emphasis></entry>
</row>
+ <row>
+ <entry spanname="fullwidth"><emphasis role="bold">Markers used to classify CONFIG and FINE/FINER/FINEST </emphasis></entry>
+ </row>
+ <row>
+ <entry><para>uima.config</para></entry>
+ <entry><para>configuration log record</para></entry>
+ </row>
+ <row>
+ <entry><para>uima.fine</para></entry>
+ <entry><para>sub category of trace, corresponds to FINE</para></entry>
+ </row>
+ <row>
+ <entry><para>uima.finer</para></entry>
+ <entry><para>sub category of trace, corresponds to FINER</para></entry>
+ </row>
+ <row>
+ <entry><para>uima.finest</para></entry>
+ <entry><para>sub category of trace, corresponds to FINEST</para></entry>
+ </row>
+
<!-- ******************************************************************************* -->
<row>
+ <entry spanname="fullwidth"><emphasis role="bold">Markers used to classify some tracing logging</emphasis></entry>
+ </row>
+ <row>
<entry><para>uima_annotator</para></entry>
<entry><para>for tracing when annotators are entered, exited</para></entry>
</row>
@@ -181,4 +208,42 @@ under the License.
</informaltable>
</section>
+
+ <section id="uv3.logging.defaults_configuration">
+ <title>Defaults and Configuration</title>
+
+ <para>By default, UIMA is configured so that the UIMA logger is hooked up to the SLF4j facade, which
+ may or may not have a logging back-end. If it doesn't, then any use of the UIMA logger will produce
+ one warning message stating that SLF4j has no back-end logger configured, and so no logging will be done.
+ </para>
+
+ <para>When UIMA is run as an embedded library in other applications, slf4j will use those other application's
+ logging frameworks.</para>
+
+ <para>Each logging back-end has its own way of being configured;
+ please consult the proper back-end documentation for details.</para>
+
+ <para>For backwards compatibility, the binary distribution of UIMA includes the slf4j back-end
+ which hooks to the standard built-in Java logging framework, so out-of-the-box, UIMA should
+ be configured and log by default as V2 did.</para>
+
+ <section id="uv3.logging.throttling_annotator_logging">
+ <title>Throttling logging from Annotators</title>
+
+ <para>Sometimes, in production, you may find annotators are logging excessively, and you wish to throttle
+ this. But you may not have access to logging settings to control this,
+ perhaps because UIMA is running as a library component within another framework.
+ For this special case,
+ you can limit logging done by Annotators by passing an additional parameter to the UIMA Framework's
+ produceAnalysisEngine API, using the key name
+ <code>AnalysisEngine.PARAM_THROTTLE_EXCESSIVE_ANNOTATOR_LOGGING</code>
+ and setting the value to an Integer object equal to the the limit. Using 0 will suppress all logging.
+ Any positive number allows that many log records to be logged, per level. A limit of 10 would allow
+ 10 Errors, 10 Warnings, etc. The limit is enforced separately, per logger instance.</para>
+
+ <note><para>This only works if the logger used by Annotators is obtained from the
+ Annotator base implementation class via the <code>getLogger()</code> method.</para></note>
+
+ </section>
+ </section>
</chapter>
\ No newline at end of file
Modified: uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.new_extended_apis.xml
URL: http://svn.apache.org/viewvc/uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.new_extended_apis.xml?rev=1784650&r1=1784649&r2=1784650&view=diff
==============================================================================
--- uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.new_extended_apis.xml (original)
+++ uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.new_extended_apis.xml Mon Feb 27 20:24:30 2017
@@ -70,6 +70,9 @@ public final static String _FeatName_sof
<para>The new <code>select</code> framework supports stream operations; see the "select" chapter for details.
</para>
+
+ <para>The UIMA Logger implementation has been extended with both the SLF4J logger APIs and the
+ Log4j APIs which support Java 8's <code>Supplier</code> Functional Interfaces.</para>
</section>
</section>
Modified: uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.overview.xml
URL: http://svn.apache.org/viewvc/uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.overview.xml?rev=1784650&r1=1784649&r2=1784650&view=diff
==============================================================================
--- uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.overview.xml (original)
+++ uima/uimaj/branches/experiment-v3-jcas/uima-docbook-v3-users-guide/src/docbook/uv3.overview.xml Mon Feb 27 20:24:30 2017
@@ -178,17 +178,18 @@ under the License.
<term><emphasis role="strong">Logging updated</emphasis></term>
<listitem>
<para>The UIMA logger is a facade that can be hooked up at deploy time to one of several logging backends.
- One of these is the log4j logging framework. UIMA V3 updates the support for this backend (when and if selected)
- to the current level of that framework, now an Apache project called log4j 2.</para>
-
- <para>In addition, a now popular logging facade, slf4j, is added to UIMA. This framework can be hooked up to
- various logging backends, including log4j 2. As a default, the Jars needed to for using log4j 2 as the backend
- are included in the binary packaging.</para>
+ It has been extended to implement all of the Logger API calls provided in the SLF4j <code>Logger</code>
+ interface, and has been changed to use SLF4j as its back-end. SLF4j, in turn,
+ requires a logging back-end which it
+ determines by examining what's available in the classpath, at deploy time. This design
+ allows UIMA to be more easily embedded in other systems which have their own logging frameworks.</para>
<para>Modern loggers support MDC/NDC and Markers; these are supported now via the slf4j facade.
- UIMA itself is extended to use these to provide contexts around logging;
- see the following chapter on logging for details.</para>
-
+ UIMA itself is extended to use these to provide contexts around logging.
+ </para>
+
+ <para>See the following chapter on logging for details.</para>
+
</listitem>
</varlistentry>