From 5f4423526b0562bb6d6cf204ddb5068df50c4759 Mon Sep 17 00:00:00 2001
From: Tim Ward <timothyjward@apache.org>
Date: Wed, 13 May 2020 14:26:59 +0100
Subject: [PATCH 1/2] [FELIX-6274] Add a test demonstrating the LogService
 ClassCastException

Create a simple test which shows component bundles using different incompatible versions of the log service
can't be properly handled by Felix SCR due to a ClassCastException

Signed-off-by: Tim Ward <timothyjward@apache.org>
---
 .../scr/integration/ComponentTestBase.java    |   7 +-
 .../felix/scr/integration/Felix6274Test.java  | 150 ++++++++++++++++++
 .../components/felix6274/Component.java       |  33 ++++
 .../components/felix6274_2/Component.java     |  33 ++++
 .../resources/integration_test_FELIX_6274.xml |  27 ++++
 .../integration_test_FELIX_6274_2.xml         |  27 ++++
 6 files changed, 275 insertions(+), 2 deletions(-)
 create mode 100644 scr/src/test/java/org/apache/felix/scr/integration/Felix6274Test.java
 create mode 100644 scr/src/test/java/org/apache/felix/scr/integration/components/felix6274/Component.java
 create mode 100644 scr/src/test/java/org/apache/felix/scr/integration/components/felix6274_2/Component.java
 create mode 100644 scr/src/test/resources/integration_test_FELIX_6274.xml
 create mode 100644 scr/src/test/resources/integration_test_FELIX_6274_2.xml

diff --git a/scr/src/test/java/org/apache/felix/scr/integration/ComponentTestBase.java b/scr/src/test/java/org/apache/felix/scr/integration/ComponentTestBase.java
index 61ba1ec7d7..a877084a14 100644
--- a/scr/src/test/java/org/apache/felix/scr/integration/ComponentTestBase.java
+++ b/scr/src/test/java/org/apache/felix/scr/integration/ComponentTestBase.java
@@ -185,6 +185,7 @@ public static Option[] configuration()
                         mavenBundle( "org.apache.felix", "org.apache.felix.configadmin", felixCaVersion ) ),
                         mavenBundle( "org.osgi", "org.osgi.util.promise"),
                         mavenBundle( "org.osgi", "org.osgi.util.function"),
+                        mavenBundle( "org.ops4j.pax.url", "pax-url-aether"),
                 junitBundles(), frameworkProperty( "org.osgi.framework.bsnversion" ).value( bsnVersionUniqueness ),
                 systemProperty( "ds.factory.enabled" ).value( Boolean.toString( NONSTANDARD_COMPONENT_FACTORY_BEHAVIOR ) ),
                 systemProperty( "ds.loglevel" ).value( DS_LOGLEVEL ),
@@ -211,8 +212,10 @@ public void setUp() throws BundleException
                 ConfigurationAdmin.class, null );
         configAdminTracker.open();
 
-        bundle = installBundle( descriptorFile, COMPONENT_PACKAGE );
-        bundle.start();
+        if( descriptorFile != null ) {
+            bundle = installBundle( descriptorFile, COMPONENT_PACKAGE );
+            bundle.start();
+        }
     }
 
     @After
diff --git a/scr/src/test/java/org/apache/felix/scr/integration/Felix6274Test.java b/scr/src/test/java/org/apache/felix/scr/integration/Felix6274Test.java
new file mode 100644
index 0000000000..8c315f5099
--- /dev/null
+++ b/scr/src/test/java/org/apache/felix/scr/integration/Felix6274Test.java
@@ -0,0 +1,150 @@
+/*
+ * 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.felix.scr.integration;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.ops4j.pax.exam.CoreOptions.mavenBundle;
+import static org.ops4j.pax.tinybundles.core.TinyBundles.bundle;
+import static org.ops4j.pax.tinybundles.core.TinyBundles.withClassicBuilder;
+
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.ops4j.pax.exam.junit.PaxExam;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleException;
+import org.osgi.framework.Constants;
+import org.osgi.namespace.extender.ExtenderNamespace;
+import org.osgi.service.component.runtime.dto.ComponentConfigurationDTO;
+import org.osgi.service.component.runtime.dto.ComponentDescriptionDTO;
+import org.osgi.service.log.LogService;
+
+@RunWith(PaxExam.class)
+public class Felix6274Test extends ComponentTestBase
+{
+    static
+    {
+        // This test creates its own component bundles
+        descriptorFile = null;
+        DS_LOGLEVEL = "debug";
+        // paxRunnerVmOption = DEBUG_VM_OPTION;
+    }
+
+    private final List<Bundle> installedBundles = new ArrayList<>();
+    private Bundle log_1_4_bundle;
+    private Bundle log_1_3_bundle;
+    
+    @Before
+    public void installBundles() throws BundleException {
+        
+        // Install an older version of the log service 
+        String url = mavenBundle( "org.apache.felix", "org.apache.felix.log", "1.0.1" ).getURL();
+        installedBundles.add( bundleContext.installBundle( url ) );
+
+        // Install the R7 version of the log service 
+        url = mavenBundle( "org.apache.felix", "org.apache.felix.log", "1.2.2" ).getURL();
+        installedBundles.add( bundleContext.installBundle( url ) );
+        
+        log_1_4_bundle = bundleContext.installBundle( "integration.test.6274", 
+                createStream( "6274", "[1.4,1.5)" ) );
+        installedBundles.add( log_1_4_bundle );
+
+        log_1_3_bundle = bundleContext.installBundle( "integration.test.6274_2", 
+                createStream( "6274_2", "[1.3,1.4)" ) );
+        installedBundles.add( log_1_3_bundle );
+
+        for( Bundle b : installedBundles ) {
+            b.start();
+        }
+    }
+    
+    @After
+    public void cleanUpBundles() {
+        for( Bundle b : installedBundles ) {
+            try {
+                b.uninstall();
+            } catch ( BundleException be ) {
+                // Just swallow this and keep going
+            }
+        }
+    }
+    
+    private InputStream createStream(String testNumber, String logImportVersionRange) {
+        String classFilePath = "org/apache/felix/scr/integration/components/felix" + testNumber + "/Component.class";
+        String componentXML = "integration_test_FELIX_" + testNumber + ".xml";
+        
+        System.out.println("Located descriptor " + getClass().getResource( "/" + componentXML ) );
+        
+        return bundle().add("OSGI-INF/components.xml", getClass().getResource( "/" + componentXML ) )
+                .add(classFilePath, getClass().getResource( "/" + classFilePath ) )
+
+                .set( Constants.BUNDLE_MANIFESTVERSION, "2" )
+                .set( Constants.BUNDLE_SYMBOLICNAME, "integration.test." + testNumber )
+                .set( Constants.BUNDLE_VERSION, "1.0.0" )
+                .set( Constants.IMPORT_PACKAGE, "org.osgi.service.log;version=\"" + logImportVersionRange + "\"" )
+                .set( "Service-Component", "OSGI-INF/components.xml" )
+                .set( Constants.REQUIRE_CAPABILITY, ExtenderNamespace.EXTENDER_NAMESPACE
+                                + ";filter:=\"(&(osgi.extender=osgi.component)(version>=1.4)(!(version>=2.0)))\"" )
+                .build( withClassicBuilder() );
+    }
+    
+    @Test
+    public void test_incompatible_log_service_version() throws Exception
+    {
+        
+        delay();
+
+        // Locate the components
+        ComponentDescriptionDTO log_1_4_dto = scrTracker.getService().getComponentDescriptionDTO(
+                log_1_4_bundle, "R7LoggerComponent" );
+
+        ComponentDescriptionDTO log_1_3_dto = scrTracker.getService().getComponentDescriptionDTO(
+                log_1_3_bundle, "LogServiceComponent" );
+
+        assertNotNull( "No Log 1.4 Component DTO", log_1_4_dto );
+        assertNotNull( "No Log 1.3 Component DTO", log_1_3_dto );
+
+        // Get the runtime instance data
+        Collection<ComponentConfigurationDTO> running_1_4_components = scrTracker.getService()
+                .getComponentConfigurationDTOs( log_1_4_dto );
+        
+        Collection<ComponentConfigurationDTO> running_1_3_components = scrTracker.getService()
+                .getComponentConfigurationDTOs( log_1_3_dto );
+        
+        assertEquals( 1, running_1_4_components.size() );
+        assertEquals( 1, running_1_3_components.size() );
+        
+        // Check the components are active
+        assertEquals( "1.4 Log Service Component failed to activate", 
+                ComponentConfigurationDTO.ACTIVE, running_1_4_components.iterator().next().state );
+        log.log( LogService.LOG_INFO, "R7LoggerComponent checked active" );
+        
+        assertEquals( "1.3 Log Service Component failed to activate", 
+                ComponentConfigurationDTO.ACTIVE, running_1_3_components.iterator().next().state);
+        log.log( LogService.LOG_INFO, "LogServiceComponent checked active" );
+        
+    }
+}
diff --git a/scr/src/test/java/org/apache/felix/scr/integration/components/felix6274/Component.java b/scr/src/test/java/org/apache/felix/scr/integration/components/felix6274/Component.java
new file mode 100644
index 0000000000..32eae52d15
--- /dev/null
+++ b/scr/src/test/java/org/apache/felix/scr/integration/components/felix6274/Component.java
@@ -0,0 +1,33 @@
+/*
+ * 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.felix.scr.integration.components.felix6274;
+
+import org.osgi.service.log.Logger;
+
+public class Component
+{
+
+	Logger logger;
+	
+    void activate()
+    {
+        logger.info("Hello from felix6274");
+    }
+
+}
diff --git a/scr/src/test/java/org/apache/felix/scr/integration/components/felix6274_2/Component.java b/scr/src/test/java/org/apache/felix/scr/integration/components/felix6274_2/Component.java
new file mode 100644
index 0000000000..bec90db2db
--- /dev/null
+++ b/scr/src/test/java/org/apache/felix/scr/integration/components/felix6274_2/Component.java
@@ -0,0 +1,33 @@
+/*
+ * 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.felix.scr.integration.components.felix6274_2;
+
+import org.osgi.service.log.LogService;
+
+public class Component
+{
+
+	LogService logger;
+	
+    void activate()
+    {
+        logger.log(LogService.LOG_INFO, "Hello from felix6274_2");
+    }
+
+}
diff --git a/scr/src/test/resources/integration_test_FELIX_6274.xml b/scr/src/test/resources/integration_test_FELIX_6274.xml
new file mode 100644
index 0000000000..91d8b63b98
--- /dev/null
+++ b/scr/src/test/resources/integration_test_FELIX_6274.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    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.
+-->
+<components xmlns:scr="http://www.osgi.org/xmlns/scr/v1.4.0">
+
+    <scr:component name="R7LoggerComponent">
+        <implementation class="org.apache.felix.scr.integration.components.felix6274.Component" />
+        <reference name="LOG" interface="org.osgi.service.log.LoggerFactory" field="logger"/>
+    </scr:component>
+        
+</components>
\ No newline at end of file
diff --git a/scr/src/test/resources/integration_test_FELIX_6274_2.xml b/scr/src/test/resources/integration_test_FELIX_6274_2.xml
new file mode 100644
index 0000000000..005967a9b0
--- /dev/null
+++ b/scr/src/test/resources/integration_test_FELIX_6274_2.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+    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.
+-->
+<components xmlns:scr="http://www.osgi.org/xmlns/scr/v1.4.0">
+
+    <scr:component name="LogServiceComponent">
+        <implementation class="org.apache.felix.scr.integration.components.felix6274_2.Component" />
+        <reference name="LOG" interface="org.osgi.service.log.LogService" field="logger"/>
+    </scr:component>
+        
+</components>
\ No newline at end of file

From a9be2a988f169c0ad9e77ae5414a68ce279ca38a Mon Sep 17 00:00:00 2001
From: Thomas Watson <tjwatson@us.ibm.com>
Date: Fri, 29 May 2020 15:36:58 -0500
Subject: [PATCH 2/2] [FELIX-6274] - Stop supporting pre R7 LogService for the
 Logger

The OSGi R7 LogService introduced the LoggerFactory which allows SCR to
get the Logger for another bundle without having to resort to using the
extendee bundles context to get the LogService.  This allows SCR to use
the log package SCR is wired to without having to worry about the
package that the extendee is wired to for log.  It also simplifies much
with how SCR logs and it keeps the log entries for all bundles that SCR
extends flowing through the same LogService that SCR uses instead of
disjointly though all the different LogServices the extendees may be
wired to.

Change-Id: I4f1169adf089b34fb460f4b2f40607c17948c909
Signed-off-by: Thomas Watson <tjwatson@us.ibm.com>
---
 scr/bnd.bnd                                   |   6 +-
 scr/pom.xml                                   |   8 +-
 .../org/apache/felix/scr/impl/Activator.java  |  69 +++---
 .../scr/impl/BundleComponentActivator.java    |  62 +++--
 .../felix/scr/impl/ComponentActorThread.java  |  16 +-
 .../felix/scr/impl/ComponentCommands.java     |   2 +-
 .../felix/scr/impl/ComponentRegistry.java     |  20 +-
 .../scr/impl/config/ScrConfigurationImpl.java |  32 +--
 .../scr/impl/helper/ConfigAdminTracker.java   |   4 +-
 .../felix/scr/impl/inject/ValueUtils.java     |  40 ++-
 .../scr/impl/inject/field/FieldHandler.java   |  25 +-
 .../scr/impl/inject/field/FieldUtils.java     |  25 +-
 .../scr/impl/inject/internal/ClassUtils.java  |  34 +--
 .../internal/ComponentConstructorImpl.java    |  16 +-
 .../impl/inject/methods/ActivateMethod.java   |   4 +-
 .../scr/impl/inject/methods/BaseMethod.java   |  49 ++--
 .../scr/impl/inject/methods/BindMethod.java   |  74 +++---
 .../felix/scr/impl/logger/AbstractLogger.java |  21 +-
 .../felix/scr/impl/logger/BundleLogger.java   |  31 +--
 .../scr/impl/logger/ComponentLogger.java      |  10 +-
 .../felix/scr/impl/logger/InternalLogger.java |  16 +-
 .../impl/logger/LogServiceEnabledLogger.java  |  82 ++-----
 .../scr/impl/logger/LogServiceSupport.java    |  82 -------
 .../felix/scr/impl/logger/OSGiLogger.java     |  76 ++++++
 .../scr/impl/logger/R6LogServiceLogger.java   |  52 ----
 .../scr/impl/logger/R7LogServiceLogger.java   |  79 ------
 .../felix/scr/impl/logger/ScrLogger.java      |  25 +-
 .../felix/scr/impl/logger/StdOutLogger.java   |  33 ++-
 .../manager/AbstractComponentManager.java     | 129 ++++++----
 .../manager/AbstractPrototypeRefPair.java     |   4 +-
 .../impl/manager/ComponentContextImpl.java    |   6 +-
 .../impl/manager/ComponentFactoryImpl.java    |   5 +-
 .../manager/ConfigurableComponentHolder.java  |  23 +-
 .../scr/impl/manager/DependencyManager.java   | 177 ++++++++------
 .../felix/scr/impl/manager/EdgeInfo.java      |   8 +-
 .../manager/RegionConfigurationSupport.java   |  34 +--
 .../scr/impl/manager/RegistrationManager.java |  33 ++-
 .../scr/impl/manager/ScrConfiguration.java    |   3 +-
 .../ServiceFactoryComponentManager.java       |  14 +-
 .../impl/manager/SingleComponentManager.java  |  72 ++++--
 .../felix/scr/impl/manager/SingleRefPair.java |   4 +-
 .../apache/felix/scr/impl/xml/XmlHandler.java |  10 +-
 .../java/org/osgi/service/log/Logger.java     |  53 ----
 .../org/osgi/service/log/LoggerFactory.java   |  31 ---
 .../scr/impl/logger/MockBundleLogger.java     |  13 +-
 .../scr/impl/logger/MockComponentLogger.java  |   6 +-
 .../felix/scr/impl/logger/MockScrLogger.java  |   6 +-
 .../impl/manager/RegistrationManagerTest.java |   3 +-
 .../scr/integration/ComponentTestBase.java    | 228 +++++++++++++++++-
 .../felix/scr/integration/Felix6274Test.java  |  39 ++-
 .../components/felix6274_hook/Activator.java  |  98 ++++++++
 51 files changed, 1149 insertions(+), 843 deletions(-)
 delete mode 100644 scr/src/main/java/org/apache/felix/scr/impl/logger/LogServiceSupport.java
 create mode 100644 scr/src/main/java/org/apache/felix/scr/impl/logger/OSGiLogger.java
 delete mode 100644 scr/src/main/java/org/apache/felix/scr/impl/logger/R6LogServiceLogger.java
 delete mode 100644 scr/src/main/java/org/apache/felix/scr/impl/logger/R7LogServiceLogger.java
 delete mode 100644 scr/src/main/java/org/osgi/service/log/Logger.java
 delete mode 100644 scr/src/main/java/org/osgi/service/log/LoggerFactory.java
 create mode 100644 scr/src/test/java/org/apache/felix/scr/integration/components/felix6274_hook/Activator.java

diff --git a/scr/bnd.bnd b/scr/bnd.bnd
index ebba0c12e4..625ae46ff0 100644
--- a/scr/bnd.bnd
+++ b/scr/bnd.bnd
@@ -22,14 +22,14 @@ Export-Package: org.apache.felix.scr.component;version=1.1.0;provide:=true, \
 Private-Package: org.apache.felix.scr.impl.*
 
 # Configuration Admin is optional and dynamic, but allow eager wiring by importing it
-# LogService is optional but if present the R4.0 version 1.3 is sufficient.
+# LogService is optional but if present the R7.0 version 1.4 is sufficient.
 # Metatype import is optional and dynamic, but allow eager wiring by importing it
 # PackageAdmin is used to find reference types if the component's bundle does not import it.
 #    R4.0 version 1.2 is sufficient.
 # optional import for Gogo annotations 
 Import-Package: \
  org.osgi.service.cm;version="[1.6,2)";resolution:=optional, \
- org.osgi.service.log;version="[1.3,2)";resolution:=optional, \
+ org.osgi.service.log;version="[1.4,2)";resolution:=optional, \
  org.osgi.service.metatype;version="[1.2,2)";resolution:=optional, \
  org.osgi.service.packageadmin;version="[1.2,2)";resolution:=optional,\
  org.apache.felix.service.command;resolution:=optional, \
@@ -37,5 +37,5 @@ Import-Package: \
 
 DynamicImport-Package: \
  org.osgi.service.cm;version="[1.6,2)", \
- org.osgi.service.log;version="[1.3,2)", \
+ org.osgi.service.log;version="[1.4,2)", \
  org.osgi.service.metatype;version="[1.1,2)"
diff --git a/scr/pom.xml b/scr/pom.xml
index d451915588..88a1347f9f 100644
--- a/scr/pom.xml
+++ b/scr/pom.xml
@@ -97,7 +97,7 @@
         <dependency>
             <groupId>org.osgi</groupId>
             <artifactId>org.osgi.service.log</artifactId>
-            <version>1.3.0</version>
+            <version>1.4.0</version>
             <scope>provided</scope>
         </dependency>
         <dependency>
@@ -149,21 +149,21 @@
         <dependency>
             <groupId>org.ops4j.pax.exam</groupId>
             <artifactId>pax-exam-container-forked</artifactId>
-            <version>3.2.0</version>
+            <version>4.13.3</version>
             <scope>test</scope>
         </dependency>
 
         <dependency>
             <groupId>org.ops4j.pax.exam</groupId>
             <artifactId>pax-exam-junit4</artifactId>
-            <version>3.2.0</version>
+            <version>4.13.3</version>
             <scope>test</scope>
         </dependency>
     
         <dependency>
             <groupId>org.ops4j.pax.exam</groupId>
             <artifactId>pax-exam-link-mvn</artifactId>
-            <version>3.2.0</version>
+            <version>4.13.3</version>
             <scope>test</scope>
         </dependency>
     
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/Activator.java b/scr/src/main/java/org/apache/felix/scr/impl/Activator.java
index fbe6ec2359..5235f04634 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/Activator.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/Activator.java
@@ -42,6 +42,7 @@
 
 import org.apache.felix.scr.impl.config.ScrConfigurationImpl;
 import org.apache.felix.scr.impl.inject.internal.ClassUtils;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.logger.ScrLogger;
 import org.apache.felix.scr.impl.manager.ComponentHolder;
 import org.apache.felix.scr.impl.metadata.ComponentMetadata;
@@ -59,7 +60,6 @@
 import org.osgi.namespace.extender.ExtenderNamespace;
 import org.osgi.service.component.ComponentConstants;
 import org.osgi.service.component.runtime.ServiceComponentRuntime;
-import org.osgi.service.log.LogService;
 
 /**
  * This activator is used to cover requirement described in section 112.8.1 @@ -27,14
@@ -137,7 +137,9 @@ public void restart(boolean globalExtender)
         }
         if ( ClassUtils.m_packageAdmin != null )
         {
-            logger.log(LogService.LOG_INFO, "Stopping to restart with new globalExtender setting: {0}", null, globalExtender);
+            logger.log(Level.INFO,
+                "Stopping to restart with new globalExtender setting: {0}", null,
+                globalExtender);
 
             //this really is a restart, not the initial start
             // the initial start where m_globalContext is null should skip this as m_packageAdmin should not yet be set.
@@ -150,21 +152,20 @@ public void restart(boolean globalExtender)
                 // logger might be null
                 if ( logger != null )
                 {
-                    logger.log(LogService.LOG_ERROR,  "Exception stopping during restart", e);
+                    logger.log(Level.ERROR, "Exception stopping during restart", e);
                 }
             }
-            // reinstantiate logger
-            logger = new ScrLogger(m_configuration, m_context);
         }
         try
         {
-            logger.log(LogService.LOG_INFO, "Starting with globalExtender setting: {0}", null, globalExtender);
+            logger.log(Level.INFO, "Starting with globalExtender setting: {0}", null,
+                globalExtender);
 
             super.start( m_globalContext );
         }
         catch ( final Exception e )
         {
-            logger.log(LogService.LOG_ERROR,  "Exception starting during restart", e);
+            logger.log(Level.ERROR, "Exception starting during restart", e);
         }
 
     }
@@ -184,7 +185,7 @@ protected void doStart() throws Exception
         m_componentRegistry.setRegistration(m_runtime_reg);
 
         // log SCR startup
-        logger.log( LogService.LOG_INFO, " Version = {0}",
+        logger.log(Level.INFO, " Version = {0}",
             null, m_bundle.getVersion().toString() );
 
         // create and start the component actor
@@ -207,6 +208,7 @@ public void stop(BundleContext context) throws Exception
         super.stop( context );
         m_configuration.stop();
         store(m_componentMetadataStore, context, logger, m_configuration.cacheMetadata());
+        logger.closeTracker();
     }
 
     @Override
@@ -277,7 +279,7 @@ private static ConcurrentMap<Long, List<ComponentMetadata>> load(
                 }
                 catch (IOException e)
                 {
-                    logger.log(LogService.LOG_WARNING,
+                    logger.log(Level.WARN,
                         "Error loading component metadata cache.", e);
                 }
             }
@@ -286,7 +288,7 @@ private static ConcurrentMap<Long, List<ComponentMetadata>> load(
         catch (RuntimeException re)
         {
             // avoid failing all of SCR start on cache load bug
-            logger.log(LogService.LOG_ERROR,
+            logger.log(Level.ERROR,
                 "Error loading component metadata cache.", re);
             return new ConcurrentHashMap<>();
         }
@@ -339,7 +341,7 @@ private static void store(Map<Long, List<ComponentMetadata>> componentsMap,
         }
         catch (IOException e)
         {
-            logger.log(LogService.LOG_WARNING, "Error storing component metadata cache.",
+            logger.log(Level.WARN, "Error storing component metadata cache.",
                 e);
         }
     }
@@ -376,13 +378,6 @@ public void doStop() throws Exception
             m_componentActor.terminate();
             m_componentActor = null;
         }
-
-        // close the LogService tracker now
-        if ( logger != null )
-        {
-            logger.close();
-            logger = null;
-        }
         ClassUtils.close();
     }
 
@@ -418,7 +413,9 @@ public void start()
                 catch ( final InterruptedException e )
                 {
                     Thread.currentThread().interrupt();
-                    logger.log(LogService.LOG_WARNING,  "The wait for {0} being destroyed before destruction has been interrupted.", e,
+                    logger.log(Level.WARN,
+                        "The wait for {0} being destroyed before destruction has been interrupted.",
+                        e,
                             bundle );
                 }
                 loadComponents( ScrExtension.this.bundle );
@@ -445,7 +442,9 @@ public void destroy()
                 catch ( final InterruptedException e )
                 {
                     Thread.currentThread().interrupt();
-                    logger.log(LogService.LOG_WARNING,  "The wait for {0} being started before destruction has been interrupted.", e,
+                    logger.log(Level.WARN,
+                        "The wait for {0} being started before destruction has been interrupted.",
+                        e,
                             bundle );
 
                 }
@@ -494,7 +493,7 @@ private void loadComponents(Bundle bundle)
         BundleContext context = bundle.getBundleContext();
         if ( context == null )
         {
-            logger.log(LogService.LOG_DEBUG,  "Cannot get BundleContext of {0}.", null, bundle);
+            logger.log(Level.DEBUG, "Cannot get BundleContext of {0}.", null, bundle);
 
             return;
         }
@@ -509,7 +508,8 @@ private void loadComponents(Bundle bundle)
             {
                 if ( !m_bundle.adapt( BundleRevision.class ).equals( wire.getProvider() ) )
                 {
-                    logger.log(LogService.LOG_DEBUG,  "{0} wired to a different extender: {1}.", null,
+                    logger.log(Level.DEBUG, "{0} wired to a different extender: {1}.",
+                        null,
                             bundle, wire.getProvider().getBundle());
 
                     return;
@@ -540,7 +540,8 @@ private void loadComponents(Bundle bundle)
         // terminate if already loaded (or currently being loaded)
         if ( loaded )
         {
-            logger.log(LogService.LOG_DEBUG,  "Components for {0} already loaded. Nothing to do.", null,
+            logger.log(Level.DEBUG,
+                "Components for {0} already loaded. Nothing to do.", null,
                     bundle );
 
             return;
@@ -578,12 +579,15 @@ private void loadComponents(Bundle bundle)
 
             if ( e instanceof IllegalStateException && bundle.getState() != Bundle.ACTIVE )
             {
-                logger.log(LogService.LOG_DEBUG,  "{0} has been stopped while trying to activate its components. Trying again when the bundles gets started again.", e,
+                logger.log(Level.DEBUG,
+                    "{0} has been stopped while trying to activate its components. Trying again when the bundles gets started again.",
+                    e,
                         bundle );
             }
             else
             {
-                logger.log(LogService.LOG_ERROR,  "Error while loading components of {0}", e, bundle);
+                logger.log(Level.ERROR, "Error while loading components of {0}", e,
+                    bundle);
             }
         }
     }
@@ -610,7 +614,8 @@ private void disposeComponents(Bundle bundle)
             }
             catch ( Exception e )
             {
-                logger.log(LogService.LOG_ERROR,  "Error while disposing components of {0}", e, bundle);
+                logger.log(Level.ERROR, "Error while disposing components of {0}", e,
+                    bundle);
             }
         }
     }
@@ -618,15 +623,15 @@ private void disposeComponents(Bundle bundle)
     @Override
     protected void debug(final Bundle bundle, final String msg)
     {
-        if ( logger.isLogEnabled(LogService.LOG_DEBUG) )
+        if (logger.isLogEnabled(Level.DEBUG))
         {
             if ( bundle != null )
             {
-                logger.log( LogService.LOG_DEBUG, "{0} : " + msg, null, bundle );
+                logger.log(Level.DEBUG, "{0} : " + msg, null, bundle);
             }
             else
             {
-                logger.log( LogService.LOG_DEBUG, msg, null );
+                logger.log(Level.DEBUG, msg, null);
             }
         }
     }
@@ -634,15 +639,15 @@ protected void debug(final Bundle bundle, final String msg)
     @Override
     protected void warn(final Bundle bundle, final String msg, final Throwable t)
     {
-        if ( logger.isLogEnabled(LogService.LOG_WARNING) )
+        if (logger.isLogEnabled(Level.WARN))
         {
             if ( bundle != null )
             {
-                logger.log( LogService.LOG_WARNING, "{0} : " + msg, t, bundle );
+                logger.log(Level.WARN, "{0} : " + msg, t, bundle);
             }
             else
             {
-                logger.log( LogService.LOG_WARNING, msg, t );
+                logger.log(Level.WARN, msg, t);
             }
         }
     }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/BundleComponentActivator.java b/scr/src/main/java/org/apache/felix/scr/impl/BundleComponentActivator.java
index cf1227f3fc..1e880a3b96 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/BundleComponentActivator.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/BundleComponentActivator.java
@@ -38,6 +38,7 @@
 import org.apache.felix.scr.impl.helper.ConfigAdminTracker;
 import org.apache.felix.scr.impl.logger.BundleLogger;
 import org.apache.felix.scr.impl.logger.ComponentLogger;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.logger.ScrLogger;
 import org.apache.felix.scr.impl.manager.AbstractComponentManager;
 import org.apache.felix.scr.impl.manager.ComponentActivator;
@@ -57,7 +58,6 @@
 import org.osgi.framework.ServiceReference;
 import org.osgi.service.cm.ConfigurationAdmin;
 import org.osgi.service.component.ComponentException;
-import org.osgi.service.log.LogService;
 
 /**
  * The BundleComponentActivator is helper class to load and unload Components of
@@ -141,7 +141,8 @@ public void addServiceListener(String serviceFilterString,
         ListenerInfo listenerInfo;
         synchronized ( listenerMap )
         {
-            logger.log( LogService.LOG_DEBUG, "serviceFilterString: " + serviceFilterString, null);
+            logger.log(Level.DEBUG, "serviceFilterString: " + serviceFilterString,
+                null);
             listenerInfo = listenerMap.get( serviceFilterString );
             if ( listenerInfo == null )
             {
@@ -198,7 +199,7 @@ public BundleComponentActivator(final ScrLogger scrLogger,
     throws ComponentException
     {
         // create a logger on behalf of the bundle
-        this.logger = new BundleLogger(context, scrLogger);
+        this.logger = new BundleLogger(context.getBundle(), scrLogger);
         // keep the parameters for later
         m_componentRegistry = componentRegistry;
         m_componentActor = componentActor;
@@ -207,7 +208,7 @@ public BundleComponentActivator(final ScrLogger scrLogger,
 
         m_configuration = configuration;
 
-        logger.log( LogService.LOG_DEBUG, "BundleComponentActivator : Bundle active", null);
+        logger.log(Level.DEBUG, "BundleComponentActivator : Bundle active", null);
 
         initialize(cachedComponentMetadata);
         ConfigAdminTracker tracker = null;
@@ -248,7 +249,7 @@ protected void initialize(List<ComponentMetadata> cachedComponentMetadata)
                     "Service-Component entry not found in the manifest");
             }
 
-            logger.log(LogService.LOG_DEBUG,
+            logger.log(Level.DEBUG,
                 "BundleComponentActivator : Descriptor locations {0}", null,
                 descriptorLocations);
 
@@ -264,7 +265,7 @@ protected void initialize(List<ComponentMetadata> cachedComponentMetadata)
                 {
                     // 112.4.1 If an XML document specified by the header cannot be located in the bundle and its attached
                     // fragments, SCR must log an error message with the Log Service, if present, and continue.
-                    logger.log(LogService.LOG_ERROR,
+                    logger.log(Level.ERROR,
                         "Component descriptor entry ''{0}'' not found", null,
                         descriptorLocation);
                     continue;
@@ -289,12 +290,14 @@ void initialEnable()
         //enable all the enabled components
         for ( ComponentHolder<?> componentHolder : m_holders )
         {
-            logger.log( LogService.LOG_DEBUG, "BundleComponentActivator : May enable component holder {0}", null,
+            logger.log(Level.DEBUG,
+                "BundleComponentActivator : May enable component holder {0}", null,
                 componentHolder.getComponentMetadata().getName() );
 
             if ( componentHolder.getComponentMetadata().isEnabled() )
             {
-                logger.log( LogService.LOG_DEBUG, "BundleComponentActivator :Enabling component holder {0}", null,
+                logger.log(Level.DEBUG,
+                    "BundleComponentActivator :Enabling component holder {0}", null,
                     componentHolder.getComponentMetadata().getName() );
 
                 try
@@ -315,14 +318,14 @@ void initialEnable()
                     {
                     }
 
-                    logger.log( LogService.LOG_ERROR,
+                    logger.log(Level.ERROR,
                         "BundleComponentActivator : Unexpected failure enabling component holder {0}", t,
                         componentHolder.getComponentMetadata().getName() );
                 }
             }
             else
             {
-                logger.log( LogService.LOG_DEBUG,
+                logger.log(Level.DEBUG,
                     "BundleComponentActivator : Will not enable component holder {0}", null,
                     componentHolder.getComponentMetadata().getName() );
             }
@@ -404,11 +407,13 @@ private void loadDescriptor(final URL descriptorURL)
             // 112.4.1 If an XML document specified by the header cannot be located in the bundle and its attached
             // fragments, SCR must log an error message with the Log Service, if present, and continue.
 
-            logger.log( LogService.LOG_ERROR, "Problem reading descriptor entry ''{0}''", ex, descriptorLocation );
+            logger.log(Level.ERROR, "Problem reading descriptor entry ''{0}''", ex,
+                descriptorLocation);
         }
         catch ( Exception ex )
         {
-            logger.log( LogService.LOG_ERROR, "General problem with descriptor entry ''{0}''", ex, descriptorLocation );
+            logger.log(Level.ERROR, "General problem with descriptor entry ''{0}''",
+                ex, descriptorLocation);
         }
         finally
         {
@@ -445,7 +450,7 @@ void validateAndRegister(ComponentMetadata metadata)
             m_componentRegistry.registerComponentHolder(key, holder);
             m_holders.add(holder);
 
-            componentLogger.log(LogService.LOG_DEBUG,
+            componentLogger.log(Level.DEBUG,
                 "BundleComponentActivator : ComponentHolder created.", null);
 
         }
@@ -453,7 +458,7 @@ void validateAndRegister(ComponentMetadata metadata)
         {
             // There is a problem with this particular component, we'll log the error
             // and proceed to the next one
-            componentLogger.log(LogService.LOG_ERROR, "Cannot register component", t);
+            componentLogger.log(Level.ERROR, "Cannot register component", t);
 
             // make sure the name is not reserved any more
             if (key != null)
@@ -471,7 +476,8 @@ void dispose(int reason)
     {
         if ( m_active.compareAndSet( true, false ) )
         {
-            logger.log( LogService.LOG_DEBUG, "BundleComponentActivator : Will destroy {0} instances",
+            logger.log(Level.DEBUG,
+                "BundleComponentActivator : Will destroy {0} instances",
                 null, m_holders.size() );
 
             for ( ComponentHolder<?> holder : m_holders )
@@ -482,7 +488,8 @@ void dispose(int reason)
                 }
                 catch ( Exception e )
                 {
-                    logger.log( LogService.LOG_ERROR, "BundleComponentActivator : Exception invalidating", e,
+                    logger.log(Level.ERROR,
+                        "BundleComponentActivator : Exception invalidating", e,
                         holder.getComponentMetadata() );
                 }
                 finally
@@ -496,10 +503,9 @@ void dispose(int reason)
                 configAdminTracker.dispose();
             }
 
-            logger.log( LogService.LOG_DEBUG, "BundleComponentActivator : Bundle STOPPED",
+            logger.log(Level.DEBUG, "BundleComponentActivator : Bundle STOPPED",
                 null );
 
-            logger.close();
             m_closeLatch.countDown();
         }
         else
@@ -565,13 +571,15 @@ public void enableComponent(final String name)
             try
             {
                 // TODO use component logger
-                logger.log( LogService.LOG_DEBUG, "Enabling Component {0}", null, aHolder.getComponentMetadata().getName() );
+                logger.log(Level.DEBUG, "Enabling Component {0}", null,
+                    aHolder.getComponentMetadata().getName());
                 aHolder.enableComponents( true );
             }
             catch ( Throwable t )
             {
                 // TODO use component logger
-                logger.log( LogService.LOG_ERROR, "Cannot enable component {0}", t, aHolder.getComponentMetadata().getName() );
+                logger.log(Level.ERROR, "Cannot enable component {0}", t,
+                    aHolder.getComponentMetadata().getName());
             }
         }
     }
@@ -594,13 +602,15 @@ public void disableComponent(final String name)
             try
             {
                 // TODO use component logger
-                logger.log( LogService.LOG_DEBUG, "Disabling Component {0}", null, aHolder.getComponentMetadata().getName() );
+                logger.log(Level.DEBUG, "Disabling Component {0}", null,
+                    aHolder.getComponentMetadata().getName());
                 aHolder.disableComponents( true );
             }
             catch ( Throwable t )
             {
                 // TODO use component logger
-                logger.log( LogService.LOG_ERROR, "Cannot disable component {0}", t, aHolder.getComponentMetadata().getName() );
+                logger.log(Level.ERROR, "Cannot disable component {0}", t,
+                    aHolder.getComponentMetadata().getName());
             }
         }
     }
@@ -673,7 +683,8 @@ public void schedule(Runnable task)
             }
             else
             {
-                logger.log( LogService.LOG_DEBUG, "Component Actor Thread not running, calling synchronously", null );
+                logger.log(Level.DEBUG,
+                    "Component Actor Thread not running, calling synchronously", null);
                 try
                 {
                     synchronized ( this )
@@ -683,13 +694,14 @@ public void schedule(Runnable task)
                 }
                 catch ( Throwable t )
                 {
-                    logger.log( LogService.LOG_WARNING, "Unexpected problem executing task", t );
+                    logger.log(Level.WARN, "Unexpected problem executing task", t);
                 }
             }
         }
         else
         {
-            logger.log( LogService.LOG_WARNING, "BundleComponentActivator is not active; not scheduling {0}",
+            logger.log(Level.WARN,
+                "BundleComponentActivator is not active; not scheduling {0}",
                 null, task );
         }
     }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/ComponentActorThread.java b/scr/src/main/java/org/apache/felix/scr/impl/ComponentActorThread.java
index 336c02abd1..d1aa3bafca 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/ComponentActorThread.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/ComponentActorThread.java
@@ -21,8 +21,8 @@
 
 import java.util.LinkedList;
 
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.logger.ScrLogger;
-import org.osgi.service.log.LogService;
 
 
 /**
@@ -68,7 +68,7 @@ public String toString()
     @Override
     public void run()
     {
-        logger.log( LogService.LOG_DEBUG, "Starting ComponentActorThread", null );
+        logger.log(Level.DEBUG, "Starting ComponentActorThread", null);
 
         for ( ;; )
         {
@@ -104,17 +104,19 @@ public void run()
                 // return if the task is this thread itself
                 if ( task == TERMINATION_TASK )
                 {
-                    logger.log( LogService.LOG_DEBUG, "Shutting down ComponentActorThread", null );
+                    logger.log(Level.DEBUG, "Shutting down ComponentActorThread",
+                        null);
                     return;
                 }
 
                 // otherwise execute the task, log any issues
-                logger.log( LogService.LOG_DEBUG, "Running task: " + task, null );
+                logger.log(Level.DEBUG, "Running task: " + task, null);
                 task.run();
             }
             catch ( Throwable t )
             {
-                logger.log( LogService.LOG_ERROR, "Unexpected problem executing task " + task, t );
+                logger.log(Level.ERROR, "Unexpected problem executing task " + task,
+                    t);
             }
             finally
             {
@@ -144,7 +146,7 @@ void terminate()
                 catch ( InterruptedException e )
                 {
                     interrupted = true;
-                    logger.log(LogService.LOG_ERROR,
+                    logger.log(Level.ERROR,
                         "Interrupted exception waiting for queue to empty", e);
                 }
                 finally
@@ -167,7 +169,7 @@ void schedule( Runnable task )
             // append to the task queue
             tasks.add( task );
 
-            logger.log( LogService.LOG_DEBUG, "Adding task [{0}] as #{1} in the queue", null,
+            logger.log(Level.DEBUG, "Adding task [{0}] as #{1} in the queue", null,
                     task, tasks.size());
 
             // notify the waiting thread
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/ComponentCommands.java b/scr/src/main/java/org/apache/felix/scr/impl/ComponentCommands.java
index e485211255..08d9184487 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/ComponentCommands.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/ComponentCommands.java
@@ -227,7 +227,7 @@ public boolean disable(@Descriptor("Name of the component") final String name) {
     @Descriptor("Show the current SCR configuration")
     public String config() {
         Map<String,String> out = new LinkedHashMap<>();
-        out.put("Log Level", Integer.toString(scrConfig.getLogLevel()));
+        out.put("Log Level", scrConfig.getLogLevel().toString());
         out.put("Obsolete Component Factory with Factory Configuration", Boolean.toString(scrConfig.isFactoryEnabled()));
         out.put("Keep instances with no references", scrConfig.keepInstances() ? "Supported" : "Unsupported");
         out.put("Lock timeout ms", Long.toString(scrConfig.lockTimeout()));
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/ComponentRegistry.java b/scr/src/main/java/org/apache/felix/scr/impl/ComponentRegistry.java
index a1574b73cc..7169f8758e 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/ComponentRegistry.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/ComponentRegistry.java
@@ -37,6 +37,7 @@
 import org.apache.felix.scr.impl.inject.ComponentMethods;
 import org.apache.felix.scr.impl.inject.internal.ComponentMethodsImpl;
 import org.apache.felix.scr.impl.logger.ComponentLogger;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.logger.ScrLogger;
 import org.apache.felix.scr.impl.manager.AbstractComponentManager;
 import org.apache.felix.scr.impl.manager.ComponentActivator;
@@ -54,7 +55,6 @@
 import org.osgi.service.component.ComponentConstants;
 import org.osgi.service.component.ComponentException;
 import org.osgi.service.component.runtime.ServiceComponentRuntime;
-import org.osgi.service.log.LogService;
 
 
 /**
@@ -257,7 +257,7 @@ final ComponentRegistryKey checkComponentName( final Bundle bundle, final String
      */
     final void registerComponentHolder( final ComponentRegistryKey key, ComponentHolder<?> componentHolder )
     {
-        m_logger.log(LogService.LOG_DEBUG,
+        m_logger.log(Level.DEBUG,
                 "Registering component with pid {0} for bundle {1}", null,
                 componentHolder.getComponentMetadata().getConfigurationPid(), key.getBundleId());
         synchronized ( m_componentHoldersByName )
@@ -416,7 +416,7 @@ final void unregisterComponentHolder( final ComponentRegistryKey key )
         }
 
         if (component != null) {
-            m_logger.log(LogService.LOG_DEBUG,
+            m_logger.log(Level.DEBUG,
                     "Unregistering component with pid {0} for bundle {1}", null,
                     component.getComponentMetadata().getConfigurationPid(), key.getBundleId());
             synchronized (m_componentHoldersByPid)
@@ -490,12 +490,12 @@ public <T> boolean enterCreate(final ServiceReference<T> serviceReference)
         List<ServiceReference<?>> info = circularInfos.get();
         if (info.contains(serviceReference))
         {
-            m_logger.log(LogService.LOG_ERROR,
+            m_logger.log(Level.ERROR,
                 "Circular reference detected trying to get service {0}\n stack of references: {1}", new Exception("stack trace"),
                 serviceReference, new Info(info));
             return true;
         }
-        m_logger.log(LogService.LOG_DEBUG,
+        m_logger.log(Level.DEBUG,
             "getService  {0}: stack of references: {1}", null,
             serviceReference, info);
         info.add(serviceReference);
@@ -577,7 +577,7 @@ public void run()
                     {
                         ((DependencyManager<?, T>)entry.getDm()).invokeBindMethodLate( serviceReference, entry.getTrackingCount() );
                     }
-                    m_logger.log(LogService.LOG_DEBUG,
+                    m_logger.log(Level.DEBUG,
                         "Ran {0} asynchronously", null, this);
                 }
 
@@ -588,7 +588,7 @@ public String toString()
                 }
 
             } ;
-            m_logger.log(LogService.LOG_DEBUG,
+            m_logger.log(Level.DEBUG,
                 "Scheduling runnable {0} asynchronously", null, runnable);
             actor.schedule( runnable );
         }
@@ -599,7 +599,7 @@ public synchronized <S, T> void registerMissingDependency( DependencyManager<S,
         //check that the service reference is from scr
         if ( serviceReference.getProperty( ComponentConstants.COMPONENT_NAME ) == null || serviceReference.getProperty( ComponentConstants.COMPONENT_ID ) == null )
         {
-            m_logger.log(LogService.LOG_DEBUG,
+            m_logger.log(Level.DEBUG,
                 "Missing service {0} for dependency manager {1} is not a DS service, cannot resolve circular dependency", null,
                 serviceReference, dependencyManager);
             return;
@@ -611,7 +611,7 @@ public synchronized <S, T> void registerMissingDependency( DependencyManager<S,
             m_missingDependencies.put( serviceReference, dependencyManagers );
         }
         dependencyManagers.add( new Entry<>( dependencyManager, trackingCount ) );
-        m_logger.log(LogService.LOG_DEBUG,
+        m_logger.log(Level.DEBUG,
             "Dependency managers {0} waiting for missing service {1}", null,
             dependencyManagers, serviceReference);
         }
@@ -768,7 +768,7 @@ public void run()
                     }, m_configuration.serviceChangecountTimeout());
             }
             catch (Exception e) {
-                m_logger.log(LogService.LOG_WARNING,
+                m_logger.log(Level.WARN,
                     "Service changecount Timer for {0} had a problem", e,
                     registration.getReference());
             }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/config/ScrConfigurationImpl.java b/scr/src/main/java/org/apache/felix/scr/impl/config/ScrConfigurationImpl.java
index 16a4f2074a..f504238adf 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/config/ScrConfigurationImpl.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/config/ScrConfigurationImpl.java
@@ -24,11 +24,11 @@
 
 import org.apache.felix.scr.impl.Activator;
 import org.apache.felix.scr.impl.ComponentCommands;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.manager.ScrConfiguration;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.Constants;
 import org.osgi.framework.ServiceRegistration;
-import org.osgi.service.log.LogService;
 import org.osgi.service.metatype.MetaTypeProvider;
 
 
@@ -73,7 +73,7 @@ public class ScrConfigurationImpl implements ScrConfiguration
 
     private final Activator activator;
 
-    private int logLevel;
+    private Level logLevel;
 
     private boolean factoryEnabled;
 
@@ -169,7 +169,7 @@ void configure( Dictionary<String, ?> config, boolean fromConfig )
                 {
                     if (this.bundleContext == null)
                     {
-                        logLevel = LogService.LOG_ERROR;
+                        logLevel = Level.ERROR;
                         factoryEnabled = false;
                         keepInstances = false;
                         infoAsService = false;
@@ -230,7 +230,7 @@ void configure( Dictionary<String, ?> config, boolean fromConfig )
      * @return
      */
     @Override
-    public int getLogLevel()
+    public Level getLogLevel()
     {
         return logLevel;
     }
@@ -297,7 +297,7 @@ private boolean getDefaultKeepInstances()
     }
 
 
-    private int getDefaultLogLevel()
+    private Level getDefaultLogLevel()
     {
         return getLogLevel( bundleContext.getProperty( PROP_LOGLEVEL ) );
     }
@@ -348,19 +348,21 @@ private boolean getDefaultCacheMetadata()
             bundleContext.getProperty(PROP_CACHE_METADATA));
     }
 
-    private int getLogLevel( final Object levelObject )
+    private Level getLogLevel(final Object levelObject)
     {
         if ( levelObject != null )
         {
             if ( levelObject instanceof Number )
             {
-                return ( ( Number ) levelObject ).intValue();
+                int ordinal = ((Number) levelObject).intValue();
+                return Level.values()[ordinal];
             }
 
             String levelString = levelObject.toString();
             try
             {
-                return Integer.parseInt( levelString );
+                int ordinal = Integer.parseInt(levelString);
+                return Level.values()[ordinal];
             }
             catch ( NumberFormatException nfe )
             {
@@ -369,35 +371,35 @@ private int getLogLevel( final Object levelObject )
 
             if ( LOG_LEVEL_DEBUG.equalsIgnoreCase( levelString ) )
             {
-                return LogService.LOG_DEBUG;
+                return Level.DEBUG;
             }
             else if ( LOG_LEVEL_INFO.equalsIgnoreCase( levelString ) )
             {
-                return LogService.LOG_INFO;
+                return Level.INFO;
             }
             else if ( LOG_LEVEL_WARN.equalsIgnoreCase( levelString ) )
             {
-                return LogService.LOG_WARNING;
+                return Level.WARN;
             }
             else if ( LOG_LEVEL_ERROR.equalsIgnoreCase( levelString ) )
             {
-                return LogService.LOG_ERROR;
+                return Level.ERROR;
             }
         }
 
         // check ds.showtrace property
         if ( VALUE_TRUE.equalsIgnoreCase( bundleContext.getProperty( PROP_SHOWTRACE ) ) )
         {
-            return LogService.LOG_DEBUG;
+            return Level.DEBUG;
         }
 
         // next check ds.showerrors property
         if ( "false".equalsIgnoreCase( bundleContext.getProperty( PROP_SHOWERRORS ) ) )
         {
-            return -1; // no logging at all !!
+            return Level.AUDIT; // no logging at all !!
         }
 
         // default log level (errors only)
-        return LogService.LOG_ERROR;
+        return Level.ERROR;
     }
 }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/helper/ConfigAdminTracker.java b/scr/src/main/java/org/apache/felix/scr/impl/helper/ConfigAdminTracker.java
index 89e432720a..577823dac2 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/helper/ConfigAdminTracker.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/helper/ConfigAdminTracker.java
@@ -18,11 +18,11 @@
  */
 package org.apache.felix.scr.impl.helper;
 
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.manager.ComponentActivator;
 import org.apache.felix.scr.impl.manager.RegionConfigurationSupport;
 import org.osgi.framework.ServiceReference;
 import org.osgi.service.cm.ConfigurationAdmin;
-import org.osgi.service.log.LogService;
 import org.osgi.util.tracker.ServiceTracker;
 import org.osgi.util.tracker.ServiceTrackerCustomizer;
 
@@ -57,7 +57,7 @@ public RegionConfigurationSupport addingService(ServiceReference<ConfigurationAd
                     }
                     catch ( final Exception ex)
                     {
-                        componentActivator.getLogger().log(LogService.LOG_ERROR,
+                            componentActivator.getLogger().log(Level.ERROR,
                                 "Configuration admin API visible to bundle " + componentActivator.getBundleContext().getBundle() +
                                 " is not the same as the Configuration Admin API visible to the SCR implementation.", ex);
                     }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/inject/ValueUtils.java b/scr/src/main/java/org/apache/felix/scr/impl/inject/ValueUtils.java
index 602bf249f9..2e29a3cee3 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/inject/ValueUtils.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/inject/ValueUtils.java
@@ -28,10 +28,10 @@
 import org.apache.felix.scr.impl.inject.internal.Annotations;
 import org.apache.felix.scr.impl.inject.internal.ClassUtils;
 import org.apache.felix.scr.impl.logger.ComponentLogger;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.ReferenceMetadata;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.ServiceReference;
-import org.osgi.service.log.LogService;
 
 /**
  * Utility methods for handling references and activation
@@ -152,12 +152,15 @@ else if ( typeClass.getName().equals(ClassUtils.FORMATTER_LOGGER_CLASS) && metad
             {
                 if ( field != null )
                 {
-                    logger.log( LogService.LOG_ERROR, "Field {0} in class {1} has unsupported type {2}", null,
+                    logger.log(Level.ERROR,
+                        "Field {0} in class {1} has unsupported type {2}", null,
                             metadata.getField(), componentClass, typeClass.getName() );
                 }
                 else
                 {
-                    logger.log( LogService.LOG_ERROR, "Constructor argument {0} in class {1} has unsupported type {2}", null,
+                    logger.log(Level.ERROR,
+                        "Constructor argument {0} in class {1} has unsupported type {2}",
+                        null,
                             metadata.getParameterIndex(), componentClass, typeClass.getName() );
                 }
                 valueType = ValueType.ignore;
@@ -165,7 +168,9 @@ else if ( typeClass.getName().equals(ClassUtils.FORMATTER_LOGGER_CLASS) && metad
 
             // if the field is dynamic, it has to be volatile (field is ignored, case logged) (112.3.8.1)
             if ( field != null && !metadata.isStatic() && !Modifier.isVolatile(field.getModifiers()) ) {
-                logger.log( LogService.LOG_ERROR, "Field {0} in class {1} must be declared volatile to handle a dynamic reference", null,
+                logger.log(Level.ERROR,
+                    "Field {0} in class {1} must be declared volatile to handle a dynamic reference",
+                    null,
                         metadata.getField(), componentClass );
                 valueType = ValueType.ignore;
             }
@@ -173,7 +178,8 @@ else if ( typeClass.getName().equals(ClassUtils.FORMATTER_LOGGER_CLASS) && metad
             // the field must not be final (field is ignored, case logged) (112.3.8.1)
             if ( field != null && Modifier.isFinal(field.getModifiers()) )
             {
-                logger.log( LogService.LOG_ERROR, "Field {0} in class {1} must not be declared as final", null,
+                logger.log(Level.ERROR,
+                    "Field {0} in class {1} must not be declared as final", null,
                         metadata.getField(), componentClass );
                 valueType = ValueType.ignore;
             }
@@ -207,12 +213,15 @@ else if ( ReferenceMetadata.FIELD_VALUE_TYPE_TUPLE.equals(colType) )
             {
                 if ( field != null )
                 {
-                    logger.log( LogService.LOG_ERROR, "Field {0} in class {1} has unsupported type {2}", null,
+                    logger.log(Level.ERROR,
+                        "Field {0} in class {1} has unsupported type {2}", null,
                             metadata.getField(), componentClass, typeClass.getName() );
                 }
                 else
                 {
-                    logger.log( LogService.LOG_ERROR, "Constructor argument {0} in class {1} has unsupported type {2}", null,
+                    logger.log(Level.ERROR,
+                        "Constructor argument {0} in class {1} has unsupported type {2}",
+                        null,
                             metadata.getParameterIndex(), componentClass, typeClass.getName() );
                 }
                 valueType = ValueType.ignore;
@@ -224,7 +233,9 @@ else if ( ReferenceMetadata.FIELD_VALUE_TYPE_TUPLE.equals(colType) )
                 // if the field is dynamic wit has to be volatile (field is ignored, case logged) (112.3.8.1)
                 if ( !metadata.isStatic() && !Modifier.isVolatile(field.getModifiers()) )
                 {
-                    logger.log( LogService.LOG_ERROR, "Field {0} in class {1} must be declared volatile to handle a dynamic reference", null,
+                    logger.log(Level.ERROR,
+                        "Field {0} in class {1} must be declared volatile to handle a dynamic reference",
+                        null,
                             metadata.getField(), componentClass );
                     valueType = ValueType.ignore;
                 }
@@ -233,7 +244,8 @@ else if ( ReferenceMetadata.FIELD_VALUE_TYPE_TUPLE.equals(colType) )
                 //                   only collection and list allowed
                 if ( typeClass != ClassUtils.LIST_CLASS && typeClass != ClassUtils.COLLECTION_CLASS )
                 {
-                    logger.log( LogService.LOG_ERROR, "Field {0} in class {1} has unsupported type {2}."+
+                    logger.log(Level.ERROR,
+                        "Field {0} in class {1} has unsupported type {2}." +
                             " It must be one of java.util.Collection or java.util.List.", null,
                             metadata.getField(), componentClass, typeClass.getName() );
                     valueType = ValueType.ignore;
@@ -241,7 +253,8 @@ else if ( ReferenceMetadata.FIELD_VALUE_TYPE_TUPLE.equals(colType) )
                 }
                 if ( Modifier.isFinal(field.getModifiers()) )
                 {
-                    logger.log( LogService.LOG_ERROR, "Field {0} in class {1} must not be declared as final", null,
+                    logger.log(Level.ERROR,
+                        "Field {0} in class {1} must not be declared as final", null,
                             metadata.getField(), componentClass );
                     valueType = ValueType.ignore;
                 }
@@ -250,7 +263,9 @@ else if ( ReferenceMetadata.FIELD_VALUE_TYPE_TUPLE.equals(colType) )
         // static references only allowed for replace strategy
         if ( field != null && metadata.isStatic() && !metadata.isReplace() )
         {
-            logger.log( LogService.LOG_ERROR, "Update strategy for field {0} in class {1} only allowed for non static field references.", null,
+            logger.log(Level.ERROR,
+                "Update strategy for field {0} in class {1} only allowed for non static field references.",
+                null,
                     metadata.getField(), componentClass );
             valueType = ValueType.ignore;
         }
@@ -327,7 +342,8 @@ private static Object getLogger(String componentType,
             } catch (final NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
                 error = e;
             }
-            componentContext.getLogger().log( LogService.LOG_ERROR, "Unexpected error while trying to get logger.", null, error );
+            componentContext.getLogger().log(Level.ERROR,
+                "Unexpected error while trying to get logger.", null, error);
         }
         return null;
     }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/inject/field/FieldHandler.java b/scr/src/main/java/org/apache/felix/scr/impl/inject/field/FieldHandler.java
index d82d693a9a..49f4964a1a 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/inject/field/FieldHandler.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/inject/field/FieldHandler.java
@@ -39,9 +39,10 @@
 import org.apache.felix.scr.impl.inject.field.FieldUtils.FieldSearchResult;
 import org.apache.felix.scr.impl.inject.internal.ClassUtils;
 import org.apache.felix.scr.impl.logger.ComponentLogger;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.ReferenceMetadata;
 import org.osgi.framework.BundleContext;
-import org.osgi.service.log.LogService;
+import org.osgi.service.log.LogLevel;
 
 /**
  * Handler for field references
@@ -111,14 +112,17 @@ private boolean initField(final Object componentInstance,
                     {
                         if ( Modifier.isFinal(this.field.getModifiers()) )
                         {
-                            logger.log( LogService.LOG_ERROR, "Field {0} in class {1} must not be declared as final", null,
+                            logger.log(Level.ERROR,
+                                "Field {0} in class {1} must not be declared as final",
+                                null,
                                     metadata.getField(), this.componentClass );
                             valueType = ValueType.ignore;
                             return true;
                         }
                         if ( fieldType != ClassUtils.LIST_CLASS && fieldType != ClassUtils.COLLECTION_CLASS )
                         {
-                            logger.log( LogService.LOG_ERROR, "Field {0} in class {1} has unsupported type {2}."+
+                            logger.log(Level.ERROR,
+                                "Field {0} in class {1} has unsupported type {2}." +
                                 " It must be one of java.util.Collection or java.util.List.", null,
                                 metadata.getField(), this.componentClass, fieldType.getName() );
                             valueType = ValueType.ignore;
@@ -149,7 +153,7 @@ private boolean initField(final Object componentInstance,
         {
             valueType = ValueType.ignore;
 
-            logger.log( LogService.LOG_ERROR, "Field {0} in class {1} can't be initialized.",
+            logger.log(Level.ERROR, "Field {0} in class {1} can't be initialized.",
                     ite, metadata.getField(), this.componentClass );
             return false;
 
@@ -353,7 +357,8 @@ private static class NotResolved implements State
 
         private void resolve(final FieldHandler handler, final ComponentLogger logger)
         {
-            logger.log( LogService.LOG_DEBUG, "getting field: {0}", null, handler.metadata.getField() );
+            logger.log(Level.DEBUG, "getting field: {0}", null,
+                handler.metadata.getField());
 
             // resolve the field
         	    final FieldUtils.FieldSearchResult result = FieldUtils.searchField( handler.componentClass, handler.metadata.getField(), logger );
@@ -392,7 +397,8 @@ public MethodResult invoke( final FieldHandler handler,
                 final Object componentInstance,
                 final BindParameters rawParameter)
         {
-            rawParameter.getComponentContext().getLogger().log( LogService.LOG_ERROR, "Field [{0}] not found", null,
+            rawParameter.getComponentContext().getLogger().log(Level.ERROR,
+                "Field [{0}] not found", null,
                 handler.metadata.getField() );
             return null;
         }
@@ -441,7 +447,7 @@ synchronized void setSearchResult(FieldSearchResult result, ComponentLogger logg
             valueType = null;
             state = NotFound.INSTANCE;
             // TODO - will component really fail?
-            logger.log(LogService.LOG_ERROR, "Field [{0}] not found; Component will fail",
+            logger.log(Level.ERROR, "Field [{0}] not found; Component will fail",
                     null, metadata.getField());
         }
         else
@@ -457,7 +463,7 @@ synchronized void setSearchResult(FieldSearchResult result, ComponentLogger logg
                     result.field.getType(), result.field, logger);
             }
             state = Resolved.INSTANCE;
-            logger.log(LogService.LOG_DEBUG, "Found field: {0}",
+            logger.log(Level.DEBUG, "Found field: {0}",
                 null, result.field );
         }
     }
@@ -495,7 +501,8 @@ public <S, T> MethodResult invoke(final Object componentInstance,
             }
             catch ( final InvocationTargetException ite )
             {
-                rawParameter.getComponentContext().getLogger().log( LogService.LOG_ERROR, "The {0} field has thrown an exception", null,
+                rawParameter.getComponentContext().getLogger().log(Level.ERROR,
+                    "The {0} field has thrown an exception", null,
                     handler.metadata.getField() );
             }
 
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/inject/field/FieldUtils.java b/scr/src/main/java/org/apache/felix/scr/impl/inject/field/FieldUtils.java
index e09b033384..3d80494760 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/inject/field/FieldUtils.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/inject/field/FieldUtils.java
@@ -26,7 +26,7 @@
 
 import org.apache.felix.scr.impl.inject.internal.ClassUtils;
 import org.apache.felix.scr.impl.logger.ComponentLogger;
-import org.osgi.service.log.LogService;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 
 /**
  * Utility methods for handling field injection.
@@ -79,7 +79,7 @@ public static FieldSearchResult searchField( final Class<?> componentClass,
         while (true)
         {
 
-            logger.log( LogService.LOG_DEBUG,
+            logger.log(Level.DEBUG,
                 "Locating field {0} in class {1}", null, fieldName, theClass.getName() );
 
             try
@@ -92,7 +92,8 @@ public static FieldSearchResult searchField( final Class<?> componentClass,
             }
             catch ( final InvocationTargetException ex )
             {
-                logger.log( LogService.LOG_ERROR, "Field {0} cannot be found in component class {1}. The field will be ignored.",
+                logger.log(Level.ERROR,
+                    "Field {0} cannot be found in component class {1}. The field will be ignored.",
                         ex.getTargetException(),
                         fieldName, componentClass.getName()  );
                 return null;
@@ -116,7 +117,9 @@ public static FieldSearchResult searchField( final Class<?> componentClass,
         }
 
         // nothing found
-        logger.log( LogService.LOG_ERROR, "Field {0} cannot be found in component class {1}. The field will be ignored.", null,
+        logger.log(Level.ERROR,
+            "Field {0} cannot be found in component class {1}. The field will be ignored.",
+            null,
                       fieldName, componentClass.getName() );
         return new FieldSearchResult(null, false);
     }
@@ -160,9 +163,10 @@ private static FieldSearchResult getField( final Class<?> componentClass,
         {
             // thrown if no field is declared with the given name and
             // parameters
-            if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+            if (logger.isLogEnabled(Level.DEBUG))
             {
-                logger.log( LogService.LOG_DEBUG, "Declared Field {0}.{1} not found", null, targetClass.getName(), fieldName );
+                logger.log(Level.DEBUG, "Declared Field {0}.{1} not found", null,
+                    targetClass.getName(), fieldName);
             }
         }
         catch ( Throwable throwable )
@@ -212,7 +216,8 @@ private static FieldSearchResult accept( final Class<?> componentClass,
         // static fields
         if ( Modifier.isStatic( mod ) )
         {
-            logger.log( LogService.LOG_ERROR, "Field {0} must not be static", null, toString(componentClass, field) );
+            logger.log(Level.ERROR, "Field {0} must not be static", null,
+                toString(componentClass, field));
             return new FieldSearchResult(field, false);
         }
 
@@ -244,7 +249,7 @@ private static FieldSearchResult accept( final Class<?> componentClass,
 
         // else don't accept
         // the method would fit the requirements but is not acceptable
-        logger.log( LogService.LOG_ERROR,
+        logger.log(Level.ERROR,
                 "findField: Suitable but non-accessible field {0}", null, toString(componentClass, field));
         return new FieldSearchResult(field, false);
     }
@@ -300,11 +305,11 @@ public static void setField( final Field f,
         }
         catch ( final IllegalArgumentException iae )
         {
-            logger.log( LogService.LOG_ERROR, "Field {0} can't be set", iae, f.getName() );
+            logger.log(Level.ERROR, "Field {0} can't be set", iae, f.getName());
         }
         catch ( final IllegalAccessException iae )
         {
-            logger.log( LogService.LOG_ERROR, "Field {0} can't be set", iae, f.getName() );
+            logger.log(Level.ERROR, "Field {0} can't be set", iae, f.getName());
         }
     }
 }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ClassUtils.java b/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ClassUtils.java
index e3f909957f..28a9a3a651 100755
--- a/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ClassUtils.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ClassUtils.java
@@ -23,11 +23,11 @@
 import java.util.Map;
 
 import org.apache.felix.scr.impl.logger.ComponentLogger;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.ServiceReference;
 import org.osgi.service.component.ComponentContext;
 import org.osgi.service.component.ComponentServiceObjects;
-import org.osgi.service.log.LogService;
 import org.osgi.service.packageadmin.ExportedPackage;
 import org.osgi.service.packageadmin.PackageAdmin;
 import org.osgi.util.tracker.ServiceTracker;
@@ -85,10 +85,10 @@ public static Class<?> getClassFromComponentClassLoader(
             final String className,
             final ComponentLogger logger )
     {
-        if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+        if (logger.isLogEnabled(Level.DEBUG))
         {
             logger.log(
-                LogService.LOG_DEBUG,
+                Level.DEBUG,
                 "getReferenceClass: Looking for interface class {0} through loader of {1}", null,
                     className, componentClass.getName() );
         }
@@ -104,9 +104,9 @@ public static Class<?> getClassFromComponentClassLoader(
             }
 
             final Class<?> referenceClass = loader.loadClass( className );
-            if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+            if (logger.isLogEnabled(Level.DEBUG))
             {
-                logger.log( LogService.LOG_DEBUG,
+                logger.log(Level.DEBUG,
                     "getParameterClass: Found class {0}", null, referenceClass.getName() );
             }
             return referenceClass;
@@ -117,9 +117,9 @@ public static Class<?> getClassFromComponentClassLoader(
             // super class so we try this class next
         }
 
-        if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+        if (logger.isLogEnabled(Level.DEBUG))
         {
-            logger.log( LogService.LOG_DEBUG,
+            logger.log(Level.DEBUG,
                 "getParameterClass: Not found through component class, using PackageAdmin service", null );
         }
 
@@ -136,18 +136,18 @@ public static Class<?> getClassFromComponentClassLoader(
                 {
                     try
                     {
-                        if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+                        if (logger.isLogEnabled(Level.DEBUG))
                         {
                             logger.log(
-                                LogService.LOG_DEBUG,
+                                Level.DEBUG,
                                 "getParameterClass: Checking Bundle {0}/{1}",
                                 null, pkg[i].getExportingBundle().getSymbolicName(), pkg[i].getExportingBundle().getBundleId() );
                         }
 
                         Class<?> referenceClass = pkg[i].getExportingBundle().loadClass( className );
-                        if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+                        if (logger.isLogEnabled(Level.DEBUG))
                         {
-                            logger.log( LogService.LOG_DEBUG,
+                            logger.log(Level.DEBUG,
                                     "getParameterClass: Found class {0}", null,referenceClass.getName() );
                         }
                         return referenceClass;
@@ -158,23 +158,23 @@ public static Class<?> getClassFromComponentClassLoader(
                     }
                 }
             }
-            else if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+            else if (logger.isLogEnabled(Level.DEBUG))
             {
-                logger.log( LogService.LOG_DEBUG,
+                logger.log(Level.DEBUG,
                     "getParameterClass: No bundles exporting package {0} found", null, referenceClassPackage );
             }
         }
-        else if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+        else if (logger.isLogEnabled(Level.DEBUG))
         {
-            logger.log( LogService.LOG_DEBUG,
+            logger.log(Level.DEBUG,
                 "getParameterClass: PackageAdmin service not available, cannot find class", null );
         }
 
         // class cannot be found, neither through the component nor from an
         // export, so we fall back to assuming Object
-        if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+        if (logger.isLogEnabled(Level.DEBUG))
         {
-            logger.log( LogService.LOG_DEBUG,
+            logger.log(Level.DEBUG,
                 "getParameterClass: No class found, falling back to class Object", null );
         }
         return OBJECT_CLASS;
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ComponentConstructorImpl.java b/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ComponentConstructorImpl.java
index 673a7060b2..2ad3248f52 100755
--- a/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ComponentConstructorImpl.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/inject/internal/ComponentConstructorImpl.java
@@ -34,9 +34,9 @@
 import org.apache.felix.scr.impl.inject.ValueUtils.ValueType;
 import org.apache.felix.scr.impl.inject.field.FieldUtils;
 import org.apache.felix.scr.impl.logger.ComponentLogger;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.ComponentMetadata;
 import org.apache.felix.scr.impl.metadata.ReferenceMetadata;
-import org.osgi.service.log.LogService;
 
 /**
  * This implementation is used to construct a component instance object,
@@ -68,14 +68,14 @@ public ComponentConstructorImpl(final ComponentMetadata componentMetadata,
                 {
                     // if the index (starting at 0) is equal or higher than the number of constructor arguments
                     // we log an error and ignore the reference
-                    logger.log(LogService.LOG_ERROR,
+                    logger.log(Level.ERROR,
                             "Ignoring reference {0} for constructor injection. Parameter index is too high.", null,
                             refMetadata.getName() );
                 }
                 else if ( !refMetadata.isStatic() )
                 {
                     // if the reference is dynamic, we log an error and ignore the reference
-                    logger.log(LogService.LOG_ERROR,
+                    logger.log(Level.ERROR,
                             "Ignoring reference {0} for constructor injection. Reference is dynamic.", null,
                             refMetadata.getName() );
                 }
@@ -101,7 +101,7 @@ else if ( !refMetadata.isStatic() )
             if ( c.getParameterTypes().length == componentMetadata.getNumberOfConstructorParameters() )
             {
                 final Constructor<S> check = (Constructor<S>) c;
-                logger.log(LogService.LOG_DEBUG,
+                logger.log(Level.DEBUG,
                         "Checking constructor {0}", null,
                         check );
                 // check argument types
@@ -119,7 +119,7 @@ else if ( !refMetadata.isStatic() )
                             foundTypes[i] = ValueUtils.getValueType(argTypes[i]);
                             if ( foundTypes[i] == ValueType.ignore )
                             {
-                                logger.log(LogService.LOG_DEBUG,
+                                logger.log(Level.DEBUG,
                                         "Constructor argument type {0} not supported by constructor injection: {1}", null,
                                         i, argTypes[i] );
                             }
@@ -144,7 +144,7 @@ else if ( !refMetadata.isStatic() )
                             {
                                 if ( refs.size() > 1 )
                                 {
-                                    logger.log(LogService.LOG_ERROR,
+                                    logger.log(Level.ERROR,
                                             "Several references for constructor injection of parameter {0}. Only {1} will be used out of: {2}.", null,
                                             i, foundRefs[i].getName(), getNames(refs) );
                                 }
@@ -215,13 +215,13 @@ else if ( !refMetadata.isStatic() )
 
         if ( constructor == null )
         {
-            logger.log(LogService.LOG_ERROR,
+            logger.log(Level.ERROR,
                     "Constructor with {0} arguments not found. Component will fail.", null,
                     componentMetadata.getNumberOfConstructorParameters() );
         }
         else
         {
-            logger.log(LogService.LOG_DEBUG,
+            logger.log(Level.DEBUG,
                     "Found constructor with {0} arguments : {1}", null,
                     componentMetadata.getNumberOfConstructorParameters(), found );
         }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/inject/methods/ActivateMethod.java b/scr/src/main/java/org/apache/felix/scr/impl/inject/methods/ActivateMethod.java
index 755b0dcf3d..30e2d497fe 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/inject/methods/ActivateMethod.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/inject/methods/ActivateMethod.java
@@ -34,8 +34,8 @@
 import org.apache.felix.scr.impl.inject.internal.Annotations;
 import org.apache.felix.scr.impl.inject.internal.ClassUtils;
 import org.apache.felix.scr.impl.logger.ComponentLogger;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.DSVersion;
-import org.osgi.service.log.LogService;
 
 
 public class ActivateMethod extends BaseMethod<ActivatorParameter, Object> implements LifecycleMethod
@@ -77,7 +77,7 @@ protected MethodInfo<Object> doFindMethod( final Class<?> targetClass,
         }
         catch ( SuitableMethodNotAccessibleException thrown )
         {
-            logger.log( LogService.LOG_DEBUG, "SuitableMethodNotAccessible", thrown );
+            logger.log(Level.DEBUG, "SuitableMethodNotAccessible", thrown);
             suitableMethodNotAccessible = true;
         }
         if (getDSVersion().isDS11())
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/inject/methods/BaseMethod.java b/scr/src/main/java/org/apache/felix/scr/impl/inject/methods/BaseMethod.java
index 146cac2dff..556df8283d 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/inject/methods/BaseMethod.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/inject/methods/BaseMethod.java
@@ -31,8 +31,8 @@
 import org.apache.felix.scr.impl.inject.MethodResult;
 import org.apache.felix.scr.impl.inject.internal.ClassUtils;
 import org.apache.felix.scr.impl.logger.ComponentLogger;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.DSVersion;
-import org.osgi.service.log.LogService;
 
 
 /**
@@ -111,20 +111,20 @@ synchronized void setMethod(MethodInfo<T> methodInfo, ComponentLogger logger)
         {
             setTypes(methodInfo.getTypes());
             m_state = Resolved.INSTANCE;
-            logger.log( LogService.LOG_DEBUG, "Found {0} method: {1}", null,
+            logger.log(Level.DEBUG, "Found {0} method: {1}", null,
                     getMethodNamePrefix(), m_method );
         }
         else if ( m_methodRequired )
         {
             m_state = NotFound.INSTANCE;
-            logger.log(LogService.LOG_ERROR, "{0} method [{1}] not found; Component will fail",
+            logger.log(Level.ERROR, "{0} method [{1}] not found; Component will fail",
                     null,
                     getMethodNamePrefix(), getMethodName());
         }
         else
         {
             // optional method not found, log as DEBUG and ignore
-            logger.log( LogService.LOG_DEBUG, "{0} method [{1}] not found, ignoring", null,
+            logger.log(Level.DEBUG, "{0} method [{1}] not found, ignoring", null,
                     getMethodNamePrefix(), getMethodName() );
             m_state = NotApplicable.INSTANCE;
         }
@@ -162,9 +162,9 @@ private MethodInfo<T> findMethod(final ComponentLogger logger) throws Invocation
         while (true)
         {
 
-            if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+            if (logger.isLogEnabled(Level.DEBUG))
             {
-                logger.log( LogService.LOG_DEBUG,
+                logger.log(Level.DEBUG,
                         "Locating method " + getMethodName() + " in class " + theClass.getName(), null );
             }
 
@@ -181,7 +181,7 @@ private MethodInfo<T> findMethod(final ComponentLogger logger) throws Invocation
             catch ( SuitableMethodNotAccessibleException ex )
             {
                 // log and return null
-                logger.log( LogService.LOG_ERROR,
+                logger.log(Level.ERROR,
                         "findMethod: Suitable but non-accessible method {0} found in class {1}, subclass of {2}", null,
                                 getMethodName(), theClass.getName(), targetClass.getName() );
                 break;
@@ -235,25 +235,29 @@ private MethodResult invokeMethod(final Object componentInstance, final P rawPar
             if ( componentInstance != null )
             {
                 final Object[] params = getParameters(m_method, rawParameter);
-                if (logger.isLogEnabled(LogService.LOG_DEBUG)) {
-                    logger.log(LogService.LOG_DEBUG, "invoking {0}: {1}: parameters {2}", null, getMethodNamePrefix(),
+                if (logger.isLogEnabled(Level.DEBUG))
+                {
+                    logger.log(Level.DEBUG, "invoking {0}: {1}: parameters {2}", null,
+                        getMethodNamePrefix(),
                             getMethodName(), Arrays.asList(getParametersForLogging(params)));
                 }
                 final Object result = m_method.invoke(componentInstance, params);
-                logger.log(LogService.LOG_DEBUG, "invoked {0}: {1}", null,
+                logger.log(Level.DEBUG, "invoked {0}: {1}", null,
                         getMethodNamePrefix(), getMethodName() );
                 return new MethodResult((m_method.getReturnType() != Void.TYPE), (Map<String, Object>) result);
             }
             else
             {
-                rawParameter.getComponentContext().getLogger().log( LogService.LOG_WARNING, "Method {0}: {1} cannot be called on null object",
+                rawParameter.getComponentContext().getLogger().log(Level.WARN,
+                    "Method {0}: {1} cannot be called on null object",
                         null,
                                 getMethodNamePrefix(), getMethodName() );
             }
         }
         catch ( IllegalStateException ise )
         {
-            rawParameter.getComponentContext().getLogger().log( LogService.LOG_DEBUG, ise.getMessage(), null );
+            rawParameter.getComponentContext().getLogger().log(Level.DEBUG,
+                ise.getMessage(), null);
             return null;
         }
         catch ( IllegalAccessException ex )
@@ -261,7 +265,8 @@ private MethodResult invokeMethod(final Object componentInstance, final P rawPar
             // 112.3.1 If the method is not is not declared protected or
             // public, SCR must log an error message with the log service,
             // if present, and ignore the method
-            rawParameter.getComponentContext().getLogger().log( LogService.LOG_DEBUG, "Method {0} cannot be called", ex,
+            rawParameter.getComponentContext().getLogger().log(Level.DEBUG,
+                "Method {0} cannot be called", ex,
                     getMethodName() );
         }
         catch ( InvocationTargetException ex )
@@ -352,10 +357,10 @@ protected String getMethodNamePrefix()
         {
             // thrown if no method is declared with the given name and
             // parameters
-            if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+            if (logger.isLogEnabled(Level.DEBUG))
             {
                 String argList = ( parameterTypes != null ) ? Arrays.asList( parameterTypes ).toString() : "";
-                logger.log( LogService.LOG_DEBUG, "Declared Method {0}.{1}({2}) not found", null,
+                logger.log(Level.DEBUG, "Declared Method {0}.{1}({2}) not found", null,
                         clazz.getName(), name, argList );
             }
         }
@@ -364,7 +369,7 @@ protected String getMethodNamePrefix()
             // may be thrown if a method would be found but the signature
             // contains throws declaration for an exception which cannot
             // be loaded
-            if ( logger.isLogEnabled( LogService.LOG_WARNING ) )
+            if (logger.isLogEnabled(Level.WARN))
             {
                 StringBuilder buf = new StringBuilder();
                 buf.append( "Failure loooking up method " ).append( name ).append( '(' );
@@ -377,7 +382,7 @@ protected String getMethodNamePrefix()
                     }
                 }
                 buf.append( ") in class class " ).append( clazz.getName() ).append( ". Assuming no such method." );
-                logger.log( LogService.LOG_WARNING, buf.toString(), cdfe );
+                logger.log(Level.WARN, buf.toString(), cdfe);
             }
         }
         catch ( SuitableMethodNotAccessibleException e)
@@ -525,7 +530,8 @@ public MethodResult invoke( final Object componentInstance, final P rawParameter
         }
         catch ( InvocationTargetException ite )
         {
-            rawParameter.getComponentContext().getLogger().log( LogService.LOG_ERROR, "The {0} method has thrown an exception", ite.getCause(),
+            rawParameter.getComponentContext().getLogger().log(Level.ERROR,
+                "The {0} method has thrown an exception", ite.getCause(),
                     getMethodName() );
             if ( methodCallFailureResult != null && methodCallFailureResult.getResult() != null )
             {
@@ -606,7 +612,7 @@ private static class NotResolved implements State
 
         private <P extends BaseParameter, T> void resolve( final BaseMethod<P, T> baseMethod, ComponentLogger logger )
         {
-            logger.log( LogService.LOG_DEBUG, "getting {0}: {1}", null,
+            logger.log(Level.DEBUG, "getting {0}: {1}", null,
                     baseMethod.getMethodNamePrefix(), baseMethod.getMethodName() );
 
             // resolve the method
@@ -617,7 +623,7 @@ private <P extends BaseParameter, T> void resolve( final BaseMethod<P, T> baseMe
             }
             catch ( InvocationTargetException ex )
             {
-                logger.log( LogService.LOG_WARNING, "{0} cannot be found", ex.getTargetException(),
+                logger.log(Level.WARN, "{0} cannot be found", ex.getTargetException(),
                         baseMethod.getMethodName() );
             }
 
@@ -653,7 +659,8 @@ public <P extends BaseParameter, T> MethodResult invoke( final BaseMethod<P, T>
             // 112.3.1 If the method is not found , SCR must log an error
             // message with the log service, if present, and ignore the
             // method
-            rawParameter.getComponentContext().getLogger().log( LogService.LOG_ERROR, "{0} method [{1}] not found", null,
+            rawParameter.getComponentContext().getLogger().log(Level.ERROR,
+                "{0} method [{1}] not found", null,
                     baseMethod.getMethodNamePrefix(), baseMethod.getMethodName() );
             return null;
         }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/inject/methods/BindMethod.java b/scr/src/main/java/org/apache/felix/scr/impl/inject/methods/BindMethod.java
index b06649a4c2..38ef0c812f 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/inject/methods/BindMethod.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/inject/methods/BindMethod.java
@@ -31,9 +31,9 @@
 import org.apache.felix.scr.impl.inject.ValueUtils;
 import org.apache.felix.scr.impl.inject.internal.ClassUtils;
 import org.apache.felix.scr.impl.logger.ComponentLogger;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.DSVersion;
 import org.osgi.framework.BundleContext;
-import org.osgi.service.log.LogService;
 
 
 /**
@@ -96,9 +96,9 @@ protected MethodInfo<List<ValueUtils.ValueType>> doFindMethod( final Class<?> ta
         // flag indicating a suitable but inaccessible method has been found
         boolean suitableMethodNotAccessible = false;
 
-        if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+        if (logger.isLogEnabled(Level.DEBUG))
         {
-            logger.log( LogService.LOG_DEBUG,
+            logger.log(Level.DEBUG,
                     "doFindMethod: Looking for method " + targetClass.getName() + "." + getMethodName(), null );
         }
 
@@ -109,9 +109,10 @@ protected MethodInfo<List<ValueUtils.ValueType>> doFindMethod( final Class<?> ta
             method = getServiceReferenceMethod( targetClass, acceptPrivate, acceptPackage, logger );
             if ( method != null )
             {
-                if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+                if (logger.isLogEnabled(Level.DEBUG))
                 {
-                    logger.log( LogService.LOG_DEBUG, "doFindMethod: Found Method " + method, null );
+                    logger.log(Level.DEBUG, "doFindMethod: Found Method " + method,
+                        null);
                 }
                 return new MethodInfo<>(method, Collections.singletonList(ValueUtils.ValueType.ref_serviceReference));
             }
@@ -129,9 +130,10 @@ protected MethodInfo<List<ValueUtils.ValueType>> doFindMethod( final Class<?> ta
                 method = getComponentObjectsMethod( targetClass, acceptPrivate, acceptPackage, logger );
                 if ( method != null )
                 {
-                    if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+                    if (logger.isLogEnabled(Level.DEBUG))
                     {
-                        logger.log( LogService.LOG_DEBUG, "doFindMethod: Found Method " + method, null );
+                        logger.log(Level.DEBUG, "doFindMethod: Found Method " + method,
+                            null);
                     }
                     return new MethodInfo<>(method, Collections.singletonList(ValueUtils.ValueType.ref_serviceObjects));
                 }
@@ -147,10 +149,10 @@ protected MethodInfo<List<ValueUtils.ValueType>> doFindMethod( final Class<?> ta
         if ( parameterClass != null )
         {
 
-            if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+            if (logger.isLogEnabled(Level.DEBUG))
             {
                 logger.log(
-                        LogService.LOG_DEBUG,
+                    Level.DEBUG,
                         "doFindMethod: No method taking ServiceReference found, checking method taking "
                                 + parameterClass.getName(), null );
             }
@@ -161,9 +163,10 @@ protected MethodInfo<List<ValueUtils.ValueType>> doFindMethod( final Class<?> ta
                 method = getServiceObjectMethod( targetClass, parameterClass, acceptPrivate, acceptPackage, logger );
                 if ( method != null )
                 {
-                    if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+                    if (logger.isLogEnabled(Level.DEBUG))
                     {
-                        logger.log( LogService.LOG_DEBUG, "doFindMethod: Found Method " + method, null );
+                        logger.log(Level.DEBUG, "doFindMethod: Found Method " + method,
+                            null);
                     }
                     return new MethodInfo<>(method,
                         Collections.singletonList(ValueUtils.ValueType.ref_serviceType));
@@ -180,9 +183,10 @@ protected MethodInfo<List<ValueUtils.ValueType>> doFindMethod( final Class<?> ta
                 method = getServiceObjectAssignableMethod( targetClass, parameterClass, acceptPrivate, acceptPackage, logger );
                 if ( method != null )
                 {
-                    if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+                    if (logger.isLogEnabled(Level.DEBUG))
                     {
-                        logger.log( LogService.LOG_DEBUG, "doFindMethod: Found Method " + method, null );
+                        logger.log(Level.DEBUG, "doFindMethod: Found Method " + method,
+                            null);
                     }
                     return new MethodInfo<>(method,
                         Collections.singletonList(ValueUtils.ValueType.ref_serviceType));
@@ -201,9 +205,10 @@ protected MethodInfo<List<ValueUtils.ValueType>> doFindMethod( final Class<?> ta
                     method = getMapMethod( targetClass, parameterClass, acceptPrivate, acceptPackage, logger );
                     if ( method != null )
                     {
-                        if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+                        if (logger.isLogEnabled(Level.DEBUG))
                         {
-                            logger.log( LogService.LOG_DEBUG, "doFindMethod: Found Method " + method, null );
+                            logger.log(Level.DEBUG,
+                                "doFindMethod: Found Method " + method, null);
                         }
                         return new MethodInfo<>(method,
                             Collections.singletonList(ValueUtils.ValueType.ref_map));
@@ -225,9 +230,10 @@ protected MethodInfo<List<ValueUtils.ValueType>> doFindMethod( final Class<?> ta
                     method = getServiceObjectWithMapMethod( targetClass, parameterClass, acceptPrivate, acceptPackage, logger );
                     if ( method != null )
                     {
-                        if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+                        if (logger.isLogEnabled(Level.DEBUG))
                         {
-                            logger.log( LogService.LOG_DEBUG, "doFindMethod: Found Method " + method, null );
+                            logger.log(Level.DEBUG,
+                                "doFindMethod: Found Method " + method, null);
                         }
                         List<ValueUtils.ValueType> paramTypes = new ArrayList<>(2);
                         paramTypes.add(ValueUtils.ValueType.ref_serviceType);
@@ -247,9 +253,10 @@ protected MethodInfo<List<ValueUtils.ValueType>> doFindMethod( final Class<?> ta
                             acceptPackage );
                     if ( method != null )
                     {
-                        if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+                        if (logger.isLogEnabled(Level.DEBUG))
                         {
-                            logger.log( LogService.LOG_DEBUG, "doFindMethod: Found Method " + method, null );
+                            logger.log(Level.DEBUG,
+                                "doFindMethod: Found Method " + method, null);
                         }
                         List<ValueUtils.ValueType> paramTypes = new ArrayList<>(2);
                         paramTypes.add(ValueUtils.ValueType.ref_serviceType);
@@ -342,9 +349,10 @@ else if ( paramType.getName().equals(ClassUtils.FORMATTER_LOGGER_CLASS) )
                         {
                             if ( accept( m, acceptPrivate, acceptPackage, returnValue() ) )
                             {
-                                if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+                                if (logger.isLogEnabled(Level.DEBUG))
                                 {
-                                    logger.log( LogService.LOG_DEBUG, "doFindMethod: Found Method " + m, null );
+                                    logger.log(Level.DEBUG,
+                                        "doFindMethod: Found Method " + m, null);
                                 }
                                 return new MethodInfo<>(m, paramTypes);
                             }
@@ -354,10 +362,10 @@ else if ( paramType.getName().equals(ClassUtils.FORMATTER_LOGGER_CLASS) )
                 }
             }
         }
-        else if ( logger.isLogEnabled( LogService.LOG_WARNING ) )
+        else if (logger.isLogEnabled(Level.WARN))
         {
             logger.log(
-                    LogService.LOG_WARNING,
+                Level.WARN,
                     "doFindMethod: Cannot check for methods taking parameter class " + m_referenceClassName + ": "
                             + targetClass.getName() + " does not see it", null );
         }
@@ -366,7 +374,7 @@ else if ( logger.isLogEnabled( LogService.LOG_WARNING ) )
         // the suitable methods are accessible, we have to terminate
         if ( suitableMethodNotAccessible )
         {
-            logger.log( LogService.LOG_ERROR,
+            logger.log(Level.ERROR,
                     "doFindMethod: Suitable but non-accessible method found in class {0}",null,
                             targetClass.getName() );
             throw new SuitableMethodNotAccessibleException();
@@ -469,10 +477,10 @@ private Method getServiceObjectAssignableMethod( final Class<?> targetClass, fin
         Method candidateBindMethods[] = targetClass.getDeclaredMethods();
         boolean suitableNotAccessible = false;
 
-        if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+        if (logger.isLogEnabled(Level.DEBUG))
         {
             logger.log(
-                    LogService.LOG_DEBUG,
+                Level.DEBUG,
                     "getServiceObjectAssignableMethod: Checking " + candidateBindMethods.length
                     + " declared method in class " + targetClass.getName(), null );
         }
@@ -481,9 +489,10 @@ private Method getServiceObjectAssignableMethod( final Class<?> targetClass, fin
         for ( int i = 0; i < candidateBindMethods.length; i++ )
         {
             Method method = candidateBindMethods[i];
-            if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+            if (logger.isLogEnabled(Level.DEBUG))
             {
-                logger.log( LogService.LOG_DEBUG, "getServiceObjectAssignableMethod: Checking " + method, null );
+                logger.log(Level.DEBUG,
+                    "getServiceObjectAssignableMethod: Checking " + method, null);
             }
 
             // Get the parameters for the current method
@@ -495,9 +504,10 @@ private Method getServiceObjectAssignableMethod( final Class<?> targetClass, fin
             if ( parameters.length == 1 && method.getName().equals( getMethodName() ) )
             {
 
-                if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+                if (logger.isLogEnabled(Level.DEBUG))
                 {
-                    logger.log( LogService.LOG_DEBUG, "getServiceObjectAssignableMethod: Considering " + method, null );
+                    logger.log(Level.DEBUG,
+                        "getServiceObjectAssignableMethod: Considering " + method, null);
                 }
 
                 // Get the parameter type
@@ -516,10 +526,10 @@ private Method getServiceObjectAssignableMethod( final Class<?> targetClass, fin
                     // suitable method is not accessible, flag for exception
                     suitableNotAccessible = true;
                 }
-                else if ( logger.isLogEnabled( LogService.LOG_DEBUG ) )
+                else if (logger.isLogEnabled(Level.DEBUG))
                 {
                     logger.log(
-                            LogService.LOG_DEBUG,
+                        Level.DEBUG,
                             "getServiceObjectAssignableMethod: Parameter failure: Required " + theParameter + "; actual "
                                     + parameterClass.getName(), null );
                 }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/AbstractLogger.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/AbstractLogger.java
index 3066584f5a..87236c6da3 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/AbstractLogger.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/AbstractLogger.java
@@ -20,7 +20,7 @@
 
 import java.text.MessageFormat;
 
-import org.apache.felix.scr.impl.manager.ScrConfiguration;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.osgi.framework.Bundle;
 
 /**
@@ -29,24 +29,17 @@
  */
 public abstract class AbstractLogger
 {
-    private final ScrConfiguration config;
 
     /**
      * The prefix put for each log message
      */
     private volatile String prefix;
 
-    AbstractLogger(final ScrConfiguration config, final String prefix)
+    AbstractLogger(final String prefix)
     {
-        this.config = config;
         this.prefix = prefix;
     }
 
-    ScrConfiguration getConfiguration()
-    {
-        return this.config;
-    }
-
     void setPrefix(final String value)
     {
         this.prefix = value;
@@ -66,11 +59,10 @@ String getPrefix()
     /**
      * Returns {@code true} if logging for the given level is enabled.
      */
-    public boolean isLogEnabled(final int level)
+    public boolean isLogEnabled(final Level level)
     {
         final InternalLogger l = getLogger();
-        return (!l.checkScrConfig() || config.getLogLevel() >= level)
-               && l.isLogEnabled(level);
+        return l.isLogEnabled(level);
     }
 
     /**
@@ -85,7 +77,8 @@ public boolean isLogEnabled(final int level)
      * @param arguments The format arguments for the <code>pattern</code>
      *      string.
      */
-    public boolean log(final int level, final String pattern, final Throwable ex, final Object... arguments )
+    public boolean log(final Level level, final String pattern, final Throwable ex,
+        final Object... arguments)
     {
         if ( isLogEnabled( level ) )
         {
@@ -105,7 +98,7 @@ public boolean log(final int level, final String pattern, final Throwable ex, fi
      * @param message The message to print
      * @param ex The <code>Throwable</code> causing the message to be logged.
      */
-    public boolean log(final int level, final String message, final Throwable ex)
+    public boolean log(final Level level, final String message, final Throwable ex)
     {
         if ( isLogEnabled( level ) )
         {
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/BundleLogger.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/BundleLogger.java
index 915fe8a4b7..241b9c87c8 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/BundleLogger.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/BundleLogger.java
@@ -18,7 +18,10 @@
  */
 package org.apache.felix.scr.impl.logger;
 
-import org.osgi.framework.BundleContext;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
+import org.osgi.framework.Bundle;
+import org.osgi.service.log.Logger;
+import org.osgi.service.log.LoggerFactory;
 
 /**
  * The {@code BundleLogger} defines a simple API to enable some logging on behalf of
@@ -29,9 +32,9 @@ public class BundleLogger extends LogServiceEnabledLogger
 {
     private final ScrLogger parent;
 
-    public BundleLogger(final BundleContext bundleContext, final ScrLogger parent)
+    public BundleLogger(final Bundle bundle, final ScrLogger parent)
     {
-        super(parent.getConfiguration(), bundleContext);
+        super(bundle, parent.getLoggerFactoryTracker());
         this.parent = parent;
     }
 
@@ -40,19 +43,16 @@ InternalLogger getDefaultLogger()
     {
         return new InternalLogger()
         {
-            @Override
-            public boolean checkScrConfig() {
-                return parent.getLogger().checkScrConfig();
-            }
 
             @Override
-            public void log(final int level, final String message, final Throwable ex)
+            public void log(final Level level, final String message,
+                final Throwable ex)
             {
                 parent.getLogger().log(level, message, ex);
             }
 
             @Override
-            public boolean isLogEnabled(final int level)
+            public boolean isLogEnabled(final Level level)
             {
                 return parent.getLogger().isLogEnabled(level);
             }
@@ -68,17 +68,19 @@ InternalLogger getLogger(final String className)
     {
         if ( className != null )
         {
-            final Object logServiceSupport = this.logServiceTracker.getService();
-            if ( logServiceSupport != null )
+            final LoggerFactory factory = this.loggingFactoryTracker.getService();
+            if (factory != null)
             {
-                return ((LogServiceSupport)logServiceSupport).getLogger(className);
+                return new OSGiLogger(factory.getLogger(bundle, className, Logger.class));
             }
         }
         return this.getLogger();
     }
 
     @Override
-    public boolean log(final int level, final String pattern, final Throwable ex, final Object... arguments) {
+    public boolean log(final Level level, final String pattern, final Throwable ex,
+        final Object... arguments)
+    {
         // delegate to parent if not logging
         if ( !super.log(level, pattern, ex, arguments) ) {
             return this.parent.log(level, pattern, ex, arguments);
@@ -87,7 +89,8 @@ public boolean log(final int level, final String pattern, final Throwable ex, fi
     }
 
     @Override
-    public boolean log(final int level, final String message, final Throwable ex) {
+    public boolean log(final Level level, final String message, final Throwable ex)
+    {
         // delegate to parent if not logging
         if ( !super.log(level, message, ex) ) {
             return this.parent.log(level, message, ex);
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/ComponentLogger.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/ComponentLogger.java
index 7f85b48505..13252c58da 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/ComponentLogger.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/ComponentLogger.java
@@ -18,6 +18,7 @@
  */
 package org.apache.felix.scr.impl.logger;
 
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.ComponentMetadata;
 
 /**
@@ -39,7 +40,7 @@ public class ComponentLogger extends AbstractLogger
 
     public ComponentLogger(final ComponentMetadata metadata, final BundleLogger parent)
     {
-        super(parent.getConfiguration(), ""); // we set the prefix later
+        super(""); // we set the prefix later
         this.parent = parent;
         if ( metadata.getName() != null )
         {
@@ -92,7 +93,9 @@ InternalLogger getLogger()
     }
 
     @Override
-    public boolean log(final int level, final String pattern, final Throwable ex, final Object... arguments) {
+    public boolean log(final Level level, final String pattern, final Throwable ex,
+        final Object... arguments)
+    {
         // delegate to parent if not logging
         if ( !super.log(level, pattern, ex, arguments) ) {
             return this.parent.log(level, pattern, ex, arguments);
@@ -101,7 +104,8 @@ public boolean log(final int level, final String pattern, final Throwable ex, fi
     }
 
     @Override
-    public boolean log(final int level, final String message, final Throwable ex) {
+    public boolean log(final Level level, final String message, final Throwable ex)
+    {
         // delegate to parent if not logging
         if ( !super.log(level, message, ex) ) {
             return this.parent.log(level, message, ex);
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/InternalLogger.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/InternalLogger.java
index b7f765b734..2295dc9297 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/InternalLogger.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/InternalLogger.java
@@ -18,11 +18,19 @@
  */
 package org.apache.felix.scr.impl.logger;
 
-interface InternalLogger {
+public interface InternalLogger
+{
+    public enum Level
+    {
+        AUDIT, ERROR, WARN, INFO, DEBUG, TRACE;
 
-    void log(int level, String message, Throwable exception);
+        public boolean implies(Level other)
+        {
+            return ordinal() >= other.ordinal();
+        }
+    }
 
-    boolean isLogEnabled(int level);
+    void log(Level level, String message, Throwable ex);
 
-    boolean checkScrConfig();
+    boolean isLogEnabled(Level level);
 }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/LogServiceEnabledLogger.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/LogServiceEnabledLogger.java
index 26ad9b1144..6bc3c86a10 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/LogServiceEnabledLogger.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/LogServiceEnabledLogger.java
@@ -18,11 +18,10 @@
  */
 package org.apache.felix.scr.impl.logger;
 
-import org.apache.felix.scr.impl.manager.ScrConfiguration;
-import org.osgi.framework.BundleContext;
-import org.osgi.framework.ServiceReference;
+import org.osgi.framework.Bundle;
+import org.osgi.service.log.Logger;
+import org.osgi.service.log.LoggerFactory;
 import org.osgi.util.tracker.ServiceTracker;
-import org.osgi.util.tracker.ServiceTrackerCustomizer;
 
 /**
  * This abstract class adds support for using a LogService
@@ -30,85 +29,46 @@
  */
 abstract class LogServiceEnabledLogger extends AbstractLogger
 {
-    // name of the LogService class (this is a string to not create a reference to the class)
-    // With R7, LogService is deprecated but extends the newer LoggerFactory
-    private static final String LOGSERVICE_CLASS = "org.osgi.service.log.LogService";
-
     // the log service to log messages to
-    protected final ServiceTracker<Object, Object> logServiceTracker;
+    protected final ServiceTracker<LoggerFactory, LoggerFactory> loggingFactoryTracker;
+
+    protected final Bundle bundle;
 
     private volatile InternalLogger currentLogger;
 
     protected volatile int trackingCount = -2;
 
-    public LogServiceEnabledLogger(final ScrConfiguration config, final BundleContext bundleContext)
-    {
-        super(config, getBundleIdentifier(bundleContext.getBundle()));
-        // Start a tracker for the log service
-        // we only track a single log service which in reality should be enough
-        logServiceTracker = new ServiceTracker<>( bundleContext, LOGSERVICE_CLASS, new ServiceTrackerCustomizer<Object, Object>()
-        {
-            private volatile boolean hasService = false;
-
-            @Override
-            public Object addingService(final ServiceReference<Object> reference)
-            {
-                if ( !hasService )
-                {
-                    final Object logService = bundleContext.getService(reference);
-                    if ( logService != null )
-                    {
-                        hasService = true;
-                        final LogServiceSupport lsl = new LogServiceSupport(bundleContext.getBundle(), logService);
-                        return lsl;
-                    }
-                }
-                return null;
-            }
-
-            @Override
-            public void modifiedService(final ServiceReference<Object> reference, final Object service)
-            {
-                // nothing to do
-            }
-
-            @Override
-            public void removedService(final ServiceReference<Object> reference, final Object service)
-            {
-                hasService = false;
-                bundleContext.ungetService(reference);
-            }
-        } );
-        logServiceTracker.open();
-    }
-
-    /**
-     * Close the logger
-     */
-    public void close()
+    public LogServiceEnabledLogger(final Bundle bundle, ServiceTracker<LoggerFactory, LoggerFactory> loggingFactoryTracker)
     {
-        // stop the tracker
-        logServiceTracker.close();
+        super(getBundleIdentifier(bundle));
+        this.bundle = bundle;
+        this.loggingFactoryTracker = loggingFactoryTracker;
     }
 
     @Override
     InternalLogger getLogger()
     {
-        if ( this.trackingCount < this.logServiceTracker.getTrackingCount() )
+        if (this.trackingCount < this.loggingFactoryTracker.getTrackingCount())
         {
-            final Object logServiceSupport = this.logServiceTracker.getService();
-            if ( logServiceSupport == null )
+            final LoggerFactory factory = this.loggingFactoryTracker.getService();
+            if (factory == null)
             {
                 this.currentLogger = this.getDefaultLogger();
             }
             else
             {
-                this.currentLogger = ((LogServiceSupport)logServiceSupport).getLogger();
+                this.currentLogger = new OSGiLogger(
+                    factory.getLogger(bundle, null, Logger.class));
             }
-            this.trackingCount = this.logServiceTracker.getTrackingCount();
+            this.trackingCount = this.loggingFactoryTracker.getTrackingCount();
         }
         return currentLogger;
     }
 
     abstract InternalLogger getDefaultLogger();
+
+    ServiceTracker<LoggerFactory, LoggerFactory> getLoggerFactoryTracker()
+    {
+        return loggingFactoryTracker;
+    }
 }
\ No newline at end of file
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/LogServiceSupport.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/LogServiceSupport.java
deleted file mode 100644
index 90e3f71ba0..0000000000
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/LogServiceSupport.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * 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.felix.scr.impl.logger;
-
-import org.osgi.framework.Bundle;
-import org.osgi.service.log.LogService;
-
-/**
- * This is a logger based on the LogService.
- * It supports both R6 and R7 logging
- *
- */
-class LogServiceSupport
-{
-    private final boolean r7Enabled;
-
-    private final LogService logService;
-
-    private final Bundle bundle;
-
-    private static boolean checkForLoggerFactory(Class<?> clazz)
-    {
-        while ( clazz != null )
-        {
-            final Class<?>[] is = clazz.getInterfaces();
-            for(final Class<?> c : is)
-            {
-                if ( "org.osgi.service.log.LoggerFactory".equals(c.getName()) )
-                {
-                    return true;
-                }
-                if ( checkForLoggerFactory(c) )
-                {
-                    return true;
-                }
-            }
-            clazz = clazz.getSuperclass();
-        }
-        return false;
-    }
-
-    public LogServiceSupport(final Bundle bundle, final Object logService)
-    {
-        this.logService = (LogService) logService;
-        this.bundle = bundle;
-        this.r7Enabled = checkForLoggerFactory(this.logService.getClass());
-    }
-
-    InternalLogger getLogger()
-    {
-        if ( r7Enabled )
-        {
-            return new R7LogServiceLogger(this.bundle, this.logService, null);
-        }
-        return new R6LogServiceLogger(this.logService);
-    }
-
-    InternalLogger getLogger(final String className)
-    {
-        if ( r7Enabled )
-        {
-            return new R7LogServiceLogger(this.bundle, this.logService, className);
-        }
-        return new R6LogServiceLogger(this.logService);
-    }
-}
\ No newline at end of file
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/OSGiLogger.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/OSGiLogger.java
new file mode 100644
index 0000000000..1a9fc07e1c
--- /dev/null
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/OSGiLogger.java
@@ -0,0 +1,76 @@
+/*
+ * 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.felix.scr.impl.logger;
+
+import org.osgi.service.log.Logger;
+
+final class OSGiLogger implements InternalLogger
+{
+
+    private final Logger logger;
+
+    public OSGiLogger(Logger logger)
+    {
+        this.logger = logger;
+    }
+
+    public void log(Level level, String message, Throwable ex)
+    {
+        if ( ex == null )
+        {
+            switch ( level )
+            {
+                case AUDIT : logger.audit(message); break;
+                case ERROR : logger.error(message); break;
+                case WARN : logger.warn(message); break;
+                case INFO : logger.info(message); break;
+                case DEBUG : logger.debug(message); break;
+                case TRACE : logger.trace(message); break;
+                default : logger.debug(message);
+            }
+        }
+        else
+        {
+            switch ( level )
+            {
+                case AUDIT : logger.audit(message, ex); break;
+                case ERROR : logger.error(message, ex); break;
+                case WARN : logger.warn(message, ex); break;
+                case INFO : logger.info(message, ex); break;
+                case DEBUG : logger.debug(message, ex); break;
+                case TRACE : logger.trace(message, ex); break;
+                default : logger.debug(message, ex);
+            }
+        }
+    }
+
+    public boolean isLogEnabled(Level level)
+    {
+        switch (level)
+        {
+            case AUDIT: return true;
+            case ERROR: return logger.isErrorEnabled();
+            case WARN: return logger.isWarnEnabled();
+            case INFO: return logger.isInfoEnabled();
+            case DEBUG: return logger.isDebugEnabled();
+            case TRACE: return logger.isTraceEnabled();
+            default: return logger.isDebugEnabled();
+        }
+    }
+}
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/R6LogServiceLogger.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/R6LogServiceLogger.java
deleted file mode 100644
index b99df1b806..0000000000
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/R6LogServiceLogger.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * 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.felix.scr.impl.logger;
-
-import org.osgi.service.log.LogService;
-
-/**
- * This is a logger based on the R6 LogService.
- */
-class R6LogServiceLogger implements InternalLogger
-{
-    private final LogService logService;
-
-    public R6LogServiceLogger(final LogService logService)
-    {
-        this.logService = logService;
-    }
-
-    @Override
-    public boolean isLogEnabled(final int level)
-    {
-        return true;
-    }
-
-    @Override
-    public boolean checkScrConfig() {
-        return true;
-    }
-
-    @SuppressWarnings("deprecation")
-    @Override
-    public void log(final int level, final String message, final Throwable ex)
-    {
-        this.logService.log(level, message, ex);
-    }
-}
\ No newline at end of file
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/R7LogServiceLogger.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/R7LogServiceLogger.java
deleted file mode 100644
index 0e81da2b1d..0000000000
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/R7LogServiceLogger.java
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- * 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.felix.scr.impl.logger;
-
-import org.osgi.framework.Bundle;
-import org.osgi.service.log.LogService;
-import org.osgi.service.log.Logger;
-import org.osgi.service.log.LoggerFactory;
-
-/**
- * This is a logger based on the R7 LogService/LoggerFactory
- */
-class R7LogServiceLogger implements InternalLogger
-{
-    private final Logger logger;
-
-    public R7LogServiceLogger(final Bundle bundle, final LogService loggerFactory, final String name)
-    {
-        this.logger = ((LoggerFactory)loggerFactory).getLogger(name == null ? Logger.ROOT_LOGGER_NAME : name, Logger.class);
-    }
-
-    @Override
-    public boolean checkScrConfig() {
-        return false;
-    }
-
-    @Override
-    public boolean isLogEnabled(final int level)
-    {
-        switch ( level )
-        {
-            case 1 : return logger.isErrorEnabled();
-            case 2 : return logger.isWarnEnabled();
-            case 3 : return logger.isInfoEnabled();
-            default : return logger.isDebugEnabled();
-        }
-    }
-
-    @Override
-    public void log(final int level, final String message, final Throwable ex)
-    {
-        if ( ex == null )
-        {
-            switch ( level )
-            {
-                case 1 : logger.error(message); break;
-                case 2 : logger.warn(message); break;
-                case 3 : logger.info(message); break;
-                default : logger.debug(message);
-            }
-        }
-        else
-        {
-            switch ( level )
-            {
-                case 1 : logger.error(message, ex); break;
-                case 2 : logger.warn(message, ex); break;
-                case 3 : logger.info(message, ex); break;
-                default : logger.debug(message, ex);
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/ScrLogger.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/ScrLogger.java
index b31ebc1948..9ef2562223 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/ScrLogger.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/ScrLogger.java
@@ -20,6 +20,8 @@
 
 import org.apache.felix.scr.impl.manager.ScrConfiguration;
 import org.osgi.framework.BundleContext;
+import org.osgi.service.log.LoggerFactory;
+import org.osgi.util.tracker.ServiceTracker;
 
 /**
  * This is the "global" logger used by the implementation for all logging
@@ -27,15 +29,30 @@
  */
 public class ScrLogger extends LogServiceEnabledLogger
 {
-    public ScrLogger(final ScrConfiguration config, final BundleContext bundleContext)
+    private final ScrConfiguration config;
+    public ScrLogger(final ScrConfiguration config, BundleContext context)
     {
-        super(config, bundleContext);
+        super(context.getBundle(), getTracker(context));
+        this.config = config;
     }
 
-
     @Override
     InternalLogger getDefaultLogger()
     {
-        return new StdOutLogger();
+        return new StdOutLogger(config);
+    }
+
+    private static ServiceTracker<LoggerFactory, LoggerFactory> getTracker(
+        BundleContext context)
+    {
+        ServiceTracker<LoggerFactory, LoggerFactory> tracker = new ServiceTracker<>(
+            context, "org.osgi.service.log.LoggerFactory", null);
+        tracker.open();
+        return tracker;
+    }
+
+    public void closeTracker()
+    {
+        getLoggerFactoryTracker().close();
     }
 }
\ No newline at end of file
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/logger/StdOutLogger.java b/scr/src/main/java/org/apache/felix/scr/impl/logger/StdOutLogger.java
index 1ff9de650b..627b812713 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/logger/StdOutLogger.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/logger/StdOutLogger.java
@@ -20,7 +20,7 @@
 
 import java.io.PrintStream;
 
-import org.osgi.service.log.LogService;
+import org.apache.felix.scr.impl.manager.ScrConfiguration;
 
 /**
  * This logger logs to std out / err
@@ -28,33 +28,41 @@
 class StdOutLogger implements InternalLogger
 {
 
-    @Override
-    public boolean checkScrConfig() {
-        return true;
+    private final ScrConfiguration config;
+
+    public StdOutLogger(ScrConfiguration config)
+    {
+        this.config = config;
     }
 
     @Override
-    public void log(final int level, final String message, final Throwable ex)
+    public void log(final Level level, final String message, final Throwable ex)
     {
         if ( isLogEnabled(level) )
         {
             // output depending on level
-            final PrintStream out = ( level == LogService.LOG_ERROR )? System.err: System.out;
+            final PrintStream out = (level == Level.ERROR) ? System.err : System.out;
 
             // level as a string
             final StringBuilder buf = new StringBuilder();
             switch (level)
             {
-                case ( LogService.LOG_DEBUG ):
+                case AUDIT:
+                    buf.append("AUDIT");
+                    break;
+                case TRACE:
+                    buf.append("TRACE");
+                    break;
+                case DEBUG:
                     buf.append( "DEBUG: " );
                     break;
-                case ( LogService.LOG_INFO ):
+                case INFO:
                     buf.append( "INFO : " );
                     break;
-                case ( LogService.LOG_WARNING ):
+                case WARN:
                     buf.append( "WARN : " );
                     break;
-                case ( LogService.LOG_ERROR ):
+                case ERROR:
                     buf.append( "ERROR: " );
                     break;
                 default:
@@ -83,8 +91,9 @@ public void log(final int level, final String message, final Throwable ex)
     }
 
     @Override
-    public boolean isLogEnabled(final int level)
+    public boolean isLogEnabled(Level level)
     {
-        return true;
+        return config.getLogLevel().implies(level);
+
     }
 }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/manager/AbstractComponentManager.java b/scr/src/main/java/org/apache/felix/scr/impl/manager/AbstractComponentManager.java
index af2c65a93a..fda0be75fb 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/manager/AbstractComponentManager.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/manager/AbstractComponentManager.java
@@ -46,6 +46,7 @@
 import org.apache.felix.scr.impl.inject.MethodResult;
 import org.apache.felix.scr.impl.inject.RefPair;
 import org.apache.felix.scr.impl.logger.ComponentLogger;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.ComponentMetadata;
 import org.apache.felix.scr.impl.metadata.ReferenceMetadata;
 import org.apache.felix.scr.impl.metadata.ServiceMetadata;
@@ -58,7 +59,6 @@
 import org.osgi.framework.ServiceRegistration;
 import org.osgi.service.component.ComponentConstants;
 import org.osgi.service.component.runtime.dto.ComponentConfigurationDTO;
-import org.osgi.service.log.LogService;
 import org.osgi.util.promise.Deferred;
 import org.osgi.util.promise.Promise;
 
@@ -196,9 +196,9 @@ protected AbstractComponentManager(ComponentContainer<S> container, ComponentMet
         m_stateLock = new ReentrantLock(true);
 
         // dump component details
-        if (m_container.getLogger().isLogEnabled(LogService.LOG_DEBUG))
+        if (m_container.getLogger().isLogEnabled(Level.DEBUG))
         {
-            m_container.getLogger().log(LogService.LOG_DEBUG,
+            m_container.getLogger().log(Level.DEBUG,
                     "Component created: DS={0}, implementation={1}, immediate={2}, default-enabled={3}, factory={4}, configuration-policy={5}, activate={6}, deactivate={7}, modified={8} configuration-pid={9}",
                     null,
                     metadata.getDSVersion(), metadata.getImplementationClassName(),
@@ -208,14 +208,15 @@ protected AbstractComponentManager(ComponentContainer<S> container, ComponentMet
 
             if (metadata.getServiceMetadata() != null)
             {
-                m_container.getLogger().log(LogService.LOG_DEBUG,
+                m_container.getLogger().log(Level.DEBUG,
                         "Component Services: scope={0}, services={1}",
                         null,
                         metadata.getServiceScope(), Arrays.toString(metadata.getServiceMetadata().getProvides()));
             }
             if (metadata.getProperties() != null)
             {
-                m_container.getLogger().log(LogService.LOG_DEBUG, "Component Properties: {0}", null,
+                m_container.getLogger().log(Level.DEBUG, "Component Properties: {0}",
+                    null,
                          metadata.getProperties() );
             }
         }
@@ -303,11 +304,11 @@ final void dumpThreads()
         try
         {
             String dump = new ThreadDump().call();
-            m_container.getLogger().log(LogService.LOG_DEBUG, dump, null);
+            m_container.getLogger().log(Level.DEBUG, dump, null);
         }
         catch (Throwable t)
         {
-            m_container.getLogger().log(LogService.LOG_DEBUG, "Could not dump threads", t);
+            m_container.getLogger().log(Level.DEBUG, "Could not dump threads", t);
         }
     }
 
@@ -354,7 +355,8 @@ void waitForTracked(int trackingCount)
         {
             while (m_ceiling < trackingCount || (!m_missing.isEmpty() && m_missing.iterator().next() < trackingCount))
             {
-                m_container.getLogger().log(LogService.LOG_DEBUG, "waitForTracked trackingCount: {0} ceiling: {1} missing: {2}", null,
+                m_container.getLogger().log(Level.DEBUG,
+                    "waitForTracked trackingCount: {0} ceiling: {1} missing: {2}", null,
                          trackingCount, m_ceiling, m_missing );
                 try
                 {
@@ -374,7 +376,7 @@ void waitForTracked(int trackingCount)
                     }
                     catch (InterruptedException e1)
                     {
-                        m_container.getLogger().log(LogService.LOG_ERROR,
+                        m_container.getLogger().log(Level.ERROR,
                                 "waitForTracked interrupted twice: {0} ceiling: {1} missing: {2},  Expect further errors", e1,
                                  trackingCount, m_ceiling, m_missing );
                     }
@@ -392,7 +394,9 @@ private boolean doMissingWait() throws InterruptedException
     {
         if (!m_missingCondition.await(getLockTimeout(), TimeUnit.MILLISECONDS))
         {
-            m_container.getLogger().log(LogService.LOG_ERROR, "waitForTracked timed out: {0} ceiling: {1} missing: {2},  Expect further errors", null,
+            m_container.getLogger().log(Level.ERROR,
+                "waitForTracked timed out: {0} ceiling: {1} missing: {2},  Expect further errors",
+                null,
                      m_trackingCount, m_ceiling, m_missing);
             dumpThreads();
             m_missing.clear();
@@ -648,57 +652,68 @@ final void enableInternal()
         }
         if (!m_container.getActivator().isActive())
         {
-            m_container.getLogger().log(LogService.LOG_DEBUG, "Bundle's component activator is not active; not enabling component", null);
+            m_container.getLogger().log(Level.DEBUG,
+                "Bundle's component activator is not active; not enabling component",
+                null);
             return;
         }
         if (previousState.isEnabled())
         {
-            m_container.getLogger().log(LogService.LOG_WARNING, "enable called but component is already in state {0}", null,
+            m_container.getLogger().log(Level.WARN,
+                "enable called but component is already in state {0}", null,
                      previousState);
             return;
         }
 
         registerComponentId();
-        m_container.getLogger().log(LogService.LOG_DEBUG, "Updating target filters", null);
+        m_container.getLogger().log(Level.DEBUG, "Updating target filters", null);
         updateTargets(getProperties());
 
         setState(previousState, State.unsatisfiedReference);
-        m_container.getLogger().log(LogService.LOG_DEBUG, "Component enabled", null);
+        m_container.getLogger().log(Level.DEBUG, "Component enabled", null);
         activateInternal();
     }
 
     final void activateInternal()
     {
-        m_container.getLogger().log(LogService.LOG_DEBUG, "ActivateInternal", null);
+        m_container.getLogger().log(Level.DEBUG, "ActivateInternal", null);
         State s = getState();
         if (s == State.disposed)
         {
-            m_container.getLogger().log(LogService.LOG_DEBUG, "ActivateInternal: disposed", null);
+            m_container.getLogger().log(Level.DEBUG, "ActivateInternal: disposed",
+                null);
             return;
         }
         if (s == State.active)
         {
-            m_container.getLogger().log(LogService.LOG_DEBUG, "ActivateInternal: already activated", null);
+            m_container.getLogger().log(Level.DEBUG,
+                "ActivateInternal: already activated", null);
             return;
         }
         if (!s.isEnabled())
         {
-            m_container.getLogger().log(LogService.LOG_DEBUG, "Component is not enabled; not activating component", null);
+            m_container.getLogger().log(Level.DEBUG,
+                "Component is not enabled; not activating component", null);
             return;
         }
         if (!m_container.getActivator().isActive())
         {
-            m_container.getLogger().log(LogService.LOG_DEBUG, "Bundle's component activator is not active; not activating component", null);
+            m_container.getLogger().log(Level.DEBUG,
+                "Bundle's component activator is not active; not activating component",
+                null);
             return;
         }
 
-        m_container.getLogger().log(LogService.LOG_DEBUG, "Activating component from state {0}", null,  getState() );
+        m_container.getLogger().log(Level.DEBUG, "Activating component from state {0}",
+            null, getState());
 
         // Before creating the implementation object, we are going to
         // test that the bundle has enough permissions to register services
         if (!hasServiceRegistrationPermissions())
         {
-            m_container.getLogger().log(LogService.LOG_DEBUG, "Component is not permitted to register all services, cannot activate", null);
+            m_container.getLogger().log(Level.DEBUG,
+                "Component is not permitted to register all services, cannot activate",
+                null);
             return;
         }
 
@@ -709,24 +724,28 @@ final void activateInternal()
             s = getState();
             if (s == State.disposed)
             {
-                m_container.getLogger().log(LogService.LOG_DEBUG, "ActivateInternal: disposed", null);
+                m_container.getLogger().log(Level.DEBUG, "ActivateInternal: disposed",
+                    null);
                 return;
             }
             if (s == State.active)
             {
-                m_container.getLogger().log(LogService.LOG_DEBUG, "ActivateInternal: already activated", null);
+                m_container.getLogger().log(Level.DEBUG,
+                    "ActivateInternal: already activated", null);
                 return;
             }
             if (!s.isEnabled())
             {
-                m_container.getLogger().log(LogService.LOG_DEBUG, "Component is not enabled; not activating component", null);
+                m_container.getLogger().log(Level.DEBUG,
+                    "Component is not enabled; not activating component", null);
                 return;
             }
             // Before creating the implementation object, we are going to
             // test if all the mandatory dependencies are satisfied
             if (!verifyDependencyManagers())
             {
-                m_container.getLogger().log(LogService.LOG_DEBUG, "Not all dependencies satisfied, cannot activate", null);
+                m_container.getLogger().log(Level.DEBUG,
+                    "Not all dependencies satisfied, cannot activate", null);
                 return;
             }
 
@@ -795,7 +814,7 @@ final void deactivateInternal(int reason, boolean disable, boolean dispose)
         {
             nextState = State.disposed;
         }
-        m_container.getLogger().log(LogService.LOG_DEBUG, "Deactivating component", null);
+        m_container.getLogger().log(Level.DEBUG, "Deactivating component", null);
 
         // catch any problems from deleting the component to prevent the
         // component to remain in the deactivating state !
@@ -812,7 +831,8 @@ final void deactivateInternal(int reason, boolean disable, boolean dispose)
         }
         if (isFactory() || m_factoryInstance || dispose)
         {
-            m_container.getLogger().log(LogService.LOG_DEBUG, "Disposing component (reason: " + reason + ")", null);
+            m_container.getLogger().log(Level.DEBUG,
+                "Disposing component (reason: " + reason + ")", null);
             clear();
         }
     }
@@ -823,7 +843,8 @@ private void doDeactivate(int reason, boolean disable)
         {
             if (!unregisterService())
             {
-                m_container.getLogger().log(LogService.LOG_DEBUG, "Component deactivation occuring on another thread", null);
+                m_container.getLogger().log(Level.DEBUG,
+                    "Component deactivation occuring on another thread", null);
             }
             obtainStateLock();
             try
@@ -843,7 +864,8 @@ private void doDeactivate(int reason, boolean disable)
         }
         catch (Throwable t)
         {
-            m_container.getLogger().log(LogService.LOG_WARNING, "Component deactivation threw an exception", t);
+            m_container.getLogger().log(Level.WARN,
+                "Component deactivation threw an exception", t);
         }
     }
 
@@ -910,7 +932,9 @@ ServiceRegistration<S> register(String[] services)
             }
             catch (ServiceException e)
             {
-                log(LogService.LOG_ERROR, "Unexpected error registering component service with properties {0}", e, serviceProperties);
+                log(Level.ERROR,
+                    "Unexpected error registering component service with properties {0}",
+                    e, serviceProperties);
                 return null;
             }
         }
@@ -929,7 +953,7 @@ void unregister(ServiceRegistration<S> serviceRegistration)
         }
 
         @Override
-        void log(int level, String message, Throwable ex, Object... arguments)
+        void log(Level level, String message, Throwable ex, Object... arguments)
         {
             AbstractComponentManager.this.getLogger().log(level, message, ex, arguments);
         }
@@ -991,7 +1015,9 @@ private void initDependencyManagers(final ComponentContextImpl<S> componentConte
         final Bundle bundle = getBundle();
         if (bundle == null)
         {
-            m_container.getLogger().log(LogService.LOG_ERROR, "bundle shut down while trying to load implementation object class", null);
+            m_container.getLogger().log(Level.ERROR,
+                "bundle shut down while trying to load implementation object class",
+                null);
             throw new IllegalStateException("bundle shut down while trying to load implementation object class");
         }
         Class<S> implementationObjectClass;
@@ -1001,7 +1027,8 @@ private void initDependencyManagers(final ComponentContextImpl<S> componentConte
         }
         catch (ClassNotFoundException e)
         {
-            m_container.getLogger().log(LogService.LOG_ERROR, "Could not load implementation object class {0}",
+            m_container.getLogger().log(Level.ERROR,
+                "Could not load implementation object class {0}",
                     e, getComponentMetadata().getImplementationClassName() );
             throw new IllegalStateException(
                     "Could not load implementation object class " + getComponentMetadata().getImplementationClassName());
@@ -1031,12 +1058,14 @@ protected boolean collectDependencies(ComponentContextImpl<S> componentContext)
             {
                 //not actually satisfied any longer
                 deactivateDependencyManagers();
-                m_container.getLogger().log(LogService.LOG_DEBUG, "Could not get required dependency for dependency manager: {0}", null,
+                m_container.getLogger().log(Level.DEBUG,
+                    "Could not get required dependency for dependency manager: {0}", null,
                          dependencyManager.getName());
                 return false;
             }
         }
-        m_container.getLogger().log(LogService.LOG_DEBUG, "This thread collected dependencies", null);
+        m_container.getLogger().log(Level.DEBUG, "This thread collected dependencies",
+            null);
         return true;
     }
 
@@ -1058,7 +1087,9 @@ void notifyWaiters()
         if ( registrationManager.getServiceRegistration() != null )
         {
             //see if our service has been requested but returned null....
-            m_container.getLogger().log( LogService.LOG_DEBUG, "Notifying possible clients that service might be available with activator {0}", null,
+            m_container.getLogger().log(Level.DEBUG,
+                "Notifying possible clients that service might be available with activator {0}",
+                null,
                 m_container.getActivator()  );
             try
             {
@@ -1110,7 +1141,8 @@ private boolean hasServiceRegistrationPermissions()
                         final Permission perm = new ServicePermission(service, ServicePermission.REGISTER);
                         if (!bundle.hasPermission(perm))
                         {
-                            m_container.getLogger().log(LogService.LOG_DEBUG, "Permission to register service {0} is denied", null,
+                            m_container.getLogger().log(Level.DEBUG,
+                                "Permission to register service {0} is denied", null,
                                     service );
                             allowed = false;
                         }
@@ -1166,12 +1198,14 @@ protected boolean verifyDependencyManagers()
                 // bundle has no service get permission
                 if (dm.isOptional())
                 {
-                    m_container.getLogger().log(LogService.LOG_DEBUG, "No permission to get optional dependency: {0}; assuming satisfied",
+                    m_container.getLogger().log(Level.DEBUG,
+                        "No permission to get optional dependency: {0}; assuming satisfied",
                             null, dm.getName() );
                 }
                 else
                 {
-                    m_container.getLogger().log(LogService.LOG_DEBUG, "No permission to get mandatory dependency: {0}; assuming unsatisfied",
+                    m_container.getLogger().log(Level.DEBUG,
+                        "No permission to get mandatory dependency: {0}; assuming unsatisfied",
                             null, dm.getName() );
                     satisfied = false;
                 }
@@ -1179,7 +1213,8 @@ protected boolean verifyDependencyManagers()
             else if (!dm.isSatisfied())
             {
                 // bundle would have permission but there are not enough services
-                m_container.getLogger().log(LogService.LOG_DEBUG, "Dependency not satisfied: {0}", null, dm.getName() );
+                m_container.getLogger().log(Level.DEBUG,
+                    "Dependency not satisfied: {0}", null, dm.getName());
                 satisfied = false;
             }
         }
@@ -1235,7 +1270,8 @@ else if (!dm.isSatisfied())
 
     private void deactivateDependencyManagers()
     {
-        m_container.getLogger().log(LogService.LOG_DEBUG, "Deactivating dependency managers", null);
+        m_container.getLogger().log(Level.DEBUG, "Deactivating dependency managers",
+            null);
         for (DependencyManager<S, ?> dm : getDependencyManagers())
         {
             dm.deactivate();
@@ -1244,7 +1280,8 @@ private void deactivateDependencyManagers()
 
     private void disableDependencyManagers()
     {
-        m_container.getLogger().log(LogService.LOG_DEBUG, "Disabling dependency managers", null);
+        m_container.getLogger().log(Level.DEBUG, "Disabling dependency managers",
+            null);
         AtomicInteger trackingCount = new AtomicInteger();
         for (DependencyManager<S, ?> dm : getDependencyManagers())
         {
@@ -1387,7 +1424,7 @@ public int getSpecState()
     State getState()
     {
         State s = state.get();
-        m_container.getLogger().log(LogService.LOG_DEBUG, "Querying state {0}", null, s );
+        m_container.getLogger().log(Level.DEBUG, "Querying state {0}", null, s);
         return s;
     }
 
@@ -1413,7 +1450,8 @@ void setState(final State previousState, final State newState)
     {
         if (state.compareAndSet(previousState, newState))
         {
-            m_container.getLogger().log(LogService.LOG_DEBUG, "Changed state from {0} to {1}", null, previousState, newState );
+            m_container.getLogger().log(Level.DEBUG, "Changed state from {0} to {1}",
+                null, previousState, newState);
             if ( newState == State.active || newState == State.unsatisfiedReference )
             {
                 this.failureReason = null;
@@ -1422,7 +1460,8 @@ void setState(final State previousState, final State newState)
         }
         else
         {
-            m_container.getLogger().log(LogService.LOG_DEBUG, "Did not change state from {0} to {1}: current state {2}",
+            m_container.getLogger().log(Level.DEBUG,
+                "Did not change state from {0} to {1}: current state {2}",
                     null, previousState, newState, state.get() );
         }
 
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/manager/AbstractPrototypeRefPair.java b/scr/src/main/java/org/apache/felix/scr/impl/manager/AbstractPrototypeRefPair.java
index 440fc44583..73bb82f565 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/manager/AbstractPrototypeRefPair.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/manager/AbstractPrototypeRefPair.java
@@ -26,9 +26,9 @@
 
 import org.apache.felix.scr.impl.inject.RefPair;
 import org.apache.felix.scr.impl.inject.ScrComponentContext;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.ServiceReference;
-import org.osgi.service.log.LogService;
 
 /**
  * @version $Rev$ $Date$
@@ -85,7 +85,7 @@ public final boolean getServiceObject(ScrComponentContext key, BundleContext con
         {
             markFailed();
             key.getLogger().log(
-                 LogService.LOG_WARNING,
+                Level.WARN,
                  "Could not get service from serviceobjects for ref {0}", null, getRef() );
             return false;
         }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/manager/ComponentContextImpl.java b/scr/src/main/java/org/apache/felix/scr/impl/manager/ComponentContextImpl.java
index 229a428499..3204e18889 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/manager/ComponentContextImpl.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/manager/ComponentContextImpl.java
@@ -32,13 +32,13 @@
 import org.apache.felix.scr.impl.inject.RefPair;
 import org.apache.felix.scr.impl.inject.ScrComponentContext;
 import org.apache.felix.scr.impl.logger.ComponentLogger;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.ComponentMetadata;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.ServiceReference;
 import org.osgi.framework.ServiceRegistration;
 import org.osgi.service.component.ComponentInstance;
-import org.osgi.service.log.LogService;
 
 
 /**
@@ -275,7 +275,9 @@ S getImplementationObject( boolean requireAccessible )
             }
             catch ( InterruptedException e1 )
             {
-                m_componentManager.getLogger().log( LogService.LOG_INFO, "Interrupted twice waiting for implementation object to become accessible", e1 );
+                m_componentManager.getLogger().log(Level.INFO,
+                    "Interrupted twice waiting for implementation object to become accessible",
+                    e1);
             }
             Thread.currentThread().interrupt();
             return null;
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/manager/ComponentFactoryImpl.java b/scr/src/main/java/org/apache/felix/scr/impl/manager/ComponentFactoryImpl.java
index 4e2491a043..ba279efb48 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/manager/ComponentFactoryImpl.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/manager/ComponentFactoryImpl.java
@@ -30,6 +30,7 @@
 import org.apache.felix.scr.impl.BundleComponentActivator;
 import org.apache.felix.scr.impl.inject.ComponentMethods;
 import org.apache.felix.scr.impl.inject.RefPair;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.ComponentMetadata;
 import org.apache.felix.scr.impl.metadata.ReferenceMetadata;
 import org.apache.felix.scr.impl.metadata.TargetedPID;
@@ -38,7 +39,6 @@
 import org.osgi.service.component.ComponentException;
 import org.osgi.service.component.ComponentFactory;
 import org.osgi.service.component.ComponentInstance;
-import org.osgi.service.log.LogService;
 
 /**
  * The <code>ComponentFactoryImpl</code> extends the {@link AbstractComponentManager}
@@ -122,7 +122,8 @@ public boolean isFactory()
     public ComponentInstance<S> newInstance( Dictionary<String, ?> dictionary )
     {
         final SingleComponentManager<S> cm = createComponentManager();
-        getLogger().log(LogService.LOG_DEBUG, "Creating new instance from component factory", null);
+        getLogger().log(Level.DEBUG, "Creating new instance from component factory",
+            null);
 
         cm.setFactoryProperties( dictionary );
         //configure the properties
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/manager/ConfigurableComponentHolder.java b/scr/src/main/java/org/apache/felix/scr/impl/manager/ConfigurableComponentHolder.java
index c8e6446f58..8fcbbdcb50 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/manager/ConfigurableComponentHolder.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/manager/ConfigurableComponentHolder.java
@@ -31,12 +31,12 @@
 
 import org.apache.felix.scr.impl.inject.ComponentMethods;
 import org.apache.felix.scr.impl.logger.ComponentLogger;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.ComponentMetadata;
 import org.apache.felix.scr.impl.metadata.ServiceMetadata.Scope;
 import org.apache.felix.scr.impl.metadata.TargetedPID;
 import org.osgi.framework.Constants;
 import org.osgi.service.component.ComponentConstants;
-import org.osgi.service.log.LogService;
 import org.osgi.util.promise.Deferred;
 import org.osgi.util.promise.Promise;
 import org.osgi.util.promise.Promises;
@@ -246,7 +246,8 @@ public final ComponentMetadata getComponentMetadata()
     @Override
     public void configurationDeleted( final TargetedPID pid, TargetedPID factoryPid )
     {
-        logger.log( LogService.LOG_DEBUG, "ImmediateComponentHolder configuration deleted for pid {0}", null, pid);
+        logger.log(Level.DEBUG,
+            "ImmediateComponentHolder configuration deleted for pid {0}", null, pid);
 
         // component to deconfigure or dispose of
         final Map<AbstractComponentManager<S>, Map<String, Object>> scms = new HashMap<>();
@@ -353,7 +354,7 @@ public void configurationDeleted( final TargetedPID pid, TargetedPID factoryPid
     @Override
     public boolean configurationUpdated( TargetedPID pid, TargetedPID factoryPid, final Dictionary<String, Object> props, long changeCount )
     {
-        logger.log(LogService.LOG_DEBUG,
+        logger.log(Level.DEBUG,
                 "ConfigurableComponentHolder configuration updated for pid {0} with change count {1}", null, pid,
                 changeCount);
 
@@ -434,16 +435,16 @@ else if ( m_factoryPidIndex != null)
         {
             // configure the component
             entry.getKey().reconfigure(entry.getValue(), false, factoryPid);
-            logger.log(LogService.LOG_DEBUG,
+            logger.log(Level.DEBUG,
                 "ImmediateComponentHolder Finished configuring the dependency managers for component for pid {0} ", null,
                 pid );
             if (enable) {
                 entry.getKey().enable(false);
-                logger.log(LogService.LOG_DEBUG,
+                logger.log(Level.DEBUG,
                     "ImmediateComponentHolder Finished enabling component for pid {0} ", null,
                     pid );
             } else {
-                logger.log(LogService.LOG_DEBUG,
+                logger.log(Level.DEBUG,
                     "ImmediateComponentHolder Will not enable component for pid {0}: holder enabled state: {1}, metadata enabled: {2} ", null,
                     pid, m_enabled, m_componentMetadata.isEnabled());
             }
@@ -500,7 +501,7 @@ else if ( m_configurations[i] != null )
     private int getSingletonPidIndex(TargetedPID pid) {
         int index = m_componentMetadata.getPidIndex(pid);
         if (index == -1) {
-            logger.log(LogService.LOG_ERROR,
+            logger.log(Level.ERROR,
                 "Unrecognized pid {0}, expected one of {1}", null,
                  pid,
                 m_componentMetadata.getConfigurationPid() );
@@ -508,7 +509,7 @@ private int getSingletonPidIndex(TargetedPID pid) {
                 + pid);
         }
         if (m_factoryPidIndex != null && index == m_factoryPidIndex) {
-            logger.log(LogService.LOG_ERROR,
+            logger.log(Level.ERROR,
                 "singleton pid {0} supplied, but matches an existing factory pid at index: {1}",
                 null, pid, m_factoryPidIndex );
             throw new IllegalStateException(
@@ -522,7 +523,7 @@ private int getSingletonPidIndex(TargetedPID pid) {
     private void checkFactoryPidIndex(TargetedPID factoryPid) {
         int index = m_componentMetadata.getPidIndex(factoryPid);
         if (index == -1) {
-            logger.log(LogService.LOG_ERROR,
+            logger.log(Level.ERROR,
                 "Unrecognized factory pid {0}, expected one of {1}", null,
                 factoryPid,
                 m_componentMetadata.getConfigurationPid() );
@@ -530,7 +531,7 @@ private void checkFactoryPidIndex(TargetedPID factoryPid) {
                 "Unrecognized factory pid " + factoryPid);
         }
         if (m_configurations[index] != null) {
-            logger.log(LogService.LOG_ERROR,
+            logger.log(Level.ERROR,
                 "factory pid {0}, but this pid is already supplied as a singleton: {1} at index {2}", null,
                 factoryPid, Arrays.asList(m_targetedPids), index);
             throw new IllegalStateException(
@@ -540,7 +541,7 @@ private void checkFactoryPidIndex(TargetedPID factoryPid) {
         if (m_factoryPidIndex == null) {
             m_factoryPidIndex = index;
         } else if (index != m_factoryPidIndex) {
-            logger.log(LogService.LOG_ERROR,
+            logger.log(Level.ERROR,
                 "factory pid {0} supplied for index {1}, but a factory pid previously supplied at index {2}", null,
                 factoryPid, index, m_factoryPidIndex );
             throw new IllegalStateException(
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/manager/DependencyManager.java b/scr/src/main/java/org/apache/felix/scr/impl/manager/DependencyManager.java
index c4b418e208..065e5158d0 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/manager/DependencyManager.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/manager/DependencyManager.java
@@ -37,6 +37,7 @@
 import org.apache.felix.scr.impl.inject.RefPair;
 import org.apache.felix.scr.impl.inject.ReferenceMethod;
 import org.apache.felix.scr.impl.inject.ReferenceMethods;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.ReferenceMetadata;
 import org.apache.felix.scr.impl.metadata.ReferenceMetadata.ReferenceScope;
 import org.apache.felix.scr.impl.metadata.ServiceMetadata.Scope;
@@ -48,7 +49,6 @@
 import org.osgi.framework.ServiceReference;
 import org.osgi.service.component.ComponentConstants;
 import org.osgi.service.component.ComponentException;
-import org.osgi.service.log.LogService;
 
 /**
  * The <code>DependencyManager</code> manages the references to services
@@ -94,9 +94,10 @@ public class DependencyManager<S, T> implements ReferenceManager<S, T>
         m_minCardinality = defaultMinimumCardinality(dependency);
 
         // dump the reference information if DEBUG is enabled
-        if (m_componentManager.getLogger().isLogEnabled(LogService.LOG_DEBUG))
+        if (m_componentManager.getLogger().isLogEnabled(Level.DEBUG))
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "Dependency Manager created {0}",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "Dependency Manager created {0}",
                 null, dependency.getDebugInfo());
         }
     }
@@ -154,7 +155,8 @@ private abstract class AbstractCustomizer implements Customizer<S, T>
         public void setTracker(ServiceTracker<T, RefPair<S, T>, ExtendedServiceEvent> tracker)
         {
             m_tracker = tracker;
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracker reset (closed)", null, getName() );
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracker reset (closed)", null, getName());
             trackerOpened = false;
         }
 
@@ -188,7 +190,8 @@ protected boolean isTrackerOpened()
         public void setTrackerOpened()
         {
             trackerOpened = true;
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracker opened", null, getName());
+            m_componentManager.getLogger().log(Level.DEBUG, "dm {0} tracker opened",
+                null, getName());
         }
 
         protected void deactivateTracker()
@@ -315,14 +318,15 @@ public RefPair<S, T> addingService(ServiceReference<T> serviceReference)
         public void addedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             int serviceCount, ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} MultipleDynamic added {2} (enter)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} MultipleDynamic added {2} (enter)",
                     null, getName(), trackingCount, serviceReference );
             boolean tracked = false;
             if (getPreviousRefMap().remove(serviceReference) == null)
             {
                 if (isActive())
                 {
-                    m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+                    m_componentManager.getLogger().log(Level.DEBUG,
                         "dm {0} tracking {1} MultipleDynamic already active, binding {2}",
                         null, getName(), trackingCount, serviceReference );
                     m_componentManager.invokeBindMethod(DependencyManager.this, refPair, trackingCount);
@@ -334,7 +338,8 @@ public void addedService(ServiceReference<T> serviceReference, RefPair<S, T> ref
                 }
                 else if (isTrackerOpened() && cardinalityJustSatisfied(serviceCount))
                 {
-                    m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} MultipleDynamic, activating",
+                    m_componentManager.getLogger().log(Level.DEBUG,
+                        "dm {0} tracking {1} MultipleDynamic, activating",
                             null, getName(), trackingCount);
                     tracked(trackingCount);
                     tracked = true;
@@ -342,12 +347,13 @@ else if (isTrackerOpened() && cardinalityJustSatisfied(serviceCount))
                 }
                 else
                 {
-                    m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+                    m_componentManager.getLogger().log(Level.DEBUG,
                         "dm {0} tracking {1} MultipleDynamic, inactive, doing nothing: tracker opened: {2}, optional: {3}",
                         null, getName(), trackingCount, isTrackerOpened(), isOptional() );
                 }
             }
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} MultipleDynamic added {2} (exit)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} MultipleDynamic added {2} (exit)",
                     null, getName(), trackingCount, serviceReference );
             if (!tracked)
             {
@@ -359,13 +365,15 @@ else if (isTrackerOpened() && cardinalityJustSatisfied(serviceCount))
         public void modifiedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} MultipleDynamic modified {2} (enter)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} MultipleDynamic modified {2} (enter)",
                     null, getName(), trackingCount, serviceReference );
             if (isActive())
             {
                 m_componentManager.invokeUpdatedMethod(DependencyManager.this, refPair, trackingCount);
             }
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} MultipleDynamic modified {2} (exit)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} MultipleDynamic modified {2} (exit)",
                     null, getName(), trackingCount, serviceReference );
             tracked(trackingCount);
         }
@@ -374,7 +382,8 @@ public void modifiedService(ServiceReference<T> serviceReference, RefPair<S, T>
         public void removedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} MultipleDynamic removed {2} (enter)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} MultipleDynamic removed {2} (enter)",
                     null, getName(), trackingCount, serviceReference );
             refPair.markDeleted();
             boolean unbind = cardinalitySatisfied();
@@ -384,7 +393,8 @@ public void removedService(ServiceReference<T> serviceReference, RefPair<S, T> r
                 {
                     m_componentManager.invokeUnbindMethod(DependencyManager.this, refPair, trackingCount);
                 }
-                m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} MultipleDynamic removed (unbind) {2}",
+                m_componentManager.getLogger().log(Level.DEBUG,
+                    "dm {0} tracking {1} MultipleDynamic removed (unbind) {2}",
                         null, getName(), trackingCount, serviceReference );
                 tracked(trackingCount);
             }
@@ -395,7 +405,7 @@ public void removedService(ServiceReference<T> serviceReference, RefPair<S, T> r
                 tracked(trackingCount);
                 deactivateComponentManager();
                 lastRefPair = null;
-                m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+                m_componentManager.getLogger().log(Level.DEBUG,
                     "dm {0} tracking {1} MultipleDynamic removed (deactivate) {2}",
                     null, getName(), trackingCount, serviceReference );
             }
@@ -484,12 +494,13 @@ public RefPair<S, T> addingService(ServiceReference<T> serviceReference)
         public void addedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             int serviceCount, ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} MultipleStaticGreedy added {2} (enter)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} MultipleStaticGreedy added {2} (enter)",
                     null, getName(), trackingCount, serviceReference );
             tracked(trackingCount);
             if (isActive())
             {
-                m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+                m_componentManager.getLogger().log(Level.DEBUG,
                     "Dependency Manager: Static dependency on {0}/{1} is broken",
                     null, getName(), m_dependencyMetadata.getInterface() );
                 deactivateComponentManager();
@@ -504,7 +515,8 @@ else if (isTrackerOpened() && cardinalityJustSatisfied(serviceCount))
             {
                 m_componentManager.activateInternal();
             }
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} MultipleStaticGreedy added {2} (exit)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} MultipleStaticGreedy added {2} (exit)",
                     null, getName(), trackingCount, serviceReference );
         }
 
@@ -512,7 +524,7 @@ else if (isTrackerOpened() && cardinalityJustSatisfied(serviceCount))
         public void modifiedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+            m_componentManager.getLogger().log(Level.DEBUG,
                 "dm {0} tracking {1} MultipleStaticGreedy modified {2} (enter)",
                 null, getName(), trackingCount, serviceReference );
             boolean reactivate = false;
@@ -529,7 +541,8 @@ public void modifiedService(ServiceReference<T> serviceReference, RefPair<S, T>
                     event.addComponentManager(m_componentManager);
                 }
             }
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} MultipleStaticGreedy modified {2} (exit)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} MultipleStaticGreedy modified {2} (exit)",
                     null, getName(), trackingCount, serviceReference );
         }
 
@@ -537,14 +550,15 @@ public void modifiedService(ServiceReference<T> serviceReference, RefPair<S, T>
         public void removedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} MultipleStaticGreedy removed {2} (enter)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} MultipleStaticGreedy removed {2} (enter)",
                     null, getName(), trackingCount, serviceReference );
             refPair.markDeleted();
             tracked(trackingCount);
             if (isActive())
             {
                 //deactivate while ref is still tracked
-                m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+                m_componentManager.getLogger().log(Level.DEBUG,
                     "Dependency Manager: Static dependency on {0}/{1} is broken",
                     null, getName(), m_dependencyMetadata.getInterface() );
                 deactivateComponentManager();
@@ -556,14 +570,15 @@ public void removedService(ServiceReference<T> serviceReference, RefPair<S, T> r
             }
             else if (!cardinalitySatisfied()) //may be called from an old tracker, so getTracker() may give a different answer
             {
-                m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+                m_componentManager.getLogger().log(Level.DEBUG,
                     "Dependency Manager: Static dependency on {0}/{1} is broken",
                     null, getName(), m_dependencyMetadata.getInterface() );
                 deactivateComponentManager();
             }
             //This is unlikely
             ungetService(refPair);
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} MultipleStaticGreedy removed {2} (exit)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} MultipleStaticGreedy removed {2} (exit)",
                     null, getName(), trackingCount, serviceReference );
         }
 
@@ -629,7 +644,7 @@ public RefPair<S, T> addingService(ServiceReference<T> serviceReference)
         public void addedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             int serviceCount, ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+            m_componentManager.getLogger().log(Level.DEBUG,
                 "dm {0} tracking {1} MultipleStaticReluctant added {2} (enter)",
                 null, getName(), trackingCount, serviceReference );
             tracked(trackingCount);
@@ -637,7 +652,8 @@ public void addedService(ServiceReference<T> serviceReference, RefPair<S, T> ref
             {
                 m_componentManager.activateInternal();
             }
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} MultipleStaticReluctant added {2} (exit)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} MultipleStaticReluctant added {2} (exit)",
                     null, getName(), trackingCount, serviceReference );
         }
 
@@ -645,7 +661,7 @@ public void addedService(ServiceReference<T> serviceReference, RefPair<S, T> ref
         public void modifiedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+            m_componentManager.getLogger().log(Level.DEBUG,
                 "dm {0} tracking {1} MultipleStaticReluctant modified {2} (enter)",
                 null, getName(), trackingCount, serviceReference );
             boolean reactivate = false;
@@ -663,7 +679,7 @@ public void modifiedService(ServiceReference<T> serviceReference, RefPair<S, T>
                     event.addComponentManager(m_componentManager);
                 }
             }
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+            m_componentManager.getLogger().log(Level.DEBUG,
                 "dm {0} tracking {1} MultipleStaticReluctant modified {2} (exit)",
                 null, getName(), trackingCount, serviceReference );
         }
@@ -672,7 +688,7 @@ public void modifiedService(ServiceReference<T> serviceReference, RefPair<S, T>
         public void removedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+            m_componentManager.getLogger().log(Level.DEBUG,
                 "dm {0} tracking {1} MultipleStaticReluctant removed {2} (enter)",
                 null, getName(), trackingCount, serviceReference );
             refPair.markDeleted();
@@ -683,7 +699,7 @@ public void removedService(ServiceReference<T> serviceReference, RefPair<S, T> r
                 if (refs.contains(refPair))
                 {
                     //we are tracking the used refs, so we can deactivate here.
-                    m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+                    m_componentManager.getLogger().log(Level.DEBUG,
                         "Dependency Manager: Static dependency on {0}/{1} is broken",
                         null, getName(), m_dependencyMetadata.getInterface() );
                     deactivateComponentManager();
@@ -698,13 +714,13 @@ public void removedService(ServiceReference<T> serviceReference, RefPair<S, T> r
             }
             else if (!cardinalitySatisfied())
             {
-                m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+                m_componentManager.getLogger().log(Level.DEBUG,
                     "Dependency Manager: Static dependency on {0}/{1} is broken",
                     null, getName(), m_dependencyMetadata.getInterface() );
                 deactivateComponentManager();
             }
             ungetService(refPair);
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+            m_componentManager.getLogger().log(Level.DEBUG,
                 "dm {0} tracking {1} MultipleStaticReluctant removed {2} (exit)",
                 null, getName(), trackingCount, serviceReference );
         }
@@ -807,7 +823,8 @@ public RefPair<S, T> addingService(ServiceReference<T> serviceReference)
         public void addedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             int serviceCount, ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} SingleDynamic added {2} (enter)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} SingleDynamic added {2} (enter)",
                     null, getName(), trackingCount, serviceReference );
             boolean tracked = false;
             if (getPreviousRefMap().remove(serviceReference) == null)
@@ -853,7 +870,8 @@ else if (isTrackerOpened() && cardinalityJustSatisfied(serviceCount))
                 }
             }
             this.trackingCount = trackingCount;
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} SingleDynamic added {2} (exit)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} SingleDynamic added {2} (exit)",
                     null, getName(), trackingCount, serviceReference );
             if (!tracked)
             {
@@ -865,7 +883,8 @@ else if (isTrackerOpened() && cardinalityJustSatisfied(serviceCount))
         public void modifiedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} SingleDynamic modified {2} (enter)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} SingleDynamic modified {2} (enter)",
                     null, getName(), trackingCount, serviceReference );
             boolean invokeUpdated = false;
             ServiceTracker<T, RefPair<S, T>, ExtendedServiceEvent> tracker = getTracker();
@@ -882,7 +901,8 @@ public void modifiedService(ServiceReference<T> serviceReference, RefPair<S, T>
                 m_componentManager.invokeUpdatedMethod(DependencyManager.this, refPair, trackingCount);
             }
             this.trackingCount = trackingCount;
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} SingleDynamic modified {2} (exit)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} SingleDynamic modified {2} (exit)",
                     null, getName(), trackingCount, serviceReference );
             tracked(trackingCount);
         }
@@ -891,7 +911,8 @@ public void modifiedService(ServiceReference<T> serviceReference, RefPair<S, T>
         public void removedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} SingleDynamic removed {2} (enter)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} SingleDynamic removed {2} (enter)",
                     null, getName(), trackingCount, serviceReference );
             refPair.markDeleted();
             boolean deactivate = false;
@@ -964,7 +985,8 @@ else if (deactivate)
                 this.trackingCount = trackingCount;
                 tracked(trackingCount);
             }
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} SingleDynamic removed {2} (exit)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} SingleDynamic removed {2} (exit)",
                     null, getName(), trackingCount, serviceReference );
         }
 
@@ -1057,7 +1079,8 @@ public RefPair<S, T> addingService(ServiceReference<T> serviceReference)
         public void addedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             int serviceCount, ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} SingleStatic added {2} (enter)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} SingleStatic added {2} (enter)",
                     null, getName(), trackingCount, serviceReference);
             this.trackingCount = trackingCount;
             tracked(trackingCount);
@@ -1081,7 +1104,7 @@ public void addedService(ServiceReference<T> serviceReference, RefPair<S, T> ref
                 }
                 else
                 {
-                    m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+                    m_componentManager.getLogger().log(Level.DEBUG,
                         "dm {0} tracking {1} SingleStatic active but new {2} is worse match than old {3}",
                         null, getName(), trackingCount, refPair, this.refPair);
                 }
@@ -1092,11 +1115,12 @@ else if (isTrackerOpened() && cardinalityJustSatisfied(serviceCount))
             }
             else
             {
-                m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+                m_componentManager.getLogger().log(Level.DEBUG,
                     "dm {0} tracking {1} SingleStatic active: {2} trackerOpened: {3} optional: {4}",
                     null, getName(), trackingCount, isActive(), isTrackerOpened(), isOptional() );
             }
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} SingleStatic added {2} (exit)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} SingleStatic added {2} (exit)",
                     null, getName(), trackingCount, serviceReference );
         }
 
@@ -1104,7 +1128,8 @@ else if (isTrackerOpened() && cardinalityJustSatisfied(serviceCount))
         public void modifiedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} SingleStatic modified {2} (enter)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} SingleStatic modified {2} (enter)",
                     null, getName(), trackingCount, serviceReference );
             boolean invokeUpdated;
             final Object sync = getTracker().tracked();
@@ -1134,7 +1159,8 @@ public void modifiedService(ServiceReference<T> serviceReference, RefPair<S, T>
                     event.addComponentManager(m_componentManager);
                 }
             }
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} SingleStatic modified {2} (exit)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} SingleStatic modified {2} (exit)",
                     null, getName(), trackingCount, serviceReference );
         }
 
@@ -1142,7 +1168,8 @@ public void modifiedService(ServiceReference<T> serviceReference, RefPair<S, T>
         public void removedService(ServiceReference<T> serviceReference, RefPair<S, T> refPair, int trackingCount,
             ExtendedServiceEvent event)
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} SingleStatic removed {2} (enter)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} SingleStatic removed {2} (enter)",
                     null, getName(), trackingCount, serviceReference );
             refPair.markDeleted();
             this.trackingCount = trackingCount;
@@ -1177,7 +1204,8 @@ public void removedService(ServiceReference<T> serviceReference, RefPair<S, T> r
                     }
                 }
             }
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "dm {0} tracking {1} SingleStatic removed {2} (exit)",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "dm {0} tracking {1} SingleStatic removed {2} (exit)",
                     null, getName(), trackingCount, serviceReference );
         }
 
@@ -1418,13 +1446,15 @@ private ServiceReference<T>[] getFrameworkServiceReferences(String targetFilter)
             }
             catch (InvalidSyntaxException ise)
             {
-                m_componentManager.getLogger().log(LogService.LOG_ERROR, "Unexpected problem with filter ''{0}''",
+                m_componentManager.getLogger().log(Level.ERROR,
+                    "Unexpected problem with filter ''{0}''",
                     ise, targetFilter );
                 return null;
             }
         }
 
-        m_componentManager.getLogger().log(LogService.LOG_DEBUG, "No permission to access the services", null);
+        m_componentManager.getLogger().log(Level.DEBUG,
+            "No permission to access the services", null);
         return null;
     }
 
@@ -1559,7 +1589,7 @@ private T getService(ComponentContextImpl<S> key, RefPair<S, T> refPair)
         final BundleContext bundleContext = m_componentManager.getBundleContext();
         if (bundleContext == null)
         {
-            m_componentManager.getLogger().log(LogService.LOG_ERROR,
+            m_componentManager.getLogger().log(Level.ERROR,
                 "Bundle shut down while getting service {0} ({1}/{2,number,#})", null, getName(),
                         m_dependencyMetadata.getInterface(), refPair.getRef().getProperty(Constants.SERVICE_ID) );
             return null;
@@ -1574,7 +1604,8 @@ private T getService(ComponentContextImpl<S> key, RefPair<S, T> refPair)
             // caused by getService() called on invalid bundle context
             // or if there is a service reference cycle involving service
             // factories !
-            m_componentManager.getLogger().log(LogService.LOG_ERROR, "Failed getting service {0} ({1}/{2,number,#})",
+            m_componentManager.getLogger().log(Level.ERROR,
+                "Failed getting service {0} ({1}/{2,number,#})",
                 e, getName(), m_dependencyMetadata.getInterface(),
                         refPair.getRef().getProperty(Constants.SERVICE_ID) );
             return null;
@@ -1667,7 +1698,8 @@ OpenStatus<S, T> open(ComponentContextImpl<S> componentContext, EdgeInfo edgeInf
             edgeInfo.setOpen(trackingCount.get());
             openLatch = edgeInfo.getOpenLatch();
         }
-        m_componentManager.getLogger().log(LogService.LOG_DEBUG, "For dependency {0}, optional: {1}; to bind: {2}",
+        m_componentManager.getLogger().log(Level.DEBUG,
+            "For dependency {0}, optional: {1}; to bind: {2}",
                 null, getName(), isOptional(), refs);
         for (RefPair<S, T> refPair : refs)
         {
@@ -1684,7 +1716,8 @@ boolean bind(final ComponentContextImpl<S> componentContext, final OpenStatus<S,
     {
         if (!invokeInitMethod(componentContext))
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "For dependency {0}, failed to initialize object",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "For dependency {0}, failed to initialize object",
                     null, getName());
             return false;
         }
@@ -1704,7 +1737,7 @@ boolean bindDependency(final ComponentContextImpl<S> componentContext,
             {
                 if (!doInvokeBindMethod(componentContext, bindMethod, refPair, trackingCount.get()))
                 {
-                    m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+                    m_componentManager.getLogger().log(Level.DEBUG,
                         "For dependency {0}, failed to invoke bind method on object {1}",
                         null, getName(), refPair );
 
@@ -1739,7 +1772,7 @@ void close(ComponentContextImpl<S> componentContext, EdgeInfo edgeInfo)
             latch = edgeInfo.getCloseLatch();
         }
 
-        m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+        m_componentManager.getLogger().log(Level.DEBUG,
             "DependencyManager: {0} close component unbinding from {1} at tracking count {2} refpairs: {3}",
             null, getName(), componentContext, trackingCount.get(), refPairs );
         m_componentManager.waitForTracked(trackingCount.get());
@@ -1791,7 +1824,7 @@ public void invokeBindMethodLate(final ServiceReference<T> ref, int trackingCoun
         //TODO this check is no longer correct, fix it!
         //        if (refPair.getServiceObject(key) != null)
         //        {
-        //            m_componentManager.getLogger().log( LogService.LOG_DEBUG,
+        //            m_componentManager.getLogger().log( LogLevel.DEBUG,
         //                    "DependencyManager : late binding of service reference {1} skipped as service has already been located",
         //                    new Object[] {ref}, null );
         //            //something else got the reference and may be binding it.
@@ -1859,7 +1892,7 @@ boolean invokeBindMethod(ComponentContextImpl<S> componentContext, RefPair<S, T>
         }
         else
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+            m_componentManager.getLogger().log(Level.DEBUG,
                 "DependencyManager : component not yet created, assuming bind method call succeeded", null);
 
             return true;
@@ -1873,7 +1906,7 @@ private boolean doInvokeBindMethod(ComponentContextImpl<S> componentContext,
     {
         if (!getServiceObject(componentContext, bindMethod, refPair))
         {
-            m_componentManager.getLogger().log(LogService.LOG_WARNING,
+            m_componentManager.getLogger().log(Level.WARN,
                 "DependencyManager : invokeBindMethod : Service not available from service registry for ServiceReference {0} for reference {1}",
                 null, refPair.getRef(), getName() );
             return false;
@@ -1925,7 +1958,7 @@ boolean invokeUpdatedMethod(ComponentContextImpl<S> componentContext, final RefP
             info.waitForOpen(m_componentManager, getName(), "invokeUpdatedMethod");
             if (!getServiceObject(componentContext, m_bindMethods.getUpdated(), refPair))
             {
-                m_componentManager.getLogger().log(LogService.LOG_WARNING,
+                m_componentManager.getLogger().log(Level.WARN,
                     "DependencyManager : invokeUpdatedMethod : Service not available from service registry for ServiceReference {0} for reference {1}",
                     null, refPair.getRef(), getName() );
                 return false;
@@ -1944,7 +1977,7 @@ boolean invokeUpdatedMethod(ComponentContextImpl<S> componentContext, final RefP
             // don't care whether we can or cannot call the updated method
             // if the component instance has already been cleared by the
             // close() method
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+            m_componentManager.getLogger().log(Level.DEBUG,
                 "DependencyManager : Component not set, no need to call updated method", null);
         }
         return false;
@@ -1999,7 +2032,7 @@ void invokeUnbindMethod(ComponentContextImpl<S> componentContext, final RefPair<
 
             if (!getServiceObject(componentContext, m_bindMethods.getUnbind(), refPair))
             {
-                m_componentManager.getLogger().log(LogService.LOG_WARNING,
+                m_componentManager.getLogger().log(Level.WARN,
                     "DependencyManager : invokeUnbindMethod : Service not available from service registry for ServiceReference {0} for reference {1}",
                     null, refPair.getRef(), getName() );
                 return;
@@ -2018,7 +2051,7 @@ void invokeUnbindMethod(ComponentContextImpl<S> componentContext, final RefPair<
             // don't care whether we can or cannot call the unbind method
             // if the component instance has already been cleared by the
             // close() method
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+            m_componentManager.getLogger().log(Level.DEBUG,
                 "DependencyManager : Component not set, no need to call unbind method", null);
         }
     }
@@ -2119,7 +2152,7 @@ private int getMinimumCardinality(Map<String, Object> properties)
         }
         catch (ComponentException e)
         {
-            m_componentManager.getLogger().log(LogService.LOG_WARNING,
+            m_componentManager.getLogger().log(Level.WARN,
                 "Invalid minimum cardinality property for dependency {0}: {1}",
                 null, getName(), e.getMessage());
         }
@@ -2159,7 +2192,7 @@ private void setTargetFilter(String target, int minimumCardinality)
         // do nothing if target filter does not change
         if ((m_target == null && target == null) || (m_target != null && m_target.equals(target)))
         {
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+            m_componentManager.getLogger().log(Level.DEBUG,
                 "No change in target property for dependency {0}: currently registered: {1}",
                 null, getName(), m_tracker != null );
             if (m_tracker != null)
@@ -2176,7 +2209,7 @@ private void setTargetFilter(String target, int minimumCardinality)
             }
             catch (InvalidSyntaxException e)
             {
-                m_componentManager.getLogger().log(LogService.LOG_ERROR,
+                m_componentManager.getLogger().log(Level.ERROR,
                         "Invalid syntax in target property for dependency {0} to {1}", null,
                         getName(), target);
 
@@ -2234,13 +2267,14 @@ private void setTargetFilter(String target, int minimumCardinality)
             //wait for service events to complete before processing initial set from new tracker.
             m_componentManager.waitForTracked(trackingCount.get());
         }
-        m_componentManager.getLogger().log(LogService.LOG_DEBUG, "Setting target property for dependency {0} to {1}",
+        m_componentManager.getLogger().log(Level.DEBUG,
+            "Setting target property for dependency {0} to {1}",
                 null, getName(), target );
         BundleContext bundleContext = m_componentManager.getBundleContext();
 
         m_customizer.setPreviousRefMap(refMap);
         boolean initialActive = oldTracker != null && oldTracker.isActive();
-        m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+        m_componentManager.getLogger().log(Level.DEBUG,
             "New service tracker for {0}, initial active: {1}, previous references: {2}, classFilter: {3}, initialReferenceFilter {4}",
             null, getName(), initialActive, refMap, classFilterString,
                     initialReferenceFilterString );
@@ -2257,7 +2291,8 @@ null, getName(), initialActive, refMap, classFilterString,
         {
             oldTracker.completeClose(refMap);
         }
-        m_componentManager.getLogger().log(LogService.LOG_DEBUG, "registering service listener for dependency {0}",
+        m_componentManager.getLogger().log(Level.DEBUG,
+            "registering service listener for dependency {0}",
                 null, getName());
     }
 
@@ -2267,7 +2302,8 @@ private Customizer<S, T> newCustomizer()
         if (!hasGetPermission())
         {
             customizer = new NoPermissionsCustomizer();
-            m_componentManager.getLogger().log(LogService.LOG_INFO, "No permission to get services for {0}",
+            m_componentManager.getLogger().log(Level.INFO,
+                "No permission to get services for {0}",
                     null, getName());
         }
         else if (m_componentManager.isFactory())
@@ -2314,13 +2350,14 @@ SortedMap<ServiceReference<T>, RefPair<S, T>> unregisterServiceListener(AtomicIn
         {
             refMap = tracker.close(trackingCount);
             m_tracker = null;
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG, "unregistering service listener for dependency {0}",
+            m_componentManager.getLogger().log(Level.DEBUG,
+                "unregistering service listener for dependency {0}",
                     null, getName());
         }
         else
         {
             refMap = new TreeMap<>(Collections.reverseOrder());
-            m_componentManager.getLogger().log(LogService.LOG_DEBUG,
+            m_componentManager.getLogger().log(Level.DEBUG,
                 " No existing service listener to unregister for dependency {0}", null, getName());
             trackingCount.set(-1);
         }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/manager/EdgeInfo.java b/scr/src/main/java/org/apache/felix/scr/impl/manager/EdgeInfo.java
index 5024aa4648..034ca288da 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/manager/EdgeInfo.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/manager/EdgeInfo.java
@@ -21,7 +21,7 @@
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
-import org.osgi.service.log.LogService;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 
 /**
  * EdgeInfo holds information about the service event tracking counts for creating (open) and disposing (close)
@@ -86,7 +86,7 @@ private void waitForLatch(AbstractComponentManager<?> m_componentManager, CountD
         {
             if (!latch.await( m_componentManager.getLockTimeout(), TimeUnit.MILLISECONDS ))
             {
-                m_componentManager.getLogger().log( LogService.LOG_ERROR,
+                m_componentManager.getLogger().log(Level.ERROR,
                         "DependencyManager : {0} : timeout on {1} latch {2}",  null, methodName, latchName, componentName );
                 m_componentManager.dumpThreads();
             }
@@ -97,14 +97,14 @@ private void waitForLatch(AbstractComponentManager<?> m_componentManager, CountD
             {
                 if (!latch.await( m_componentManager.getLockTimeout(), TimeUnit.MILLISECONDS ))
                 {
-                    m_componentManager.getLogger().log( LogService.LOG_ERROR,
+                    m_componentManager.getLogger().log(Level.ERROR,
                             "DependencyManager : {0} : timeout on {1} latch {2}",  null, methodName, latchName, componentName );
                     m_componentManager.dumpThreads();
                 }
             }
             catch ( InterruptedException e1 )
             {
-                m_componentManager.getLogger().log( LogService.LOG_ERROR,
+                m_componentManager.getLogger().log(Level.ERROR,
                         "DependencyManager : {0} : Interrupted twice on {1} latch {2}",
                         null, methodName, latchName, componentName );
                 Thread.currentThread().interrupt();
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/manager/RegionConfigurationSupport.java b/scr/src/main/java/org/apache/felix/scr/impl/manager/RegionConfigurationSupport.java
index f48e2e7004..a5d431300e 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/manager/RegionConfigurationSupport.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/manager/RegionConfigurationSupport.java
@@ -31,6 +31,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.apache.felix.scr.impl.ComponentRegistry;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.logger.ScrLogger;
 import org.apache.felix.scr.impl.metadata.TargetedPID;
 import org.osgi.framework.Bundle;
@@ -46,7 +47,6 @@
 import org.osgi.service.cm.ConfigurationListener;
 import org.osgi.service.cm.ConfigurationPermission;
 import org.osgi.service.cm.ManagedService;
-import org.osgi.service.log.LogService;
 
 public abstract class RegionConfigurationSupport
 {
@@ -180,7 +180,7 @@ public boolean configureComponentHolder(final ComponentHolder<?> holder)
                         {
                             try
                             {
-                                logger.log(LogService.LOG_DEBUG,
+                                logger.log(Level.DEBUG,
                                     "Configuring holder {0} with change count {1}", null,
                                     holder, config.getChangeCount());
                                 if (checkBundleLocation(config,
@@ -214,7 +214,7 @@ public boolean configureComponentHolder(final ComponentHolder<?> holder)
                         {
                             try
                             {
-                                logger.log(LogService.LOG_DEBUG,
+                                logger.log(Level.DEBUG,
                                     "Configuring holder {0} with change count {1}", null,
                                     holder, singleton.getChangeCount());
                                 if (singleton != null && checkBundleLocation(singleton,
@@ -287,7 +287,7 @@ public void configurationEvent(ConfigurationEvent event)
         // (since DS 1.2, components may specify a specific configuration PID (112.4.4 configuration-pid)
         Collection<ComponentHolder<?>> holders = getComponentHolders( factoryPid != null? factoryPid: pid );
 
-        logger.log( LogService.LOG_DEBUG,
+        logger.log(Level.DEBUG,
             "configurationEvent: Handling {0} of Configuration PID={1} for component holders {2}", null,
             getEventType( event ), pid, holders );
 
@@ -370,7 +370,7 @@ public void configurationEvent(ConfigurationEvent event)
                                 componentHolder, bundleContext );
                             if ( configInfo != null )
                             {
-                                logger.log( LogService.LOG_DEBUG,
+                                logger.log(Level.DEBUG,
                                     "LocationChanged event, same targetedPID {0}, location now {1}, change count {2}", null,
                                     targetedPid, configInfo.getBundleLocation(),
                                             configInfo.getChangeCount() );
@@ -401,7 +401,7 @@ public void configurationEvent(ConfigurationEvent event)
                                 componentHolder, bundleContext );
                             if ( configInfo != null )
                             {
-                                logger.log( LogService.LOG_DEBUG,
+                                logger.log(Level.DEBUG,
                                     "LocationChanged event, better targetedPID {0} compared to {1}, location now {2}, change count {3}", null,
                                      targetedPid, oldTargetedPID, configInfo.getBundleLocation(),
                                             configInfo.getChangeCount());
@@ -426,14 +426,15 @@ public void configurationEvent(ConfigurationEvent event)
                         //else worse match, do nothing
                         else
                         {
-                            logger.log( LogService.LOG_DEBUG,
+                            logger.log(Level.DEBUG,
                                 "LocationChanged event, worse targetedPID {0} compared to {1}, do nothing", null,
                                 targetedPid, oldTargetedPID  );
                         }
                         break;
                     }
                     default:
-                        logger.log( LogService.LOG_WARNING, "Unknown ConfigurationEvent type {0}", null,
+                        logger.log(Level.WARN,
+                            "Unknown ConfigurationEvent type {0}", null,
                             event.getType() );
                 }
             }
@@ -533,11 +534,13 @@ private ConfigurationInfo getConfigurationInfo(final TargetedPID pid, TargetedPI
             }
             catch ( IOException e )
             {
-                logger.log( LogService.LOG_WARNING, "Failed reading configuration for pid={0}", e, pid);
+                logger.log(Level.WARN, "Failed reading configuration for pid={0}",
+                    e, pid);
             }
             catch ( InvalidSyntaxException e )
             {
-                logger.log( LogService.LOG_WARNING, "Failed reading configuration for pid={0}", e, pid);
+                logger.log(Level.WARN, "Failed reading configuration for pid={0}",
+                    e, pid);
             }
             finally
             {
@@ -547,7 +550,7 @@ private ConfigurationInfo getConfigurationInfo(final TargetedPID pid, TargetedPI
         catch ( IllegalStateException ise )
         {
             // If the bundle has been stopped concurrently
-            logger.log(LogService.LOG_DEBUG, "Bundle in unexpected state", ise);
+            logger.log(Level.DEBUG, "Bundle in unexpected state", ise);
         }
         return null;
     }
@@ -714,7 +717,8 @@ else if ( configBundleLocation.startsWith( "?" ) )
         {
             result = configBundleLocation.equals( bundle.getLocation() );
         }
-        logger.log( LogService.LOG_DEBUG, "checkBundleLocation: location {0}, returning {1}", null,
+        logger.log(Level.DEBUG, "checkBundleLocation: location {0}, returning {1}",
+            null,
             configBundleLocation, result );
         return result;
     }
@@ -727,12 +731,14 @@ private Configuration[] findConfigurations(final ConfigurationAdmin ca, final St
         }
         catch ( IOException ioe )
         {
-            logger.log( LogService.LOG_WARNING, "Problem listing configurations for filter={0}", ioe,
+            logger.log(Level.WARN, "Problem listing configurations for filter={0}",
+                ioe,
                 filter  );
         }
         catch ( InvalidSyntaxException ise )
         {
-            logger.log( LogService.LOG_ERROR, "Invalid Configuration selection filter {0}", ise, filter);
+            logger.log(Level.ERROR, "Invalid Configuration selection filter {0}", ise,
+                filter);
         }
 
         // no factories in case of problems
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/manager/RegistrationManager.java b/scr/src/main/java/org/apache/felix/scr/impl/manager/RegistrationManager.java
index fa0616fae4..9602fc868a 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/manager/RegistrationManager.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/manager/RegistrationManager.java
@@ -25,7 +25,7 @@
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 
-import org.osgi.service.log.LogService;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 
 abstract class RegistrationManager<T>
 {
@@ -92,13 +92,15 @@ boolean changeRegistration( RegState desired, String[] services )
             {
                 if ((desired == RegState.unregistered) == (m_serviceRegistration == null))
                 {
-                    log( LogService.LOG_DEBUG, "Already in desired state {0}", null, desired);
+                    log(Level.DEBUG, "Already in desired state {0}", null, desired);
                     return false;
                 }
             }
             else if (opqueue.get( opqueue.size() - 1 ).getRegState() == desired)
             {
-                log( LogService.LOG_DEBUG, "Duplicate request on other thread: registration change queue {0}", null, opqueue);
+                log(Level.DEBUG,
+                    "Duplicate request on other thread: registration change queue {0}",
+                    null, opqueue);
                 rsw = opqueue.get( opqueue.size() - 1 );
                 return false; //another thread will do our work and owns the state change
             }
@@ -106,13 +108,16 @@ else if (opqueue.get( opqueue.size() - 1 ).getRegState() == desired)
             opqueue.add( rsw );
             if (opqueue.size() > 1)
             {
-                log( LogService.LOG_DEBUG, "Allowing other thread to process request: registration change queue {0}", null, opqueue);
+                log(Level.DEBUG,
+                    "Allowing other thread to process request: registration change queue {0}",
+                    null, opqueue);
                 return true; //some other thread will do it later but this thread owns the state change.
             }
             //we're next
             do
             {
-                log( LogService.LOG_DEBUG, "registration change queue {0}", null, opqueue);;
+                log(Level.DEBUG, "registration change queue {0}", null, opqueue);
+                ;
                 RegStateWrapper next = opqueue.get( 0 );
                 T serviceRegistration = m_serviceRegistration;
                 if ( next.getRegState() == RegState.unregistered)
@@ -136,7 +141,9 @@ else if (opqueue.get( opqueue.size() - 1 ).getRegState() == desired)
                         }
                         else
                         {
-                            log( LogService.LOG_ERROR, "Unexpected unregistration request with no registration present",  new Exception("Stack trace"));
+                            log(Level.ERROR,
+                                "Unexpected unregistration request with no registration present",
+                                new Exception("Stack trace"));
 
                         }
                     }
@@ -165,7 +172,9 @@ else if (opqueue.get( opqueue.size() - 1 ).getRegState() == desired)
                 {
                     if ( !rsw.getLatch().await( getTimeout(), TimeUnit.MILLISECONDS ))
                     {
-                        log( LogService.LOG_ERROR, "Timeout waiting for reg change to complete {0}", null, rsw.getRegState());
+                        log(Level.ERROR,
+                            "Timeout waiting for reg change to complete {0}", null,
+                            rsw.getRegState());
                         reportTimeout();
                     }
                 }
@@ -175,13 +184,17 @@ else if (opqueue.get( opqueue.size() - 1 ).getRegState() == desired)
                     {
                         if ( !rsw.getLatch().await( getTimeout(), TimeUnit.MILLISECONDS ))
                         {
-                            log( LogService.LOG_ERROR, "Timeout waiting for reg change to complete {0}", null, rsw.getRegState());
+                            log(Level.ERROR,
+                                "Timeout waiting for reg change to complete {0}", null,
+                                rsw.getRegState());
                             reportTimeout();
                         }
                     }
                     catch ( InterruptedException e1 )
                     {
-                        log( LogService.LOG_ERROR, "Interrupted twice waiting for reg change to complete {0}",null, rsw.getRegState());
+                        log(Level.ERROR,
+                            "Interrupted twice waiting for reg change to complete {0}",
+                            null, rsw.getRegState());
                     }
                     Thread.currentThread().interrupt();
                 }
@@ -196,7 +209,7 @@ else if (opqueue.get( opqueue.size() - 1 ).getRegState() == desired)
 
     abstract void unregister(T serviceRegistration);
 
-    abstract void log( int level, String message, Throwable ex, Object... arguments );
+    abstract void log(Level level, String message, Throwable ex, Object... arguments);
 
     abstract long getTimeout();
 
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/manager/ScrConfiguration.java b/scr/src/main/java/org/apache/felix/scr/impl/manager/ScrConfiguration.java
index d7d591e08e..77881e03e1 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/manager/ScrConfiguration.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/manager/ScrConfiguration.java
@@ -18,6 +18,7 @@
  */
 package org.apache.felix.scr.impl.manager;
 
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 
 /**
  * The <code>ScrConfiguration</code> class conveys configuration for the
@@ -74,7 +75,7 @@ public interface ScrConfiguration
      * Returns the current log level.
      * @return
      */
-    int getLogLevel();
+    Level getLogLevel();
 
 
     boolean isFactoryEnabled();
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/manager/ServiceFactoryComponentManager.java b/scr/src/main/java/org/apache/felix/scr/impl/manager/ServiceFactoryComponentManager.java
index 3b600d29f4..a3ba9a1cdc 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/manager/ServiceFactoryComponentManager.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/manager/ServiceFactoryComponentManager.java
@@ -28,11 +28,11 @@
 import org.apache.felix.scr.impl.inject.LifecycleMethod;
 import org.apache.felix.scr.impl.inject.MethodResult;
 import org.apache.felix.scr.impl.inject.RefPair;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.ServiceRegistration;
 import org.osgi.service.component.ComponentConstants;
 import org.osgi.service.component.ComponentInstance;
-import org.osgi.service.log.LogService;
 
 
 /**
@@ -82,7 +82,8 @@ protected void deleteComponent( int reason )
         for (ComponentContextImpl<S> componentContext: getComponentContexts() )
         {
             disposeImplementationObject( componentContext, reason );
-            getLogger().log( LogService.LOG_DEBUG, "Unset implementation object for component in deleteComponent for reason {0}",
+            getLogger().log(Level.DEBUG,
+                "Unset implementation object for component in deleteComponent for reason {0}",
                     null, REASONS[ reason ] );
         }
         serviceContexts.clear();
@@ -96,14 +97,14 @@ protected void deleteComponent( int reason )
     @Override
     public S getService( Bundle bundle, ServiceRegistration<S> serviceRegistration )
     {
-        getLogger().log( LogService.LOG_DEBUG, "ServiceFactory.getService()", null );
+        getLogger().log(Level.DEBUG, "ServiceFactory.getService()", null);
 
         // When the getServiceMethod is called, the implementation object must be created
 
         ComponentContextImpl<S> componentContext = new ComponentContextImpl<>(this, bundle, serviceRegistration);
         if (collectDependencies(componentContext) )
         {
-            getLogger().log( LogService.LOG_DEBUG,
+            getLogger().log(Level.DEBUG,
                     "getService (ServiceFactory) dependencies collected.",
                     null );
 
@@ -142,7 +143,8 @@ public void resetImplementationObject( S implementationObject )
         {
             // log that the service factory component cannot be created (we don't
             // know why at this moment; this should already have been logged)
-            getLogger().log( LogService.LOG_DEBUG, "Failed creating the component instance; see log for reason", null );
+            getLogger().log(Level.DEBUG,
+                "Failed creating the component instance; see log for reason", null);
         }
         else
         {
@@ -159,7 +161,7 @@ public void resetImplementationObject( S implementationObject )
     @Override
     public void ungetService( Bundle bundle, ServiceRegistration<S> registration, S service )
     {
-        getLogger().log( LogService.LOG_DEBUG, "ServiceFactory.ungetService()", null );
+        getLogger().log(Level.DEBUG, "ServiceFactory.ungetService()", null);
 
         // When the ungetServiceMethod is called, the implementation object must be deactivated
         // private ComponentContext and implementation instances
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/manager/SingleComponentManager.java b/scr/src/main/java/org/apache/felix/scr/impl/manager/SingleComponentManager.java
index 7030bc14a4..cbc68c008b 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/manager/SingleComponentManager.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/manager/SingleComponentManager.java
@@ -34,6 +34,7 @@
 import org.apache.felix.scr.impl.inject.OpenStatus;
 import org.apache.felix.scr.impl.inject.RefPair;
 import org.apache.felix.scr.impl.inject.ReferenceMethod;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.DSVersion;
 import org.apache.felix.scr.impl.metadata.ReferenceMetadata;
 import org.apache.felix.scr.impl.metadata.TargetedPID;
@@ -44,7 +45,6 @@
 import org.osgi.framework.ServiceRegistration;
 import org.osgi.service.component.ComponentConstants;
 import org.osgi.service.component.ComponentInstance;
-import org.osgi.service.log.LogService;
 import org.osgi.util.promise.Deferred;
 
 
@@ -135,7 +135,8 @@ public void resetImplementationObject( S implementationObject )
             }
 
             // otherwise set the context and component instance and return true
-           getLogger().log( LogService.LOG_DEBUG, "Set implementation object for component", null );
+            getLogger().log(Level.DEBUG, "Set implementation object for component",
+                null);
 
             //notify that component was successfully created so any optional circular dependencies can be retried
            try
@@ -163,7 +164,9 @@ protected void deleteComponent( final int reason )
             m_useCount.set( 0 );
             disposeImplementationObject( m_componentContext, reason );
             m_componentContext = null;
-            getLogger().log( LogService.LOG_DEBUG, "Unset and deconfigured implementation object for component in deleteComponent for reason {0}", null, REASONS[ reason ] );
+            getLogger().log(Level.DEBUG,
+                "Unset and deconfigured implementation object for component in deleteComponent for reason {0}",
+                null, REASONS[reason]);
             clearServiceProperties();
         }
     }
@@ -233,7 +236,9 @@ protected S createImplementationObject( Bundle usingBundle, SetImplementationObj
         Bundle bundle = getBundle();
         if (bundle == null)
         {
-            getLogger().log( LogService.LOG_WARNING, "Bundle shut down during instantiation of the implementation object", null);
+            getLogger().log(Level.WARN,
+                "Bundle shut down during instantiation of the implementation object",
+                null);
             return null;
         }
 
@@ -251,7 +256,8 @@ protected S createImplementationObject( Bundle usingBundle, SetImplementationObj
             OpenStatus<S, ?> open = dm.open(componentContext, componentContext.getEdgeInfo(dm));
             if ( open == null )
             {
-                getLogger().log( LogService.LOG_DEBUG, "Cannot create component instance due to failure to bind reference {0}",
+                getLogger().log(Level.DEBUG,
+                    "Cannot create component instance due to failure to bind reference {0}",
                         null, dm.getName()  );
 
                 failed = true;
@@ -262,7 +268,8 @@ protected S createImplementationObject( Bundle usingBundle, SetImplementationObj
             {
                 if ( !dm.bindDependency(componentContext, ReferenceMethod.NOPReferenceMethod, (OpenStatus) open) )
                 {
-                    getLogger().log( LogService.LOG_DEBUG, "Cannot create component instance due to failure to bind reference {0}",
+                    getLogger().log(Level.DEBUG,
+                        "Cannot create component instance due to failure to bind reference {0}",
                             null, dm.getName()  );
                     failed = true;
                     break;
@@ -284,14 +291,18 @@ protected S createImplementationObject( Bundle usingBundle, SetImplementationObj
             catch ( final InstantiationException ie)
             {
                 // we don't need to log the stack trace
-                getLogger().log( LogService.LOG_ERROR, "Error during instantiation of the implementation object: " + ie.getMessage(), null );
+                getLogger().log(Level.ERROR,
+                    "Error during instantiation of the implementation object: "
+                        + ie.getMessage(),
+                    null);
                 this.setFailureReason(ie);
                 return null;
             }
             catch ( final Throwable t )
             {
                 // failed to instantiate, return null
-                getLogger().log( LogService.LOG_ERROR, "Error during instantiation of the implementation object", t );
+                getLogger().log(Level.ERROR,
+                    "Error during instantiation of the implementation object", t);
                 this.setFailureReason(t);
                 return null;
             }
@@ -308,7 +319,8 @@ protected S createImplementationObject( Bundle usingBundle, SetImplementationObj
                 final OpenStatus<S, ?> open = iter.next();
                 if ( !dm.bind(componentContext, (OpenStatus) open) )
                 {
-                    getLogger().log( LogService.LOG_DEBUG, "Cannot create component instance due to failure to bind reference {0}",
+                    getLogger().log(Level.DEBUG,
+                        "Cannot create component instance due to failure to bind reference {0}",
                             null, dm.getName()  );
                     failed = true;
                     break;
@@ -625,7 +637,9 @@ private void updateServiceRegistration()
                 }
                 else
                 {
-                    getLogger().log( LogService.LOG_DEBUG, "Not updating service registration, no change in properties", null );
+                    getLogger().log(Level.DEBUG,
+                        "Not updating service registration, no change in properties",
+                        null);
                 }
             }
             catch ( final IllegalStateException ise )
@@ -634,17 +648,18 @@ private void updateServiceRegistration()
             }
             catch ( final IllegalArgumentException iae )
             {
-                getLogger().log( LogService.LOG_ERROR,
+                getLogger().log(Level.ERROR,
                         "Unexpected configuration property problem when updating service registration", iae );
             }
             catch ( final Throwable t )
             {
-                getLogger().log( LogService.LOG_ERROR, "Unexpected problem when updating service registration", t );
+                getLogger().log(Level.ERROR,
+                    "Unexpected problem when updating service registration", t);
             }
         }
         else
         {
-            getLogger().log( LogService.LOG_DEBUG, "No service registration to update", null );
+            getLogger().log(Level.DEBUG, "No service registration to update", null);
         }
     }
 
@@ -689,7 +704,9 @@ void reconfigure(boolean configurationDeleted)
             if ( !getState().isEnabled() )
             {
                 // nothing to do for inactive components, leave this method
-                getLogger().log( LogService.LOG_DEBUG, "Component can not be activated since it is in state {0}", null, getState() );
+                getLogger().log(Level.DEBUG,
+                    "Component can not be activated since it is in state {0}", null,
+                    getState());
                 //enabling the component will set the target properties, do nothing now.
                 return;
             }
@@ -701,7 +718,8 @@ void reconfigure(boolean configurationDeleted)
             {
                 if ( !getState().isSatisfied() && !getComponentMetadata().isConfigurationIgnored() )
                 {
-                    getLogger().log( LogService.LOG_DEBUG, "Attempting to activate unsatisfied component", null );
+                    getLogger().log(Level.DEBUG,
+                        "Attempting to activate unsatisfied component", null);
                     updateTargets( getProperties() );
                     releaseActivationWriteeLock(  );
                     activateInternal( );
@@ -711,7 +729,9 @@ void reconfigure(boolean configurationDeleted)
                 if ( !modify(configurationDeleted) )
                 {
                     // SCR 112.7.1 - deactivate if configuration is deleted or no modified method declared
-                    getLogger().log( LogService.LOG_DEBUG, "Deactivating and Activating to reconfigure from configuration", null );
+                    getLogger().log(Level.DEBUG,
+                        "Deactivating and Activating to reconfigure from configuration",
+                        null);
                     int reason = configurationDeleted ? ComponentConstants.DEACTIVATION_REASON_CONFIGURATION_DELETED
                             : ComponentConstants.DEACTIVATION_REASON_CONFIGURATION_MODIFIED;
 
@@ -760,7 +780,8 @@ private boolean modify(boolean configurationDeleted)
         // 1. no live update if there is no declared method
         if ( getComponentMetadata().getModified() == null )
         {
-            getLogger().log( LogService.LOG_DEBUG, "No modified method, cannot update dynamically", null );
+            getLogger().log(Level.DEBUG,
+                "No modified method, cannot update dynamically", null);
             return false;
         }
         // invariant: we have a modified method name
@@ -775,7 +796,7 @@ private boolean modify(boolean configurationDeleted)
         {
             if ( !dm.canUpdateDynamically( props ) )
             {
-                getLogger().log( LogService.LOG_DEBUG,
+                getLogger().log(Level.DEBUG,
                         "Cannot dynamically update the configuration due to dependency changes induced on dependency {0}",
                         null, dm.getName() );
                 return false;
@@ -795,7 +816,8 @@ private boolean modify(boolean configurationDeleted)
             if ( result == null )
             {
                 // log an error if the declared method cannot be found
-                getLogger().log( LogService.LOG_ERROR, "Declared modify method ''{0}'' cannot be found, configuring by reactivation",
+                getLogger().log(Level.ERROR,
+                    "Declared modify method ''{0}'' cannot be found, configuring by reactivation",
                         null, getComponentMetadata().getModified() );
                 return false;
             }
@@ -805,7 +827,7 @@ private boolean modify(boolean configurationDeleted)
             // this dynamic update and have the component be deactivated
             if ( !verifyDependencyManagers() )
             {
-                getLogger().log( LogService.LOG_DEBUG,
+                getLogger().log(Level.DEBUG,
                         "Updating the service references caused at least one reference to become unsatisfied, deactivating component",
                         null );
                 return false;
@@ -936,13 +958,13 @@ boolean getServiceInternal(ServiceRegistration<S> serviceRegistration)
             ComponentContextImpl<S> componentContext = new ComponentContextImpl<>(this, this.getBundle(), serviceRegistration);
             if ( collectDependencies(componentContext))
             {
-                getLogger().log( LogService.LOG_DEBUG,
+                getLogger().log(Level.DEBUG,
                         "getService (single component manager) dependencies collected.",
                         null );
             }
             else
             {
-                getLogger().log( LogService.LOG_INFO,
+                getLogger().log(Level.INFO,
                         "Could not obtain all required dependencies, getService returning null",
                         null );
                 return false;
@@ -988,7 +1010,8 @@ private S getService(ComponentContextImpl<S> componentContext)
 
         // log that the delayed component cannot be created (we don't
         // know why at this moment; this should already have been logged)
-        getLogger().log( LogService.LOG_DEBUG, "Failed creating the component instance; see log for reason", null );
+        getLogger().log(Level.DEBUG,
+            "Failed creating the component instance; see log for reason", null);
 
         // component could not really be created. This may be temporary
         // so we stay in the registered state but ensure the component
@@ -999,7 +1022,8 @@ private S getService(ComponentContextImpl<S> componentContext)
         }
         catch ( final Throwable t )
         {
-            getLogger().log( LogService.LOG_DEBUG, "Cannot delete incomplete component instance. Ignoring.", t );
+            getLogger().log(Level.DEBUG,
+                "Cannot delete incomplete component instance. Ignoring.", t);
         }
 
         // no service can be returned (be prepared for more logging !!)
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/manager/SingleRefPair.java b/scr/src/main/java/org/apache/felix/scr/impl/manager/SingleRefPair.java
index 59eb7c3792..75771573f9 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/manager/SingleRefPair.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/manager/SingleRefPair.java
@@ -24,9 +24,9 @@
 
 import org.apache.felix.scr.impl.inject.RefPair;
 import org.apache.felix.scr.impl.inject.ScrComponentContext;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.ServiceReference;
-import org.osgi.service.log.LogService;
 
 /**
  * @version $Rev$ $Date$
@@ -90,7 +90,7 @@ public boolean getServiceObject(ScrComponentContext key, BundleContext context)
         {
             markFailed();
             key.getLogger().log(
-                 LogService.LOG_WARNING,
+                Level.WARN,
                  "Could not get service from ref {0}", null, getRef() );
             return false;
         }
diff --git a/scr/src/main/java/org/apache/felix/scr/impl/xml/XmlHandler.java b/scr/src/main/java/org/apache/felix/scr/impl/xml/XmlHandler.java
index 948d819e54..4197d747ab 100644
--- a/scr/src/main/java/org/apache/felix/scr/impl/xml/XmlHandler.java
+++ b/scr/src/main/java/org/apache/felix/scr/impl/xml/XmlHandler.java
@@ -27,13 +27,13 @@
 import java.util.Properties;
 
 import org.apache.felix.scr.impl.logger.BundleLogger;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.ComponentMetadata;
 import org.apache.felix.scr.impl.metadata.DSVersion;
 import org.apache.felix.scr.impl.metadata.PropertyMetadata;
 import org.apache.felix.scr.impl.metadata.ReferenceMetadata;
 import org.apache.felix.scr.impl.metadata.ServiceMetadata;
 import org.osgi.framework.Bundle;
-import org.osgi.service.log.LogService;
 import org.xml.sax.Attributes;
 import org.xml.sax.SAXException;
 import org.xml.sax.helpers.DefaultHandler;
@@ -237,7 +237,7 @@ else if ( !namespaceCode.isDS13() )
                 // not inside a component element, ignore current element
                 else if ( !this.isComponent )
                 {
-                    m_logger.log( LogService.LOG_DEBUG,
+                    m_logger.log(Level.DEBUG,
                             "Not currently parsing a component; ignoring element {0} (bundle {1})", null,
                                     localName, m_bundle.getLocation() );
                 }
@@ -419,7 +419,8 @@ else if ( localName.equals( XmlConstants.EL_REF ) )
                 // used by the Maven SCR Plugin, which is just silently ignored)
                 else if ( !localName.equals( XmlConstants.EL_COMPONENTS ) )
                 {
-                    m_logger.log( LogService.LOG_DEBUG, "Ignoring unsupported element {0} (bundle {1})", null,
+                    m_logger.log(Level.DEBUG,
+                        "Ignoring unsupported element {0} (bundle {1})", null,
                             localName, m_bundle.getLocation() );
                 }
             }
@@ -433,7 +434,8 @@ else if ( !localName.equals( XmlConstants.EL_COMPONENTS ) )
         // used by the Maven SCR Plugin, which is just silently ignored)
         else if ( !localName.equals( XmlConstants.EL_COMPONENTS ) )
         {
-            m_logger.log( LogService.LOG_DEBUG, "Ignoring unsupported element '{'{0}'}'{1} (bundle {2})", null,
+            m_logger.log(Level.DEBUG,
+                "Ignoring unsupported element '{'{0}'}'{1} (bundle {2})", null,
                     uri, localName, m_bundle.getLocation()  );
         }
     }
diff --git a/scr/src/main/java/org/osgi/service/log/Logger.java b/scr/src/main/java/org/osgi/service/log/Logger.java
deleted file mode 100644
index 8c0ddc097c..0000000000
--- a/scr/src/main/java/org/osgi/service/log/Logger.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (c) OSGi Alliance (2016, 2017). All Rights Reserved.
- *
- * Licensed 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.osgi.service.log;
-
-import org.osgi.annotation.versioning.ProviderType;
-
-/**
- * This is a stripped down copy of the LogService 1.4 API (R7). It's
- * trimmed down to the methods used by the optional support for
- * R7 logging.
- */
-@ProviderType
-public interface Logger {
-
-    String ROOT_LOGGER_NAME = "ROOT";
-
-	boolean isDebugEnabled();
-
-	void debug(String message);
-
-	void debug(String format, Object arg);
-
-	boolean isInfoEnabled();
-
-	void info(String message);
-
-	void info(String format, Object arg);
-
-	boolean isWarnEnabled();
-
-	void warn(String message);
-
-	void warn(String format, Object arg);
-
-	boolean isErrorEnabled();
-
-	void error(String message);
-
-	void error(String format, Object arg);
-}
diff --git a/scr/src/main/java/org/osgi/service/log/LoggerFactory.java b/scr/src/main/java/org/osgi/service/log/LoggerFactory.java
deleted file mode 100644
index defbaf6340..0000000000
--- a/scr/src/main/java/org/osgi/service/log/LoggerFactory.java
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) OSGi Alliance (2016). All Rights Reserved.
- *
- * Licensed 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.osgi.service.log;
-
-import org.osgi.annotation.versioning.ProviderType;
-
-/**
- * This is a stripped down copy of the LogService 1.4 API (R7). It's
- * trimmed down to the methods used by the optional support for
- * R7 logging.
- */
-@ProviderType
-public interface LoggerFactory {
-
-    <L extends Logger> L getLogger(String name,
-            Class<L> loggerType);
-
-}
diff --git a/scr/src/test/java/org/apache/felix/scr/impl/logger/MockBundleLogger.java b/scr/src/test/java/org/apache/felix/scr/impl/logger/MockBundleLogger.java
index 52057f1050..acbd8fb5ec 100644
--- a/scr/src/test/java/org/apache/felix/scr/impl/logger/MockBundleLogger.java
+++ b/scr/src/test/java/org/apache/felix/scr/impl/logger/MockBundleLogger.java
@@ -22,14 +22,14 @@
 import java.text.MessageFormat;
 
 import org.apache.felix.scr.impl.MockBundle;
-import org.apache.felix.scr.impl.MockBundleContext;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 
 
 public class MockBundleLogger extends BundleLogger
 {
     public MockBundleLogger()
     {
-        super(new MockBundleContext(new MockBundle()), new MockScrLogger());
+        super(new MockBundle(), new MockScrLogger());
     }
 
 
@@ -37,13 +37,14 @@ public MockBundleLogger()
 
 
     @Override
-    public boolean isLogEnabled( final int level )
+    public boolean isLogEnabled(final Level level)
     {
-        return level == 1;
+        return level == Level.ERROR;
     }
 
     @Override
-    public boolean log( final int level, final String pattern, final Throwable ex, final Object...arguments )
+    public boolean log(final Level level, final String pattern, final Throwable ex,
+        final Object... arguments)
     {
         if ( isLogEnabled( level ) )
         {
@@ -54,7 +55,7 @@ public boolean log( final int level, final String pattern, final Throwable ex, f
 
 
     @Override
-    public boolean log( final int level, final String message, final Throwable ex )
+    public boolean log(final Level level, final String message, final Throwable ex)
     {
         lastMessage = message;
         return true;
diff --git a/scr/src/test/java/org/apache/felix/scr/impl/logger/MockComponentLogger.java b/scr/src/test/java/org/apache/felix/scr/impl/logger/MockComponentLogger.java
index 2bc551bbca..8194ebe0a2 100644
--- a/scr/src/test/java/org/apache/felix/scr/impl/logger/MockComponentLogger.java
+++ b/scr/src/test/java/org/apache/felix/scr/impl/logger/MockComponentLogger.java
@@ -18,6 +18,7 @@
  */
 package org.apache.felix.scr.impl.logger;
 
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.metadata.ComponentMetadata;
 import org.apache.felix.scr.impl.metadata.DSVersion;
 
@@ -29,14 +30,15 @@ public MockComponentLogger()
     }
 
     @Override
-    public boolean log(final int level, final String pattern, final Throwable ex, final Object... arguments)
+    public boolean log(final Level level, final String pattern, final Throwable ex,
+        final Object... arguments)
     {
         // ignore
         return true;
     }
 
     @Override
-    public boolean log(final int level, final String message, final Throwable ex)
+    public boolean log(final Level level, final String message, final Throwable ex)
     {
         // ignore
         return true;
diff --git a/scr/src/test/java/org/apache/felix/scr/impl/logger/MockScrLogger.java b/scr/src/test/java/org/apache/felix/scr/impl/logger/MockScrLogger.java
index 4425853564..f2f2f94fad 100644
--- a/scr/src/test/java/org/apache/felix/scr/impl/logger/MockScrLogger.java
+++ b/scr/src/test/java/org/apache/felix/scr/impl/logger/MockScrLogger.java
@@ -21,8 +21,8 @@
 
 import org.apache.felix.scr.impl.MockBundle;
 import org.apache.felix.scr.impl.MockBundleContext;
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.manager.ScrConfiguration;
-import org.osgi.service.log.LogService;
 
 
 public class MockScrLogger extends ScrLogger
@@ -69,9 +69,9 @@ public long serviceChangecountTimeout()
             }
 
             @Override
-            public int getLogLevel()
+            public Level getLogLevel()
             {
-                return LogService.LOG_ERROR;
+                return Level.ERROR;
             }
 
             @Override
diff --git a/scr/src/test/java/org/apache/felix/scr/impl/manager/RegistrationManagerTest.java b/scr/src/test/java/org/apache/felix/scr/impl/manager/RegistrationManagerTest.java
index 7fb61fa737..3b3381b4ef 100644
--- a/scr/src/test/java/org/apache/felix/scr/impl/manager/RegistrationManagerTest.java
+++ b/scr/src/test/java/org/apache/felix/scr/impl/manager/RegistrationManagerTest.java
@@ -23,6 +23,7 @@
 import java.util.ArrayList;
 import java.util.concurrent.CountDownLatch;
 
+import org.apache.felix.scr.impl.logger.InternalLogger.Level;
 import org.apache.felix.scr.impl.manager.RegistrationManager.RegState;
 import org.junit.Test;
 
@@ -112,7 +113,7 @@ void unregister(Object serviceRegistration)
         }
 
         @Override
-        void log(int level, String message, Throwable ex, Object... arguments)
+        void log(Level level, String message, Throwable ex, Object... arguments)
         {
             if ( arguments != null && arguments.length == 1 && (arguments[0] instanceof ArrayList))
             {
diff --git a/scr/src/test/java/org/apache/felix/scr/integration/ComponentTestBase.java b/scr/src/test/java/org/apache/felix/scr/integration/ComponentTestBase.java
index a877084a14..ce27281312 100644
--- a/scr/src/test/java/org/apache/felix/scr/integration/ComponentTestBase.java
+++ b/scr/src/test/java/org/apache/felix/scr/integration/ComponentTestBase.java
@@ -82,6 +82,9 @@
 import org.osgi.service.component.runtime.dto.ComponentConfigurationDTO;
 import org.osgi.service.component.runtime.dto.ComponentDescriptionDTO;
 import org.osgi.service.log.LogService;
+import org.osgi.service.log.Logger;
+import org.osgi.service.log.LoggerConsumer;
+import org.osgi.service.log.LoggerFactory;
 import org.osgi.util.tracker.ServiceTracker;
 
 import junit.framework.Assert;
@@ -180,8 +183,11 @@ public static Option[] configuration()
         }
 
         final Option[] base = options(
-                provision( CoreOptions.bundle( bundleFile.toURI().toString() ),
+                provision(
+                        CoreOptions.bundle( bundleFile.toURI().toString() ),
                         mavenBundle( "org.ops4j.pax.tinybundles", "tinybundles", "1.0.0" ),
+                        mavenBundle( "org.osgi", "org.osgi.service.log", "1.4.0"),
+                        mavenBundle( "org.osgi", "org.osgi.util.pushstream", "1.0.0"),
                         mavenBundle( "org.apache.felix", "org.apache.felix.configadmin", felixCaVersion ) ),
                         mavenBundle( "org.osgi", "org.osgi.util.promise"),
                         mavenBundle( "org.osgi", "org.osgi.util.function"),
@@ -203,7 +209,9 @@ public void setUp() throws BundleException
         log = new Log( restrictedLogging, ignoredWarnings );
         log.start();
         bundleContext.addFrameworkListener( log );
-        bundleContext.registerService( LogService.class.getName(), log, null );
+        bundleContext.registerService(
+            new String[] { LogService.class.getName(), LoggerFactory.class.getName() },
+            log, null);
 
         scrTracker = new ServiceTracker<>( bundleContext,
                 ServiceComponentRuntime.class, null );
@@ -851,7 +859,7 @@ public Thread getThread()
         }
     }
 
-    public static class Log implements LogService, FrameworkListener, Runnable
+    public static class Log implements LogService, Logger, FrameworkListener, Runnable
     {
         private static final int RESTRICTED_LOG_SIZE = 1000;
         private final SimpleDateFormat m_sdf = new SimpleDateFormat( "HH:mm:ss,S" );
@@ -1096,5 +1104,219 @@ private String getFrameworkEventMessage(int event)
                 return null;
             }
         }
+
+        @Override
+        public <L extends Logger> L getLogger(String name, Class<L> loggerType)
+        {
+            return (L) this;
+        }
+
+        @Override
+        public Logger getLogger(String name)
+        {
+            return this;
+        }
+
+        @Override
+        public Logger getLogger(Class<?> clazz)
+        {
+            return this;
+        }
+
+        @Override
+        public <L extends Logger> L getLogger(Class<?> clazz, Class<L> loggerType)
+        {
+            return (L) this;
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public <L extends Logger> L getLogger(Bundle bundle, String name,
+            Class<L> loggerType)
+        {
+            return (L) this;
+        }
+
+
+        @Override
+        public String getName()
+        {
+            return null;
+        }
+
+        @Override
+        public boolean isTraceEnabled()
+        {
+            return false;
+        }
+
+        @Override
+        public void trace(String message)
+        {
+        }
+
+        @Override
+        public void trace(String format, Object arg)
+        {
+        }
+
+        @Override
+        public void trace(String format, Object arg1, Object arg2)
+        {
+        }
+
+        @Override
+        public void trace(String format, Object... arguments)
+        {
+        }
+
+        @Override
+        public <E extends Exception> void trace(LoggerConsumer<E> consumer) throws E
+        {
+        }
+
+        @Override
+        public boolean isDebugEnabled()
+        {
+            return false;
+        }
+
+        @Override
+        public void debug(String message)
+        {
+        }
+
+        @Override
+        public void debug(String format, Object arg)
+        {
+        }
+
+        @Override
+        public void debug(String format, Object arg1, Object arg2)
+        {
+        }
+
+        @Override
+        public void debug(String format, Object... arguments)
+        {
+        }
+
+        @Override
+        public <E extends Exception> void debug(LoggerConsumer<E> consumer) throws E
+        {
+        }
+
+        @Override
+        public boolean isInfoEnabled()
+        {
+            return false;
+        }
+
+        @Override
+        public void info(String message)
+        {
+        }
+
+        @Override
+        public void info(String format, Object arg)
+        {
+        }
+
+        @Override
+        public void info(String format, Object arg1, Object arg2)
+        {
+        }
+
+        @Override
+        public void info(String format, Object... arguments)
+        {
+        }
+
+        @Override
+        public <E extends Exception> void info(LoggerConsumer<E> consumer) throws E
+        {
+        }
+
+        @Override
+        public boolean isWarnEnabled()
+        {
+            return false;
+        }
+
+        @Override
+        public void warn(String message)
+        {
+        }
+
+        @Override
+        public void warn(String format, Object arg)
+        {
+        }
+
+        @Override
+        public void warn(String format, Object arg1, Object arg2)
+        {
+        }
+
+        @Override
+        public void warn(String format, Object... arguments)
+        {
+        }
+
+        @Override
+        public <E extends Exception> void warn(LoggerConsumer<E> consumer) throws E
+        {
+        }
+
+        @Override
+        public boolean isErrorEnabled()
+        {
+            return false;
+        }
+
+        @Override
+        public void error(String message)
+        {
+        }
+
+        @Override
+        public void error(String format, Object arg)
+        {
+        }
+
+        @Override
+        public void error(String format, Object arg1, Object arg2)
+        {
+        }
+
+        @Override
+        public void error(String format, Object... arguments)
+        {
+        }
+
+        @Override
+        public <E extends Exception> void error(LoggerConsumer<E> consumer) throws E
+        {
+        }
+
+        @Override
+        public void audit(String message)
+        {
+        }
+
+        @Override
+        public void audit(String format, Object arg)
+        {
+        }
+
+        @Override
+        public void audit(String format, Object arg1, Object arg2)
+        {
+        }
+
+        @Override
+        public void audit(String format, Object... arguments)
+        {
+        }
     }
 }
diff --git a/scr/src/test/java/org/apache/felix/scr/integration/Felix6274Test.java b/scr/src/test/java/org/apache/felix/scr/integration/Felix6274Test.java
index 8c315f5099..08c4117176 100644
--- a/scr/src/test/java/org/apache/felix/scr/integration/Felix6274Test.java
+++ b/scr/src/test/java/org/apache/felix/scr/integration/Felix6274Test.java
@@ -59,14 +59,16 @@ public class Felix6274Test extends ComponentTestBase
     
     @Before
     public void installBundles() throws BundleException {
-        
+        String log101 = mavenBundle( "org.apache.felix", "org.apache.felix.log", "1.0.1" ).getURL();
+
+        // install and start the resolver hook first
+        Bundle hookBundle = bundleContext.installBundle("integration.test.6274_hook", createHookBundle());
+        installedBundles.add(hookBundle);
+        hookBundle.start();
+
         // Install an older version of the log service 
-        String url = mavenBundle( "org.apache.felix", "org.apache.felix.log", "1.0.1" ).getURL();
-        installedBundles.add( bundleContext.installBundle( url ) );
+        installedBundles.add( bundleContext.installBundle( log101 ) );
 
-        // Install the R7 version of the log service 
-        url = mavenBundle( "org.apache.felix", "org.apache.felix.log", "1.2.2" ).getURL();
-        installedBundles.add( bundleContext.installBundle( url ) );
         
         log_1_4_bundle = bundleContext.installBundle( "integration.test.6274", 
                 createStream( "6274", "[1.4,1.5)" ) );
@@ -91,7 +93,7 @@ public void cleanUpBundles() {
             }
         }
     }
-    
+
     private InputStream createStream(String testNumber, String logImportVersionRange) {
         String classFilePath = "org/apache/felix/scr/integration/components/felix" + testNumber + "/Component.class";
         String componentXML = "integration_test_FELIX_" + testNumber + ".xml";
@@ -110,7 +112,20 @@ private InputStream createStream(String testNumber, String logImportVersionRange
                                 + ";filter:=\"(&(osgi.extender=osgi.component)(version>=1.4)(!(version>=2.0)))\"" )
                 .build( withClassicBuilder() );
     }
-    
+
+    private InputStream createHookBundle()
+    {
+        String activatorClass = "org.apache.felix.scr.integration.components.felix6274_hook.Activator";
+        String activatorFilePath = activatorClass.replace('.', '/') + ".class";
+        return bundle().add(activatorFilePath, getClass().getResource("/" + activatorFilePath))
+            .set( Constants.BUNDLE_MANIFESTVERSION, "2" )
+            .set( Constants.BUNDLE_SYMBOLICNAME, "integration.test.6274_hook" )
+            .set( Constants.BUNDLE_VERSION, "1.0.0" )
+            .set( Constants.BUNDLE_ACTIVATOR, activatorClass)
+            .set( Constants.IMPORT_PACKAGE, "org.osgi.framework, org.osgi.framework.hooks.resolver, org.osgi.framework.namespace, org.osgi.framework.wiring" )
+            .build( withClassicBuilder() );
+    }
+
     @Test
     public void test_incompatible_log_service_version() throws Exception
     {
@@ -136,15 +151,15 @@ public void test_incompatible_log_service_version() throws Exception
         
         assertEquals( 1, running_1_4_components.size() );
         assertEquals( 1, running_1_3_components.size() );
-        
+
         // Check the components are active
         assertEquals( "1.4 Log Service Component failed to activate", 
                 ComponentConfigurationDTO.ACTIVE, running_1_4_components.iterator().next().state );
         log.log( LogService.LOG_INFO, "R7LoggerComponent checked active" );
         
-        assertEquals( "1.3 Log Service Component failed to activate", 
+        assertEquals("1.3 Log Service Component failed to activate",
                 ComponentConfigurationDTO.ACTIVE, running_1_3_components.iterator().next().state);
-        log.log( LogService.LOG_INFO, "LogServiceComponent checked active" );
-        
+        log.log(LogService.LOG_INFO, "LogServiceComponent checked active");
+
     }
 }
diff --git a/scr/src/test/java/org/apache/felix/scr/integration/components/felix6274_hook/Activator.java b/scr/src/test/java/org/apache/felix/scr/integration/components/felix6274_hook/Activator.java
new file mode 100644
index 0000000000..fa54fa6107
--- /dev/null
+++ b/scr/src/test/java/org/apache/felix/scr/integration/components/felix6274_hook/Activator.java
@@ -0,0 +1,98 @@
+/*
+ * 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.felix.scr.integration.components.felix6274_hook;
+
+import java.util.Collection;
+import java.util.Iterator;
+
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleActivator;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.Version;
+import org.osgi.framework.hooks.resolver.ResolverHook;
+import org.osgi.framework.hooks.resolver.ResolverHookFactory;
+import org.osgi.framework.namespace.PackageNamespace;
+import org.osgi.framework.wiring.BundleCapability;
+import org.osgi.framework.wiring.BundleRequirement;
+import org.osgi.framework.wiring.BundleRevision;
+
+public class Activator implements BundleActivator, ResolverHookFactory, ResolverHook
+{
+
+    @Override
+    public void start(BundleContext context) throws Exception
+    {
+        context.registerService(ResolverHookFactory.class, this, null);
+    }
+
+    @Override
+    public void stop(BundleContext context) throws Exception
+    {
+    }
+
+    @Override
+    public ResolverHook begin(Collection<BundleRevision> triggers)
+    {
+        return this;
+    }
+
+    @Override
+    public void filterSingletonCollisions(BundleCapability singleton,
+        Collection<BundleCapability> collisionCandidates)
+    {
+    }
+
+    @Override
+    public void filterResolvable(Collection<BundleRevision> candidates)
+    {
+
+    }
+
+    @Override
+    public void filterMatches(BundleRequirement requirement,
+        Collection<BundleCapability> candidates)
+    {
+        Bundle b = requirement.getResource().getBundle();
+
+        if (PackageNamespace.PACKAGE_NAMESPACE.equals(requirement.getNamespace())
+            && "org.osgi.service.log".equals(
+                candidates.iterator().next().getAttributes().get(
+                    PackageNamespace.PACKAGE_NAMESPACE))
+            && "org.apache.felix.log".equals(b.getSymbolicName())
+            && Version.valueOf("1.0.1").equals(b.getVersion()))
+        {
+            // Felix log 1.0.1 incorrectly allows import of R7 log
+            Iterator<BundleCapability> iCaps = candidates.iterator();
+            while (iCaps.hasNext())
+            {
+                if (!iCaps.next().getRevision().getBundle().equals(
+                    requirement.getRevision().getBundle()))
+                {
+                    System.out.println("TJW - removed");
+                    iCaps.remove();
+                }
+            }
+        }
+    }
+
+    @Override
+    public void end()
+    {
+    }
+}