diff --git a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ConfigurationDependency.java b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ConfigurationDependency.java
index 83b3364..4f27cb3 100644
--- a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ConfigurationDependency.java
+++ b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ConfigurationDependency.java
@@ -54,19 +54,30 @@
 	private volatile Service m_service;
 	private Dictionary m_settings;
 	private boolean m_propagate;
+    private final Logger m_logger;
 	
-	public ConfigurationDependency(BundleContext context) {
+	public ConfigurationDependency(BundleContext context, Logger logger) {
 		m_context = context;
+        m_logger = logger;
 	}
 	
 	public synchronized boolean isAvailable() {
 		return m_settings != null;
 	}
 
+	/**
+	 * Will always return <code>true</code> as optional configuration dependencies
+	 * do not make sense. You might as well just implement <code>ManagedService</code>
+	 * yourself in those cases.
+	 */
 	public boolean isRequired() {
 		return true;
 	}
 	
+	/**
+	 * Returns <code>true</code> when configuration properties should be propagated
+	 * as service properties.
+	 */
 	public boolean isPropagated() {
 		return m_propagate;
 	}
@@ -104,11 +115,13 @@
 				// the "old" configuration to stay in effect
 			}
 			else {
-				throw new IllegalStateException("Could not invoke updated on implementation");
+				m_logger.log(Logger.LOG_ERROR, "Service " + m_service + " with configuration dependency " + this + " does not implement ManagedService.");
+				return;
 			}
 		}
 		else {
-			throw new IllegalStateException("Could not instantiate implementation");
+		    m_logger.log(Logger.LOG_ERROR, "Service " + m_service + " with configuration dependency " + this + " could not be instantiated.");
+		    return;
 		}
 		// if these settings did not cause a configuration exception, we determine
 		// if they have caused the dependency state to change
@@ -128,12 +141,21 @@
 		}
 	}
 
+	/**
+	 * Sets the <code>service.pid</code> of the configuration you
+	 * are depending on.
+	 */
 	public ConfigurationDependency setPid(String pid) {
 		ensureNotActive();
 		m_pid = pid;
 		return this;
 	}
-	
+
+	/**
+	 * Sets propagation of the configuration properties to the service
+	 * properties. Any additional service properties specified directly
+	 * are merged with these.
+	 */
 	public ConfigurationDependency setPropagate(boolean propagate) {
 		ensureNotActive();
 		m_propagate = propagate;
diff --git a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/DependencyActivatorBase.java b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/DependencyActivatorBase.java
index f11ea04..1d92150 100644
--- a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/DependencyActivatorBase.java
+++ b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/DependencyActivatorBase.java
@@ -35,6 +35,7 @@
 public abstract class DependencyActivatorBase implements BundleActivator {
     private BundleContext m_context;
     private DependencyManager m_manager;
+    private Logger m_logger;
     
     /**
      * Initialize the dependency manager. Here you can add all services and their dependencies.
@@ -70,7 +71,8 @@
      */
     public void start(BundleContext context) throws Exception {
         m_context = context;
-        m_manager = new DependencyManager(context);
+        m_logger = new Logger(context);
+        m_manager = new DependencyManager(context, m_logger);
         init(m_context, m_manager);
     }
 
@@ -93,7 +95,7 @@
      * @return the new service
      */
     public Service createService() {
-        return new ServiceImpl(m_context);
+        return new ServiceImpl(m_context, m_logger);
     }
     
     /**
@@ -102,7 +104,7 @@
      * @return the service dependency
      */
     public ServiceDependency createServiceDependency() {
-        return new ServiceDependency(m_context);
+        return new ServiceDependency(m_context, m_logger);
     }
     
     /**
@@ -111,7 +113,7 @@
      * @return the configuration dependency
      */
     public ConfigurationDependency createConfigurationDependency() {
-    	return new ConfigurationDependency(m_context);
+    	return new ConfigurationDependency(m_context, m_logger);
     }
 
     /**
diff --git a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/DependencyManager.java b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/DependencyManager.java
index 40e9e53..30f3cde 100644
--- a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/DependencyManager.java
+++ b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/DependencyManager.java
@@ -30,16 +30,19 @@
  * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
  */
 public class DependencyManager {
-    private BundleContext m_context;
+    private final BundleContext m_context;
+    private final Logger m_logger;
     private List m_services = Collections.synchronizedList(new ArrayList());
 
     /**
      * Creates a new dependency manager.
      * 
      * @param context the bundle context
+     * @param logger 
      */
-    public DependencyManager(BundleContext context) {
+    public DependencyManager(BundleContext context, Logger logger) {
         m_context = context;
+        m_logger = logger;
     }
     
     /**
@@ -70,7 +73,7 @@
      * @return the new service
      */
     public Service createService() {
-        return new ServiceImpl(m_context);
+        return new ServiceImpl(m_context, m_logger);
     }
     
     /**
@@ -79,7 +82,11 @@
      * @return the service dependency
      */
     public ServiceDependency createServiceDependency() {
-        return new ServiceDependency(m_context);
+        return new ServiceDependency(m_context, m_logger);
+    }
+    
+    public ConfigurationDependency createConfigurationDependency() {
+        return new ConfigurationDependency(m_context, m_logger);
     }
     
     /**
diff --git a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/Logger.java b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/Logger.java
new file mode 100644
index 0000000..c5a9af1
--- /dev/null
+++ b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/Logger.java
@@ -0,0 +1,279 @@
+/*
+ * 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.dependencymanager;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.BundleException;
+import org.osgi.framework.InvalidSyntaxException;
+import org.osgi.framework.ServiceEvent;
+import org.osgi.framework.ServiceListener;
+import org.osgi.framework.ServiceReference;
+
+/**
+ * <p>
+ * This class mimics the standard OSGi <tt>LogService</tt> interface. An
+ * instance of this class is used by the framework for all logging. By default
+ * this class logs messages to standard out. The log level can be set to
+ * control the amount of logging performed, where a higher number results in
+ * more logging. A log level of zero turns off logging completely.
+ * </p>
+ * <p>
+ * The log levels match those specified in the OSGi Log Service (i.e., 1 = error,
+ * 2 = warning, 3 = information, and 4 = debug). The default value is 1.
+ * </p>
+ * <p>
+ * This class also uses the System Bundle's context to track log services
+ * and will use the highest ranking log service, if present, as a back end
+ * instead of printing to standard out. The class uses reflection to invoking
+ * the log service's method to avoid a dependency on the log interface.
+ * </p>
+**/
+public class Logger implements ServiceListener
+{
+    public static final int LOG_ERROR = 1;
+    public static final int LOG_WARNING = 2;
+    public static final int LOG_INFO = 3;
+    public static final int LOG_DEBUG = 4;
+
+    private final BundleContext m_context;
+
+    private final static int LOGGER_OBJECT_IDX = 0;
+    private final static int LOGGER_METHOD_IDX = 1;
+    private ServiceReference m_logRef = null;
+    private Object[] m_logger = null;
+
+    public Logger(BundleContext context)
+    {
+         m_context = context;
+         startListeningForLogService();
+    }
+
+    public final void log(int level, String msg)
+    {
+        _log(null, level, msg, null);
+    }
+
+    public final void log(int level, String msg, Throwable throwable)
+    {
+        _log(null, level, msg, throwable);
+    }
+
+    public final void log(ServiceReference sr, int level, String msg)
+    {
+        _log(sr, level, msg, null);
+    }
+
+    public final void log(ServiceReference sr, int level, String msg, Throwable throwable)
+    {
+        _log(sr, level, msg, throwable);
+    }
+
+    protected void doLog(ServiceReference sr, int level, String msg, Throwable throwable)
+    {
+        String s = (sr == null) ? null : "SvcRef " + sr;
+        s = (s == null) ? msg : s + " " + msg;
+        s = (throwable == null) ? s : s + " (" + throwable + ")";
+        switch (level)
+        {
+            case LOG_DEBUG:
+                System.out.println("DEBUG: " + s);
+                break;
+            case LOG_ERROR:
+                System.out.println("ERROR: " + s);
+                if (throwable != null)
+                {
+                    if ((throwable instanceof BundleException) &&
+                        (((BundleException) throwable).getNestedException() != null))
+                    {
+                        throwable = ((BundleException) throwable).getNestedException();
+                    }
+                    throwable.printStackTrace();
+                }
+                break;
+            case LOG_INFO:
+                System.out.println("INFO: " + s);
+                break;
+            case LOG_WARNING:
+                System.out.println("WARNING: " + s);
+                break;
+            default:
+                System.out.println("UNKNOWN[" + level + "]: " + s);
+        }
+    }
+
+    private void _log(ServiceReference sr, int level, String msg, Throwable throwable)
+    {
+        // Save our own copy just in case it changes. We could try to do
+        // more conservative locking here, but let's be optimistic.
+        Object[] logger = m_logger;
+
+        // Use the log service if available.
+        if (logger != null)
+        {
+            _logReflectively(logger, sr, level, msg, throwable);
+        }
+        // Otherwise, default logging action.
+        else
+        {
+            doLog(sr, level, msg, throwable);
+        }
+    }
+
+    private void _logReflectively(
+        Object[] logger, ServiceReference sr, int level, String msg, Throwable throwable)
+    {
+        if (logger != null)
+        {
+            Object[] params = {
+                sr, new Integer(level), msg, throwable
+            };
+            try
+            {
+                ((Method) logger[LOGGER_METHOD_IDX]).invoke(logger[LOGGER_OBJECT_IDX], params);
+            }
+            catch (InvocationTargetException ex)
+            {
+                System.err.println("Logger: " + ex);
+            }
+            catch (IllegalAccessException ex)
+            {
+                System.err.println("Logger: " + ex);
+            }
+        }
+    }
+
+    /**
+     * This method is called when the bundle context is set;
+     * it simply adds a service listener so that the bundle can track
+     * log services to be used as the back end of the logging mechanism. It also
+     * attempts to get an existing log service, if present, but in general
+     * there will never be a log service present since the system bundle is
+     * started before every other bundle.
+    **/
+    private void startListeningForLogService()
+    {
+        // Add a service listener for log services.
+        try
+        {
+            m_context.addServiceListener(
+                this, "(objectClass=org.osgi.service.log.LogService)");
+        }
+        catch (InvalidSyntaxException ex) {
+            // This will never happen since the filter is hard coded.
+        }
+        // Try to get an existing log service.
+        m_logRef = m_context.getServiceReference("org.osgi.service.log.LogService");
+        // Get the service object if available and set it in the logger.
+        if (m_logRef != null)
+        {
+            setLogger(m_context.getService(m_logRef));
+        }
+    }
+
+    /**
+     * This method implements the callback for the ServiceListener interface.
+     * It is public as a byproduct of implementing the interface and should
+     * not be called directly. This method tracks run-time changes to log
+     * service availability. If the log service being used by the framework's
+     * logging mechanism goes away, then this will try to find an alternative.
+     * If a higher ranking log service is registered, then this will switch
+     * to the higher ranking log service.
+    **/
+    public final synchronized void serviceChanged(ServiceEvent event)
+    {
+        // If no logger is in use, then grab this one.
+        if ((event.getType() == ServiceEvent.REGISTERED) && (m_logRef == null))
+        {
+            m_logRef = event.getServiceReference();
+            // Get the service object and set it in the logger.
+            setLogger(m_context.getService(m_logRef));
+        }
+        // If a logger is in use, but this one has a higher ranking, then swap
+        // it for the existing logger.
+        else if ((event.getType() == ServiceEvent.REGISTERED) && (m_logRef != null))
+        {
+            ServiceReference ref =
+                m_context.getServiceReference("org.osgi.service.log.LogService");
+            if (!ref.equals(m_logRef))
+            {
+                m_context.ungetService(m_logRef);
+                m_logRef = ref;
+                setLogger(m_context.getService(m_logRef));
+            }
+
+        }
+        // If the current logger is going away, release it and try to
+        // find another one.
+        else if ((event.getType() == ServiceEvent.UNREGISTERING) &&
+            m_logRef.equals(event.getServiceReference()))
+        {
+            // Unget the service object.
+            m_context.ungetService(m_logRef);
+            // Try to get an existing log service.
+            m_logRef = m_context.getServiceReference(
+                "org.osgi.service.log.LogService");
+            // Get the service object if available and set it in the logger.
+            if (m_logRef != null)
+            {
+                setLogger(m_context.getService(m_logRef));
+            }
+            else
+            {
+                setLogger(null);
+            }
+        }
+    }
+
+    /**
+     * This method sets the new log service object. It also caches the method to
+     * invoke. The service object and method are stored in array to optimistically
+     * eliminate the need to locking when logging.
+    **/
+    private void setLogger(Object logObj)
+    {
+        if (logObj == null)
+        {
+            m_logger = null;
+        }
+        else
+        {
+            Class[] formalParams = {
+                ServiceReference.class,
+                Integer.TYPE,
+                String.class,
+                Throwable.class
+            };
+
+            try
+            {
+                Method logMethod = logObj.getClass().getMethod("log", formalParams);
+                logMethod.setAccessible(true);
+                m_logger = new Object[] { logObj, logMethod };
+            }
+            catch (NoSuchMethodException ex)
+            {
+                System.err.println("Logger: " + ex);
+                m_logger = null;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ServiceDependency.java b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ServiceDependency.java
index 81d9825..f76ac67 100644
--- a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ServiceDependency.java
+++ b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ServiceDependency.java
@@ -50,14 +50,17 @@
     private boolean m_autoConfig;
     private ServiceReference m_reference;
     private Object m_serviceInstance;
+    private final Logger m_logger;
     
     /**
      * Creates a new service dependency.
      * 
      * @param context the bundle context
+     * @param logger 
      */
-    public ServiceDependency(BundleContext context) {
+    public ServiceDependency(BundleContext context, Logger logger) {
         m_context = context;
+        m_logger = logger;
         m_autoConfig = true;
     }
 
@@ -171,8 +174,9 @@
         if ((callbackInstance != null) && (m_callbackAdded != null)) {
             try {
                 invokeCallbackMethod(callbackInstance, m_callbackAdded, reference, serviceInstance);
-            } catch (NoSuchMethodException e) {
-                // silently ignore this
+            }
+            catch (NoSuchMethodException e) {
+                m_logger.log(Logger.LOG_ERROR, "Could not invoke method " + m_callbackAdded + " on " + callbackInstance + ".", e);
             }
         }
     }
@@ -197,7 +201,7 @@
                 invokeCallbackMethod(callbackInstance, m_callbackChanged, reference, serviceInstance);
             }
             catch (NoSuchMethodException e) {
-                // ignore when the service has no such method
+                m_logger.log(Logger.LOG_ERROR, "Could not invoke method " + m_callbackChanged + " on " + callbackInstance + ".", e);
             }
         }
     }
@@ -230,7 +234,7 @@
                 invokeCallbackMethod(callbackInstance, m_callbackRemoved, reference, serviceInstance);
             }
             catch (NoSuchMethodException e) {
-                // ignore when the service has no such method
+                m_logger.log(Logger.LOG_ERROR, "Could not invoke method " + m_callbackRemoved + " on " + callbackInstance + ".", e);
             }
         }
     }
@@ -275,6 +279,9 @@
                 currentClazz = currentClazz.getSuperclass();
             }
         }
+        if (!done && currentClazz == null) {
+            throw new NoSuchMethodException(methodName);
+        }
     }
 
     private boolean invokeMethod(Object object, Class clazz, String name, Class[][] signatures, Object[][] parameters, boolean isSuper) {
@@ -289,14 +296,18 @@
                         m.invoke(object, parameters[i]);
                     }
                     catch (InvocationTargetException e) {
-                        // thrown by the underlying method, we ignore this exception
-                        // and still return true because we could invoke the method
+                        m_logger.log(Logger.LOG_ERROR, "Exception while invoking method " + m + ".", e);
                     }
+                    // we did find and invoke the method, so we return true
                     return true;
                 }
             }
+            catch (NoSuchMethodException e) {
+                // ignore this and keep looking
+            }
             catch (Exception e) {
-                // ignore any exception and keep looking for a method
+                // could not even try to invoke the method
+                m_logger.log(Logger.LOG_ERROR, "Exception while trying to invoke method " + m + ".", e);
             }
         }
         return false;
diff --git a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ServiceImpl.java b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ServiceImpl.java
index a63f4b8..f29a41e 100644
--- a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ServiceImpl.java
+++ b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ServiceImpl.java
@@ -20,6 +20,7 @@
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.ArrayList;
@@ -80,9 +81,13 @@
 	private Object m_compositionManager;
 	private String m_compositionManagerGetMethod;
 	private Object m_compositionManagerInstance;
+	
+	// internal logging
+    private final Logger m_logger;
 
-    public ServiceImpl(BundleContext context) {
-    	m_state = new State((List) m_dependencies.clone(), false);
+    public ServiceImpl(BundleContext context, Logger logger) {
+    	m_logger = logger;
+        m_state = new State((List) m_dependencies.clone(), false);
         m_context = context;
         m_callbackInit = "init";
         m_callbackStart = "start";
@@ -352,30 +357,50 @@
 	private void stateListenersStarting() {
 		ServiceStateListener[] list = getListeners();
 		for (int i = 0; i < list.length; i++) {
-			list[i].starting(this);
+		    try {
+		        list[i].starting(this);
+		    }
+		    catch (Throwable t) {
+		        m_logger.log(Logger.LOG_ERROR, "Error invoking listener starting method.", t);
+		    }
 		}
 	}
 
 	private void stateListenersStarted() {
-		ServiceStateListener[] list = getListeners();
-		for (int i = 0; i < list.length; i++) {
-			list[i].started(this);
-		}
-	}
+        ServiceStateListener[] list = getListeners();
+        for (int i = 0; i < list.length; i++) {
+            try {
+                list[i].started(this);
+            }
+            catch (Throwable t) {
+                m_logger.log(Logger.LOG_ERROR, "Error invoking listener started method.", t);
+            }
+        }
+    }
 
-	private void stateListenersStopping() {
-		ServiceStateListener[] list = getListeners();
-		for (int i = 0; i < list.length; i++) {
-			list[i].stopping(this);
-		}
-	}
+    private void stateListenersStopping() {
+        ServiceStateListener[] list = getListeners();
+        for (int i = 0; i < list.length; i++) {
+            try {
+                list[i].stopping(this);
+            }
+            catch (Throwable t) {
+                m_logger.log(Logger.LOG_ERROR, "Error invoking listener stopping method.", t);
+            }
+        }
+    }
 
-	private void stateListenersStopped() {
-		ServiceStateListener[] list = getListeners();
-		for (int i = 0; i < list.length; i++) {
-			list[i].stopped(this);
-		}
-	}
+    private void stateListenersStopped() {
+        ServiceStateListener[] list = getListeners();
+        for (int i = 0; i < list.length; i++) {
+            try {
+                list[i].stopped(this);
+            }
+            catch (Throwable t) {
+                m_logger.log(Logger.LOG_ERROR, "Error invoking listener stopped method.", t);
+            }
+        }
+    }
 
 	private ServiceStateListener[] getListeners() {
 		synchronized (m_stateListeners) {
@@ -443,7 +468,12 @@
                 	Method method = clazz.getDeclaredMethod(name, null);
 	                	if (method != null) {
 	                		method.setAccessible(true);
-	                		method.invoke(m_serviceInstance, null);
+	                		try {
+    	                		method.invoke(m_serviceInstance, null);
+	                		}
+	                		catch (InvocationTargetException e) {
+	                		    m_logger.log(Logger.LOG_ERROR, "Exception while invoking method " + method + ".", e);
+	                		}
 	                		return;
 	                	}
                 	}
@@ -454,7 +484,7 @@
                 }
             }
             catch (Exception e) {
-                throw new RuntimeException(e);
+                m_logger.log(Logger.LOG_ERROR, "Error trying to invoke method named " + name + ".", e);
             }
         }
     }
@@ -512,19 +542,8 @@
 	            try {
 	            	m_serviceInstance = createInstance((Class) m_implementation);
 	            }
-	            catch (InstantiationException e) {
-	                // TODO handle this exception
-	                e.printStackTrace();
-	            }
-	            catch (IllegalAccessException e) {
-	                // TODO handle this exception
-	                e.printStackTrace();
-	            } catch (SecurityException e) {
-					// TODO Auto-generated catch block
-					e.printStackTrace();
-				} catch (NoSuchMethodException e) {
-					// TODO Auto-generated catch block
-					e.printStackTrace();
+	            catch (Exception e) {
+	                m_logger.log(Logger.LOG_ERROR, "Could not create service instance of class " + m_implementation + ".", e);
 				}
 	        }
 	        else {
@@ -535,20 +554,9 @@
 		        			try {
 								factory = createInstance((Class) m_instanceFactory);
 							}
-		        			catch (InstantiationException e) {
-								// TODO Auto-generated catch block
-								e.printStackTrace();
-							}
-		        			catch (IllegalAccessException e) {
-								// TODO Auto-generated catch block
-								e.printStackTrace();
-							} catch (SecurityException e) {
-								// TODO Auto-generated catch block
-								e.printStackTrace();
-							} catch (NoSuchMethodException e) {
-								// TODO Auto-generated catch block
-								e.printStackTrace();
-							}
+		                    catch (Exception e) {
+		                        m_logger.log(Logger.LOG_ERROR, "Could not create factory instance of class " + m_instanceFactory + ".", e);
+		                    }
 		        		}
 		        		else {
 		        			factory = m_instanceFactory;
@@ -560,21 +568,22 @@
 		        		// could be ???
 		        	}
 		        	if (factory == null) {
-		        		throw new IllegalStateException("Factory cannot be null");
+                        m_logger.log(Logger.LOG_ERROR, "Factory cannot be null.");
 		        	}
 		        	try {
 						Method m = factory.getClass().getDeclaredMethod(m_instanceFactoryCreateMethod, null);
 						m_serviceInstance = m.invoke(factory, null);
 					}
 		        	catch (Exception e) {
-						// TODO Auto-generated catch block
-						e.printStackTrace();
+	                    m_logger.log(Logger.LOG_ERROR, "Could not create service instance using factory " + factory + " method " + m_instanceFactoryCreateMethod + ".", e);
 					}
 	        	}
 	        	if (m_implementation == null) {
-	        		throw new IllegalStateException("Implementation cannot be null");
+                    m_logger.log(Logger.LOG_ERROR, "Implementation cannot be null.");
 	        	}
-	            m_serviceInstance = m_implementation;
+	        	if (m_serviceInstance == null) {
+	        	    m_serviceInstance = m_implementation;
+	        	}
 	        }
 	        // configure the bundle context
 	        configureImplementation(BundleContext.class, m_context);
@@ -704,8 +713,8 @@
 					instances = (Object[]) m.invoke(m_compositionManagerInstance, null);
 				}
 	    		catch (Exception e) {
-					// TODO Auto-generated catch block
-					e.printStackTrace();
+                    m_logger.log(Logger.LOG_ERROR, "Could not obtain instances from the composition manager.", e);
+                    return;
 				}
     		}
     	}
@@ -728,29 +737,8 @@
 		                        }
 		                    }
 		                    catch (Exception e) {
-		                        System.err.println("Exception while trying to set " + fields[j].getName() +
-		                            " of type " + fields[j].getType().getName() +
-		                            " by classloader " + fields[j].getType().getClassLoader() +
-		                            " which should equal type " + clazz.getName() +
-		                            " by classloader " + clazz.getClassLoader() +
-		                            " of type " + serviceClazz.getName() +
-		                            " by classloader " + serviceClazz.getClassLoader() +
-		                            " on " + serviceInstance +
-		                            " by classloader " + serviceInstance.getClass().getClassLoader() +
-		                            "\nDumping stack:"
-		                        );
-		                        e.printStackTrace();
-		                        System.out.println("C: " + clazz);
-		                        System.out.println("I: " + instance);
-		                        System.out.println("I:C: " + instance.getClass().getClassLoader());
-		                        Class[] classes = instance.getClass().getInterfaces();
-		                        for (int k = 0; k < classes.length; k++) {
-		                            Class c = classes[k];
-		                            System.out.println("I:C:I: " + c);
-		                            System.out.println("I:C:I:C: " + c.getClassLoader());
-		                        }
-		                        System.out.println("F: " + fields[j]);
-		                        throw new IllegalStateException("Could not set field " + fields[j].getName() + " on " + serviceInstance);
+		                        m_logger.log(Logger.LOG_ERROR, "Could not set field " + fields[j], e);
+		                        return;
 		                    }
 		                }
 		            }
diff --git a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ServiceTracker.java b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ServiceTracker.java
index 0202e49..1c083de 100644
--- a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ServiceTracker.java
+++ b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/ServiceTracker.java
@@ -31,10 +31,7 @@
 import org.osgi.framework.ServiceReference;
 
 /**
- * TODO copied this from the OSGi specification, but it's not clear if that
- * is allowed or not, for now I modified as little as possible but I might
- * integrate only the parts I want as soon as this code is finished. Perhaps
- * it would be better to borrow the Knopflerfish implementation here.
+ * Copied this from the OSGi specification and made a slight modification.
  * 
  * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
  */
diff --git a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/State.java b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/State.java
index 986f70c..56aa0de 100644
--- a/dependencymanager/src/main/java/org/apache/felix/dependencymanager/State.java
+++ b/dependencymanager/src/main/java/org/apache/felix/dependencymanager/State.java
@@ -3,17 +3,19 @@
 import java.util.List;
 
 /**
- * Encapsulates the current state of the dependencies of a service.
+ * Encapsulates the current state of the dependencies of a service. A state is
+ * basically an immutable value object.
  * 
  * @author <a href="mailto:dev@felix.apache.org">Felix Project Team</a>
  */
 public final class State {
-	public static final String[] STATES = { "?", "inactive", "waiting for required", "tracking optional" };
-	public static final int INACTIVE = 1;
-	public static final int WAITING_FOR_REQUIRED = 2;
-	public static final int TRACKING_OPTIONAL = 3;
+    private static final String[] STATES = { "?", "inactive", "waiting for required", "tracking optional" };
+    private static final int INACTIVE = 1;
+    private static final int WAITING_FOR_REQUIRED = 2;
+    private static final int TRACKING_OPTIONAL = 3;
 	private final List m_deps;
 	private final int m_state;
+    private String m_stringValue;
 	
 	/**
 	 * Creates a new state instance.
@@ -46,10 +48,6 @@
     	}
 	}
 	
-	public int getState() {
-		return m_state;
-	}
-	
 	public boolean isInactive() {
 		return m_state == INACTIVE;
 	}
@@ -67,13 +65,17 @@
 	}
 	
 	public String toString() {
-		StringBuffer buf = new StringBuffer();
-		buf.append("State[" + STATES[m_state] + "|");
-		List deps = m_deps;
-    	for (int i = 0; i < deps.size(); i++) {
-    		Dependency dep = (Dependency) deps.get(i);
-    		buf.append("(" + dep + (dep.isRequired() ? " R" : " O") + (dep.isAvailable() ? " +" : " -") + ")");
-    	}
-    	return buf.toString();
+	    if (m_stringValue == null) {
+	        // we only need to determine this once, but we do it lazily
+	        StringBuffer buf = new StringBuffer();
+    		buf.append("State[" + STATES[m_state] + "|");
+    		List deps = m_deps;
+        	for (int i = 0; i < deps.size(); i++) {
+        		Dependency dep = (Dependency) deps.get(i);
+        		buf.append("(" + dep + (dep.isRequired() ? " R" : " O") + (dep.isAvailable() ? " +" : " -") + ")");
+        	}
+        	m_stringValue = buf.toString();
+	    }
+        return m_stringValue;
 	}
 }
diff --git a/dependencymanager/src/test/java/org/apache/felix/dependencymanager/ServiceDependencyTest.java b/dependencymanager/src/test/java/org/apache/felix/dependencymanager/ServiceDependencyTest.java
index fae1491..e5bb4e0 100644
--- a/dependencymanager/src/test/java/org/apache/felix/dependencymanager/ServiceDependencyTest.java
+++ b/dependencymanager/src/test/java/org/apache/felix/dependencymanager/ServiceDependencyTest.java
@@ -24,8 +24,8 @@
 		// start the actual test
 		c1.replay();
         c2.replay();
-		DependencyManager dm = new DependencyManager(context);
-		Service service = new ServiceImpl(context).setImplementation(svc);
+		DependencyManager dm = new DependencyManager(context, null);
+		Service service = new ServiceImpl(context, null).setImplementation(svc);
 		dm.add(service);
 		dm.remove(service);
 		// verify the results
@@ -59,8 +59,8 @@
 		c1.replay();
         c2.replay();
         c3.replay();
-		DependencyManager dm = new DependencyManager(context);
-		Service service = new ServiceImpl(context)
+		DependencyManager dm = new DependencyManager(context, null);
+		Service service = new ServiceImpl(context, null)
 			.setImplementation(svc)
 			.add(dependency);
 		dm.add(service);