killbill-uncached

Merge pull request #1034 from killbill/lifecycle-improvements Introduce

8/3/2018 3:50:15 PM

Changes

pom.xml 2(+1 -1)

Details

diff --git a/account/src/main/java/org/killbill/billing/account/api/DefaultAccountService.java b/account/src/main/java/org/killbill/billing/account/api/DefaultAccountService.java
index f18fbc0..2a15453 100644
--- a/account/src/main/java/org/killbill/billing/account/api/DefaultAccountService.java
+++ b/account/src/main/java/org/killbill/billing/account/api/DefaultAccountService.java
@@ -18,11 +18,14 @@ package org.killbill.billing.account.api;
 
 public class DefaultAccountService implements AccountService {
 
-    private static final String ACCOUNT_SERVICE_NAME = "account-service";
-
     @Override
     public String getName() {
-        return ACCOUNT_SERVICE_NAME;
+        return KILLBILL_SERVICES.ACCOUNT_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.ACCOUNT_SERVICE.getRegistrationOrdering();
     }
 
 }
diff --git a/api/src/main/java/org/killbill/billing/entitlement/EntitlementService.java b/api/src/main/java/org/killbill/billing/entitlement/EntitlementService.java
index 32fc8c3..7ed7292 100644
--- a/api/src/main/java/org/killbill/billing/entitlement/EntitlementService.java
+++ b/api/src/main/java/org/killbill/billing/entitlement/EntitlementService.java
@@ -22,7 +22,5 @@ import org.killbill.billing.platform.api.KillbillService;
 
 public interface EntitlementService extends KillbillService {
 
-    public static final String ENTITLEMENT_SERVICE_NAME = "entitlement-service";
-
     public String getName();
 }
diff --git a/beatrix/src/main/java/org/killbill/billing/beatrix/DefaultBeatrixService.java b/beatrix/src/main/java/org/killbill/billing/beatrix/DefaultBeatrixService.java
index 7d071ea..f9ead20 100644
--- a/beatrix/src/main/java/org/killbill/billing/beatrix/DefaultBeatrixService.java
+++ b/beatrix/src/main/java/org/killbill/billing/beatrix/DefaultBeatrixService.java
@@ -28,7 +28,6 @@ import org.killbill.bus.api.PersistentBus;
 
 public class DefaultBeatrixService implements BeatrixService {
 
-    public static final String BEATRIX_SERVICE_NAME = "beatrix-service";
 
     private final BeatrixListener beatrixListener;
     private final PersistentBus eventBus;
@@ -41,7 +40,12 @@ public class DefaultBeatrixService implements BeatrixService {
 
     @Override
     public String getName() {
-        return BEATRIX_SERVICE_NAME;
+        return KILLBILL_SERVICES.BEATRIX_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.BEATRIX_SERVICE.getRegistrationOrdering();
     }
 
     @LifecycleHandlerType(LifecycleLevel.INIT_SERVICE)
diff --git a/beatrix/src/main/java/org/killbill/billing/beatrix/extbus/BeatrixListener.java b/beatrix/src/main/java/org/killbill/billing/beatrix/extbus/BeatrixListener.java
index ad5349b..fe0ba6a 100644
--- a/beatrix/src/main/java/org/killbill/billing/beatrix/extbus/BeatrixListener.java
+++ b/beatrix/src/main/java/org/killbill/billing/beatrix/extbus/BeatrixListener.java
@@ -63,6 +63,7 @@ import org.killbill.billing.notification.plugin.api.InvoicePaymentMetadata;
 import org.killbill.billing.notification.plugin.api.PaymentMetadata;
 import org.killbill.billing.notification.plugin.api.SubscriptionMetadata;
 import org.killbill.billing.notification.plugin.api.SubscriptionMetadata.ActionType;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.subscription.api.SubscriptionBaseTransitionType;
 import org.killbill.billing.util.callcontext.CallOrigin;
 import org.killbill.billing.util.callcontext.InternalCallContextFactory;
@@ -180,7 +181,7 @@ public class BeatrixListener {
                 }
                 objectId = realEventBS.getBlockableId();
 
-                if (EntitlementService.ENTITLEMENT_SERVICE_NAME.equals(realEventBS.getService())) {
+                if (KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName().equals(realEventBS.getService())) {
                     if (DefaultEntitlementApi.ENT_STATE_START.equals(realEventBS.getStateName())) {
                         eventBusType = ExtBusEventType.ENTITLEMENT_CREATION;
                     } else if (DefaultEntitlementApi.ENT_STATE_BLOCKED.equals(realEventBS.getStateName())) {
diff --git a/beatrix/src/test/java/org/killbill/billing/beatrix/integration/TestIntegrationParentInvoice.java b/beatrix/src/test/java/org/killbill/billing/beatrix/integration/TestIntegrationParentInvoice.java
index a0d0dcf..3813266 100644
--- a/beatrix/src/test/java/org/killbill/billing/beatrix/integration/TestIntegrationParentInvoice.java
+++ b/beatrix/src/test/java/org/killbill/billing/beatrix/integration/TestIntegrationParentInvoice.java
@@ -50,6 +50,7 @@ import org.killbill.billing.invoice.notification.ParentInvoiceCommitmentNotifier
 import org.killbill.billing.payment.api.Payment;
 import org.killbill.billing.payment.api.PaymentApiException;
 import org.killbill.billing.payment.api.PluginProperty;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.notificationq.api.NotificationEvent;
 import org.killbill.notificationq.api.NotificationEventWithMetadata;
 import org.killbill.notificationq.api.NotificationQueue;
@@ -97,7 +98,7 @@ public class TestIntegrationParentInvoice extends TestIntegrationBase {
         assertEquals(parentInvoice.getBalance().compareTo(BigDecimal.ZERO), 0);
 
         // Verify the notification exists and the efective time matches the default configuration '23:59:59'
-        final NotificationQueue notificationQueue = notificationQueueService.getNotificationQueue(DefaultInvoiceService.INVOICE_SERVICE_NAME, ParentInvoiceCommitmentNotifier.PARENT_INVOICE_COMMITMENT_NOTIFIER_QUEUE);
+        final NotificationQueue notificationQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.INVOICE_SERVICE.getServiceName(), ParentInvoiceCommitmentNotifier.PARENT_INVOICE_COMMITMENT_NOTIFIER_QUEUE);
         final Iterable<NotificationEventWithMetadata<NotificationEvent>> events = notificationQueue.getFutureNotificationForSearchKey2(new DateTime(2050, 5, 15, 0, 0, 0, 0, testTimeZone), internalCallContext.getTenantRecordId());
         //
         final Iterator<NotificationEventWithMetadata<NotificationEvent>> metadataEventIterator = events.iterator();
diff --git a/beatrix/src/test/java/org/killbill/billing/beatrix/integration/TestWithInvoicePlugin.java b/beatrix/src/test/java/org/killbill/billing/beatrix/integration/TestWithInvoicePlugin.java
index d8c5a35..bf439c2 100644
--- a/beatrix/src/test/java/org/killbill/billing/beatrix/integration/TestWithInvoicePlugin.java
+++ b/beatrix/src/test/java/org/killbill/billing/beatrix/integration/TestWithInvoicePlugin.java
@@ -60,6 +60,7 @@ import org.killbill.billing.invoice.plugin.api.PriorInvoiceResult;
 import org.killbill.billing.osgi.api.OSGIServiceDescriptor;
 import org.killbill.billing.osgi.api.OSGIServiceRegistration;
 import org.killbill.billing.payment.api.PluginProperty;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.util.callcontext.CallContext;
 import org.killbill.notificationq.api.NotificationEventWithMetadata;
 import org.killbill.notificationq.api.NotificationQueue;
@@ -734,7 +735,7 @@ public class TestWithInvoicePlugin extends TestIntegrationBase {
     }
 
     private List<NotificationEventWithMetadata> getFutureInvoiceNotifications() throws NoSuchNotificationQueue {
-        final NotificationQueue notificationQueue = notificationQueueService.getNotificationQueue(DefaultInvoiceService.INVOICE_SERVICE_NAME, DefaultNextBillingDateNotifier.NEXT_BILLING_DATE_NOTIFIER_QUEUE);
+        final NotificationQueue notificationQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.INVOICE_SERVICE.getServiceName(), DefaultNextBillingDateNotifier.NEXT_BILLING_DATE_NOTIFIER_QUEUE);
         return ImmutableList.<NotificationEventWithMetadata>copyOf(notificationQueue.getFutureNotificationForSearchKeys(internalCallContext.getAccountRecordId(), internalCallContext.getTenantRecordId()));
     }
 
diff --git a/catalog/src/main/java/org/killbill/billing/catalog/DefaultCatalogService.java b/catalog/src/main/java/org/killbill/billing/catalog/DefaultCatalogService.java
index 5dbd140..37a00a1 100644
--- a/catalog/src/main/java/org/killbill/billing/catalog/DefaultCatalogService.java
+++ b/catalog/src/main/java/org/killbill/billing/catalog/DefaultCatalogService.java
@@ -40,7 +40,6 @@ import com.google.inject.Inject;
 public class DefaultCatalogService implements KillbillService, CatalogService {
 
     private static final Logger log = LoggerFactory.getLogger(DefaultCatalogService.class);
-    private static final String CATALOG_SERVICE_NAME = "catalog-service";
 
     private final CatalogConfig config;
     private final TenantInternalApi tenantInternalApi;
@@ -83,7 +82,12 @@ public class DefaultCatalogService implements KillbillService, CatalogService {
 
     @Override
     public String getName() {
-        return CATALOG_SERVICE_NAME;
+        return KILLBILL_SERVICES.CATALOG_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.CATALOG_SERVICE.getRegistrationOrdering();
     }
 
     @Override
diff --git a/currency/src/main/java/org/killbill/billing/currency/DefaultCurrencyService.java b/currency/src/main/java/org/killbill/billing/currency/DefaultCurrencyService.java
index 0b3e9b8..2f0eff9 100644
--- a/currency/src/main/java/org/killbill/billing/currency/DefaultCurrencyService.java
+++ b/currency/src/main/java/org/killbill/billing/currency/DefaultCurrencyService.java
@@ -25,10 +25,14 @@ public class DefaultCurrencyService implements CurrencyService {
 
     private static final Logger log = LoggerFactory.getLogger(DefaultCurrencyService.class);
 
-    public static final String SERVICE_NAME = "currency-service";
 
     @Override
     public String getName() {
-        return SERVICE_NAME;
+        return KILLBILL_SERVICES.CURRENCY_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.CURRENCY_SERVICE.getRegistrationOrdering();
     }
 }
diff --git a/entitlement/src/main/java/org/killbill/billing/entitlement/api/BlockingStateOrdering.java b/entitlement/src/main/java/org/killbill/billing/entitlement/api/BlockingStateOrdering.java
index 6648e03..40551a4 100644
--- a/entitlement/src/main/java/org/killbill/billing/entitlement/api/BlockingStateOrdering.java
+++ b/entitlement/src/main/java/org/killbill/billing/entitlement/api/BlockingStateOrdering.java
@@ -42,6 +42,7 @@ import org.killbill.billing.entitlement.DefaultEntitlementService;
 import org.killbill.billing.entitlement.block.BlockingChecker.BlockingAggregator;
 import org.killbill.billing.entitlement.block.DefaultBlockingChecker.DefaultBlockingAggregator;
 import org.killbill.billing.junction.DefaultBlockingState;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Function;
@@ -183,10 +184,10 @@ public class BlockingStateOrdering extends EntitlementOrderingBase {
 
         // For consistency, make sure entitlement-service and billing-service events always happen in a
         // deterministic order (e.g. after other services for STOP events and before for START events)
-        if ((DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME.equals(serviceName) ||
+        if ((KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName().equals(serviceName) ||
              BILLING_SERVICE_NAME.equals(serviceName) ||
              ENT_BILLING_SERVICE_NAME.equals(serviceName)) &&
-            !(DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME.equals(next.getServiceName()) ||
+            !(KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName().equals(next.getServiceName()) ||
               BILLING_SERVICE_NAME.equals(next.getServiceName()) ||
               ENT_BILLING_SERVICE_NAME.equals(next.getServiceName()))) {
             // first is an entitlement-service or billing-service event, but not second
@@ -196,10 +197,10 @@ public class BlockingStateOrdering extends EntitlementOrderingBase {
             } else {
                 return -1;
             }
-        } else if ((DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME.equals(next.getServiceName()) ||
+        } else if ((KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName().equals(next.getServiceName()) ||
                     BILLING_SERVICE_NAME.equals(next.getServiceName()) ||
                     ENT_BILLING_SERVICE_NAME.equals(next.getServiceName())) &&
-                   !(DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME.equals(serviceName) ||
+                   !(KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName().equals(serviceName) ||
                      BILLING_SERVICE_NAME.equals(serviceName) ||
                      ENT_BILLING_SERVICE_NAME.equals(serviceName))) {
             // second is an entitlement-service or billing-service event, but not first
@@ -477,11 +478,11 @@ public class BlockingStateOrdering extends EntitlementOrderingBase {
             // across all services
             //
             final BlockingAggregator stateBefore = getState();
-            if (DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME.equals(fixedBlockingState.getService())) {
+            if (KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName().equals(fixedBlockingState.getService())) {
                 // Some blocking states will be added as entitlement-service and billing-service via addEntitlementEvent
                 // (see above). Because of it, we need to multiplex entitlement events here.
                 // TODO - this is magic and fragile. We should revisit how we create this state machine.
-                perServiceBlockingState.put(DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME, fixedBlockingState);
+                perServiceBlockingState.put(KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), fixedBlockingState);
                 perServiceBlockingState.put(BILLING_SERVICE_NAME, fixedBlockingState);
             } else {
                 perServiceBlockingState.put(fixedBlockingState.getService(), fixedBlockingState);
@@ -506,7 +507,7 @@ public class BlockingStateOrdering extends EntitlementOrderingBase {
                 result.add(SubscriptionEventType.PAUSE_BILLING);
             }
 
-            if (!shouldResumeEntitlement && !shouldResumeBilling && !shouldBlockEntitlement && !shouldBlockBilling && !fixedBlockingState.getService().equals(DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME)) {
+            if (!shouldResumeEntitlement && !shouldResumeBilling && !shouldBlockEntitlement && !shouldBlockBilling && !fixedBlockingState.getService().equals(KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName())) {
                 result.add(SubscriptionEventType.SERVICE_STATE_CHANGE);
             }
             return result;
@@ -522,12 +523,12 @@ public class BlockingStateOrdering extends EntitlementOrderingBase {
     }
 
     private static boolean isStartEntitlement(final BlockingState blockingState) {
-        return DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME.equals(blockingState.getService()) &&
+        return KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName().equals(blockingState.getService()) &&
                DefaultEntitlementApi.ENT_STATE_START.equals(blockingState.getStateName());
     }
 
     private static boolean isStopEntitlement(final BlockingState blockingState) {
-        return DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME.equals(blockingState.getService()) &&
+        return KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName().equals(blockingState.getService()) &&
                DefaultEntitlementApi.ENT_STATE_CANCELLED.equals(blockingState.getStateName());
     }
 
@@ -560,7 +561,7 @@ public class BlockingStateOrdering extends EntitlementOrderingBase {
                                                                                                     SubscriptionEventType.START_ENTITLEMENT,
                                                                                                     false,
                                                                                                     false,
-                                                                                                    DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                                                    KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                                                     SubscriptionEventType.START_ENTITLEMENT.toString(),
                                                                                                     cur.getPrevProduct(),
                                                                                                     cur.getPrevPlan(),
@@ -598,7 +599,7 @@ public class BlockingStateOrdering extends EntitlementOrderingBase {
             final Set<UUID> ENT_STATE_START_entitlementIdSet = ImmutableSet.copyOf(Iterables.transform(Iterables.filter(blockingStates, new Predicate<BlockingState>() {
                 @Override
                 public boolean apply(final BlockingState input) {
-                    return input.getService().equals(DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME) && input.getStateName().equals(DefaultEntitlementApi.ENT_STATE_START);
+                    return input.getService().equals(KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName()) && input.getStateName().equals(DefaultEntitlementApi.ENT_STATE_START);
                 }
             }), new Function<BlockingState, UUID>() {
                 @Override
diff --git a/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultEntitlement.java b/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultEntitlement.java
index 58dbd76..172c7cf 100644
--- a/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultEntitlement.java
+++ b/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultEntitlement.java
@@ -58,6 +58,7 @@ import org.killbill.billing.entitlement.plugin.api.OperationType;
 import org.killbill.billing.entity.EntityBase;
 import org.killbill.billing.junction.DefaultBlockingState;
 import org.killbill.billing.payment.api.PluginProperty;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.security.Logical;
 import org.killbill.billing.security.Permission;
 import org.killbill.billing.security.SecurityApiException;
@@ -359,7 +360,7 @@ public class DefaultEntitlement extends EntityBase implements Entitlement {
                 }
 
                 final DateTime entitlementEffectiveCancelDate = dateHelper.fromLocalDateAndReferenceTimeWithMinimum(entitlementEffectiveDate, getEventsStream().getEntitlementEffectiveStartDateTime(), updatedPluginContext.getCreatedDate(), contextWithValidAccountRecordId);
-                final BlockingState newBlockingState = new DefaultBlockingState(getId(), BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_CANCELLED, EntitlementService.ENTITLEMENT_SERVICE_NAME, true, true, false, entitlementEffectiveCancelDate);
+                final BlockingState newBlockingState = new DefaultBlockingState(getId(), BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_CANCELLED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), true, true, false, entitlementEffectiveCancelDate);
                 final Collection<NotificationEvent> notificationEvents = new ArrayList<NotificationEvent>();
                 final Collection<BlockingState> addOnsBlockingStates = computeAddOnBlockingStates(entitlementEffectiveCancelDate, notificationEvents, callContext, contextWithValidAccountRecordId);
 
@@ -503,7 +504,7 @@ public class DefaultEntitlement extends EntityBase implements Entitlement {
                 }
 
                 final DateTime effectiveCancelDate = dateHelper.fromLocalDateAndReferenceTimeWithMinimum(entitlementEffectiveDate, getEventsStream().getEntitlementEffectiveStartDateTime(), updatedPluginContext.getCreatedDate(), contextWithValidAccountRecordId);
-                final BlockingState newBlockingState = new DefaultBlockingState(getId(), BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_CANCELLED, EntitlementService.ENTITLEMENT_SERVICE_NAME, true, true, false, effectiveCancelDate);
+                final BlockingState newBlockingState = new DefaultBlockingState(getId(), BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_CANCELLED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), true, true, false, effectiveCancelDate);
                 final Collection<NotificationEvent> notificationEvents = new ArrayList<NotificationEvent>();
                 final Collection<BlockingState> addOnsBlockingStates = computeAddOnBlockingStates(effectiveCancelDate, notificationEvents, callContext, contextWithValidAccountRecordId);
 
@@ -849,7 +850,7 @@ public class DefaultEntitlement extends EntityBase implements Entitlement {
                                           final NotificationEvent notificationEvent,
                                           final InternalCallContext context) {
         try {
-            final NotificationQueue subscriptionEventQueue = notificationQueueService.getNotificationQueue(DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+            final NotificationQueue subscriptionEventQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                                                            DefaultEntitlementService.NOTIFICATION_QUEUE_NAME);
             subscriptionEventQueue.recordFutureNotification(effectiveDate, notificationEvent, context.getUserToken(), context.getAccountRecordId(), context.getTenantRecordId());
         } catch (final NoSuchNotificationQueue e) {
diff --git a/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultEntitlementApi.java b/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultEntitlementApi.java
index 11eea65..3deb24d 100644
--- a/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultEntitlementApi.java
+++ b/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultEntitlementApi.java
@@ -58,6 +58,7 @@ import org.killbill.billing.entitlement.plugin.api.EntitlementContext;
 import org.killbill.billing.entitlement.plugin.api.OperationType;
 import org.killbill.billing.junction.DefaultBlockingState;
 import org.killbill.billing.payment.api.PluginProperty;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.security.api.SecurityApi;
 import org.killbill.billing.subscription.api.SubscriptionBase;
 import org.killbill.billing.subscription.api.SubscriptionBaseInternalApi;
@@ -342,7 +343,7 @@ public class DefaultEntitlementApi extends DefaultEntitlementApiBase implements 
                     // Block all associated subscriptions - TODO Do we want to block the bundle as well (this will add an extra STOP_ENTITLEMENT event in the bundle timeline stream)?
                     // Note that there is no un-transfer at the moment, so we effectively add a blocking state on disk for all subscriptions
                     for (final SubscriptionBase subscriptionBase : subscriptionBaseInternalApi.getSubscriptionsForBundle(bundleId, null, contextWithSourceAccountRecordId)) {
-                        final BlockingState blockingState = new DefaultBlockingState(subscriptionBase.getId(), BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_CANCELLED, EntitlementService.ENTITLEMENT_SERVICE_NAME, true, true, false, requestedDate);
+                        final BlockingState blockingState = new DefaultBlockingState(subscriptionBase.getId(), BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_CANCELLED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), true, true, false, requestedDate);
                         blockingStates.put(blockingState, subscriptionBase.getBundleId());
                     }
                     entitlementUtils.setBlockingStateAndPostBlockingTransitionEvent(blockingStates, contextWithSourceAccountRecordId);
@@ -353,7 +354,7 @@ public class DefaultEntitlementApi extends DefaultEntitlementApiBase implements 
                     blockingStates.clear();
                     final DateTime entitlementRequestedDate = dateHelper.fromLocalDateAndReferenceTime(baseEntitlementWithAddOnsSpecifier.getEntitlementEffectiveDate(), updatedPluginContext.getCreatedDate(), contextWithDestAccountRecordId);
                     for (final SubscriptionBase subscriptionBase : subscriptionBaseInternalApi.getSubscriptionsForBundle(newBundle.getId(), null, contextWithDestAccountRecordId)) {
-                        final BlockingState newBlockingState = new DefaultBlockingState(subscriptionBase.getId(), BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, EntitlementService.ENTITLEMENT_SERVICE_NAME, false, false, false, entitlementRequestedDate);
+                        final BlockingState newBlockingState = new DefaultBlockingState(subscriptionBase.getId(), BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), false, false, false, entitlementRequestedDate);
                         blockingStates.put(newBlockingState, subscriptionBase.getBundleId());
                     }
                     entitlementUtils.setBlockingStateAndPostBlockingTransitionEvent(blockingStates, contextWithDestAccountRecordId);
@@ -572,7 +573,7 @@ public class DefaultEntitlementApi extends DefaultEntitlementApiBase implements 
                 final BlockingState blockingState = new DefaultBlockingState(subscriptionBase.getId(),
                                                                              BlockingStateType.SUBSCRIPTION,
                                                                              DefaultEntitlementApi.ENT_STATE_START,
-                                                                             EntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                             KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                              false,
                                                                              false,
                                                                              false,
diff --git a/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultSubscriptionApi.java b/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultSubscriptionApi.java
index 2178510..69b5a51 100644
--- a/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultSubscriptionApi.java
+++ b/entitlement/src/main/java/org/killbill/billing/entitlement/api/DefaultSubscriptionApi.java
@@ -52,6 +52,7 @@ import org.killbill.billing.entitlement.plugin.api.EntitlementContext;
 import org.killbill.billing.entitlement.plugin.api.OperationType;
 import org.killbill.billing.junction.DefaultBlockingState;
 import org.killbill.billing.payment.api.PluginProperty;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.subscription.api.SubscriptionBase;
 import org.killbill.billing.subscription.api.SubscriptionBaseInternalApi;
 import org.killbill.billing.subscription.api.user.SubscriptionBaseApiException;
@@ -324,7 +325,7 @@ public class DefaultSubscriptionApi implements SubscriptionApi {
         logAddBlockingState(log, inputBlockingState, inputEffectiveDate);
 
         // This is in no way an exhaustive arg validation, but to to ensure plugin would not hijack private entitlement state or service name
-        if (inputBlockingState.getService() == null || inputBlockingState.getService().equals(EntitlementService.ENTITLEMENT_SERVICE_NAME)) {
+        if (inputBlockingState.getService() == null || inputBlockingState.getService().equals(KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName())) {
             throw new EntitlementApiException(ErrorCode.SUB_BLOCKING_STATE_INVALID_ARG, "Need to specify a valid serviceName");
         }
 
diff --git a/entitlement/src/main/java/org/killbill/billing/entitlement/api/EntitlementOrderingBase.java b/entitlement/src/main/java/org/killbill/billing/entitlement/api/EntitlementOrderingBase.java
index 6643f92..d043873 100644
--- a/entitlement/src/main/java/org/killbill/billing/entitlement/api/EntitlementOrderingBase.java
+++ b/entitlement/src/main/java/org/killbill/billing/entitlement/api/EntitlementOrderingBase.java
@@ -18,6 +18,7 @@
 package org.killbill.billing.entitlement.api;
 
 import org.killbill.billing.entitlement.DefaultEntitlementService;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 
 public abstract class EntitlementOrderingBase {
 
@@ -26,7 +27,7 @@ public abstract class EntitlementOrderingBase {
 
     protected static String getRealServiceNameForEntitlementOrExternalServiceName(final String originalServiceName, final SubscriptionEventType eventType) {
         final String serviceName;
-        if (DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME.equals(originalServiceName)) {
+        if (KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName().equals(originalServiceName)) {
             serviceName = getServiceName(eventType);
         } else {
             serviceName = originalServiceName;
@@ -47,7 +48,7 @@ public abstract class EntitlementOrderingBase {
                 return ENT_BILLING_SERVICE_NAME;
 
             default:
-                return DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME;
+                return KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName();
         }
     }
 }
diff --git a/entitlement/src/main/java/org/killbill/billing/entitlement/api/svcs/DefaultEntitlementApiBase.java b/entitlement/src/main/java/org/killbill/billing/entitlement/api/svcs/DefaultEntitlementApiBase.java
index e73bdad..61563f2 100644
--- a/entitlement/src/main/java/org/killbill/billing/entitlement/api/svcs/DefaultEntitlementApiBase.java
+++ b/entitlement/src/main/java/org/killbill/billing/entitlement/api/svcs/DefaultEntitlementApiBase.java
@@ -57,6 +57,7 @@ import org.killbill.billing.entitlement.plugin.api.EntitlementContext;
 import org.killbill.billing.entitlement.plugin.api.OperationType;
 import org.killbill.billing.junction.DefaultBlockingState;
 import org.killbill.billing.payment.api.PluginProperty;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.security.api.SecurityApi;
 import org.killbill.billing.subscription.api.SubscriptionBase;
 import org.killbill.billing.subscription.api.SubscriptionBaseInternalApi;
@@ -164,7 +165,7 @@ public class DefaultEntitlementApiBase {
             public Void doCall(final EntitlementApi entitlementApi, final EntitlementContext updatedPluginContext) throws EntitlementApiException {
                 try {
                     final SubscriptionBase baseSubscription = subscriptionInternalApi.getBaseSubscription(bundleId, internalCallContext);
-                    blockUnblockBundle(bundleId, DefaultEntitlementApi.ENT_STATE_BLOCKED, EntitlementService.ENTITLEMENT_SERVICE_NAME, localEffectiveDate, true, true, true, baseSubscription, internalCallContext);
+                    blockUnblockBundle(bundleId, DefaultEntitlementApi.ENT_STATE_BLOCKED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), localEffectiveDate, true, true, true, baseSubscription, internalCallContext);
                 } catch (SubscriptionBaseApiException e) {
                     throw new EntitlementApiException(e);
                 }
@@ -197,7 +198,7 @@ public class DefaultEntitlementApiBase {
             public Void doCall(final EntitlementApi entitlementApi, final EntitlementContext updatedPluginContext) throws EntitlementApiException {
                 try {
                     final SubscriptionBase baseSubscription = subscriptionInternalApi.getBaseSubscription(bundleId, internalCallContext);
-                    blockUnblockBundle(bundleId, DefaultEntitlementApi.ENT_STATE_CLEAR, EntitlementService.ENTITLEMENT_SERVICE_NAME, localEffectiveDate, false, false, false, baseSubscription, internalCallContext);
+                    blockUnblockBundle(bundleId, DefaultEntitlementApi.ENT_STATE_CLEAR, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), localEffectiveDate, false, false, false, baseSubscription, internalCallContext);
                 } catch (SubscriptionBaseApiException e) {
                     throw new EntitlementApiException(e);
                 }
diff --git a/entitlement/src/main/java/org/killbill/billing/entitlement/api/svcs/DefaultEntitlementInternalApi.java b/entitlement/src/main/java/org/killbill/billing/entitlement/api/svcs/DefaultEntitlementInternalApi.java
index 0b69332..cf0128a 100644
--- a/entitlement/src/main/java/org/killbill/billing/entitlement/api/svcs/DefaultEntitlementInternalApi.java
+++ b/entitlement/src/main/java/org/killbill/billing/entitlement/api/svcs/DefaultEntitlementInternalApi.java
@@ -61,6 +61,7 @@ import org.killbill.billing.entitlement.plugin.api.EntitlementContext;
 import org.killbill.billing.entitlement.plugin.api.OperationType;
 import org.killbill.billing.junction.DefaultBlockingState;
 import org.killbill.billing.payment.api.PluginProperty;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.security.api.SecurityApi;
 import org.killbill.billing.subscription.api.SubscriptionBase;
 import org.killbill.billing.subscription.api.SubscriptionBaseInternalApi;
@@ -172,7 +173,7 @@ public class DefaultEntitlementInternalApi extends DefaultEntitlementApiBase imp
                                           final NotificationEvent notificationEvent,
                                           final InternalCallContext context) {
         try {
-            final NotificationQueue subscriptionEventQueue = notificationQueueService.getNotificationQueue(DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+            final NotificationQueue subscriptionEventQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                                                            DefaultEntitlementService.NOTIFICATION_QUEUE_NAME);
             subscriptionEventQueue.recordFutureNotification(effectiveDate, notificationEvent, context.getUserToken(), context.getAccountRecordId(), context.getTenantRecordId());
         } catch (final NoSuchNotificationQueue e) {
@@ -250,7 +251,7 @@ public class DefaultEntitlementInternalApi extends DefaultEntitlementApiBase imp
                 effectiveDate = subscriptionBaseCancellationDate;
             }
 
-            final BlockingState newBlockingState = new DefaultBlockingState(entitlement.getId(), BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_CANCELLED, EntitlementService.ENTITLEMENT_SERVICE_NAME, true, true, false, effectiveDate);
+            final BlockingState newBlockingState = new DefaultBlockingState(entitlement.getId(), BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_CANCELLED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), true, true, false, effectiveDate);
             final Collection<NotificationEvent> notificationEvents = new ArrayList<NotificationEvent>();
             final Collection<BlockingState> addOnsBlockingStates = entitlement.computeAddOnBlockingStates(effectiveDate, notificationEvents, callContext, internalCallContext);
 
diff --git a/entitlement/src/main/java/org/killbill/billing/entitlement/dao/DefaultBlockingStateDao.java b/entitlement/src/main/java/org/killbill/billing/entitlement/dao/DefaultBlockingStateDao.java
index 0e7aada..9547418 100644
--- a/entitlement/src/main/java/org/killbill/billing/entitlement/dao/DefaultBlockingStateDao.java
+++ b/entitlement/src/main/java/org/killbill/billing/entitlement/dao/DefaultBlockingStateDao.java
@@ -46,6 +46,7 @@ import org.killbill.billing.entitlement.api.EntitlementApiException;
 import org.killbill.billing.entitlement.block.BlockingChecker.BlockingAggregator;
 import org.killbill.billing.entitlement.block.StatelessBlockingChecker;
 import org.killbill.billing.entitlement.engine.core.BlockingTransitionNotificationKey;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.util.cache.Cachable.CacheType;
 import org.killbill.billing.util.cache.CacheController;
 import org.killbill.billing.util.cache.CacheControllerDispatcher;
@@ -351,7 +352,7 @@ public class DefaultBlockingStateDao extends EntityDaoBase<BlockingStateModelDao
                                                          final NotificationEvent notificationEvent,
                                                          final InternalCallContext context) {
         try {
-            final NotificationQueue subscriptionEventQueue = notificationQueueService.getNotificationQueue(DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+            final NotificationQueue subscriptionEventQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                                                            DefaultEntitlementService.NOTIFICATION_QUEUE_NAME);
             subscriptionEventQueue.recordFutureNotificationFromTransaction(entitySqlDaoWrapperFactory.getHandle().getConnection(),
                                                                            effectiveDate,
diff --git a/entitlement/src/main/java/org/killbill/billing/entitlement/dao/ProxyBlockingStateDao.java b/entitlement/src/main/java/org/killbill/billing/entitlement/dao/ProxyBlockingStateDao.java
index aac961f..d2840da 100644
--- a/entitlement/src/main/java/org/killbill/billing/entitlement/dao/ProxyBlockingStateDao.java
+++ b/entitlement/src/main/java/org/killbill/billing/entitlement/dao/ProxyBlockingStateDao.java
@@ -42,6 +42,7 @@ import org.killbill.billing.entitlement.api.BlockingStateType;
 import org.killbill.billing.entitlement.api.DefaultEntitlementApi;
 import org.killbill.billing.entitlement.api.EntitlementApiException;
 import org.killbill.billing.entitlement.engine.core.EventsStreamBuilder;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.subscription.api.SubscriptionBase;
 import org.killbill.billing.subscription.api.SubscriptionBaseInternalApi;
 import org.killbill.billing.subscription.api.user.SubscriptionBaseApiException;
@@ -351,7 +352,7 @@ public class ProxyBlockingStateDao implements BlockingStateDao {
 
     private static boolean isEntitlementCancellationBlockingState(final BlockingState blockingState) {
         return BlockingStateType.SUBSCRIPTION.equals(blockingState.getType()) &&
-               EntitlementService.ENTITLEMENT_SERVICE_NAME.equals(blockingState.getService()) &&
+               KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName().equals(blockingState.getService()) &&
                DefaultEntitlementApi.ENT_STATE_CANCELLED.equals(blockingState.getStateName());
     }
 }
diff --git a/entitlement/src/main/java/org/killbill/billing/entitlement/DefaultEntitlementService.java b/entitlement/src/main/java/org/killbill/billing/entitlement/DefaultEntitlementService.java
index 00ab6c3..25a5ab7 100644
--- a/entitlement/src/main/java/org/killbill/billing/entitlement/DefaultEntitlementService.java
+++ b/entitlement/src/main/java/org/killbill/billing/entitlement/DefaultEntitlementService.java
@@ -90,7 +90,12 @@ public class DefaultEntitlementService implements EntitlementService {
 
     @Override
     public String getName() {
-        return EntitlementService.ENTITLEMENT_SERVICE_NAME;
+        return KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getRegistrationOrdering();
     }
 
     @LifecycleHandlerType(LifecycleLevel.INIT_SERVICE)
@@ -114,7 +119,7 @@ public class DefaultEntitlementService implements EntitlementService {
                 }
             };
 
-            entitlementEventQueue = notificationQueueService.createNotificationQueue(ENTITLEMENT_SERVICE_NAME,
+            entitlementEventQueue = notificationQueueService.createNotificationQueue(KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                                      NOTIFICATION_QUEUE_NAME,
                                                                                      queueHandler);
         } catch (final NotificationQueueAlreadyExists e) {
@@ -165,7 +170,7 @@ public class DefaultEntitlementService implements EntitlementService {
                                           final NotificationEvent notificationEvent,
                                           final InternalCallContext context) {
         try {
-            final NotificationQueue subscriptionEventQueue = notificationQueueService.getNotificationQueue(DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+            final NotificationQueue subscriptionEventQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                                                            DefaultEntitlementService.NOTIFICATION_QUEUE_NAME);
             subscriptionEventQueue.recordFutureNotification(effectiveDate, notificationEvent, context.getUserToken(), context.getAccountRecordId(), context.getTenantRecordId());
         } catch (final NoSuchNotificationQueue e) {
diff --git a/entitlement/src/main/java/org/killbill/billing/entitlement/engine/core/DefaultEventsStream.java b/entitlement/src/main/java/org/killbill/billing/entitlement/engine/core/DefaultEventsStream.java
index 9c5a89b..daf7ff6 100644
--- a/entitlement/src/main/java/org/killbill/billing/entitlement/engine/core/DefaultEventsStream.java
+++ b/entitlement/src/main/java/org/killbill/billing/entitlement/engine/core/DefaultEventsStream.java
@@ -42,6 +42,7 @@ import org.killbill.billing.entitlement.api.Entitlement.EntitlementState;
 import org.killbill.billing.entitlement.block.BlockingChecker;
 import org.killbill.billing.entitlement.block.BlockingChecker.BlockingAggregator;
 import org.killbill.billing.junction.DefaultBlockingState;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.subscription.api.SubscriptionBase;
 import org.killbill.billing.subscription.api.SubscriptionBaseTransitionType;
 import org.killbill.billing.subscription.api.user.SubscriptionBaseBundle;
@@ -408,7 +409,7 @@ public class DefaultEventsStream implements EventsStream {
                                                                                return new DefaultBlockingState(input.getId(),
                                                                                                                BlockingStateType.SUBSCRIPTION,
                                                                                                                DefaultEntitlementApi.ENT_STATE_CANCELLED,
-                                                                                                               EntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                                                               KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                                                                true,
                                                                                                                true,
                                                                                                                false,
@@ -519,7 +520,7 @@ public class DefaultEventsStream implements EventsStream {
                                                                                        @Override
                                                                                        public boolean apply(final BlockingState input) {
                                                                                            return blockingStateType.equals(input.getType()) &&
-                                                                                                  EntitlementService.ENTITLEMENT_SERVICE_NAME.equals(input.getService()) &&
+                                                                                                  KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName().equals(input.getService()) &&
                                                                                                   input.getBlockedId().equals(blockableId);
                                                                                        }
                                                                                    }));
diff --git a/entitlement/src/main/java/org/killbill/billing/entitlement/engine/core/EntitlementUtils.java b/entitlement/src/main/java/org/killbill/billing/entitlement/engine/core/EntitlementUtils.java
index 5307695..2a30b39 100644
--- a/entitlement/src/main/java/org/killbill/billing/entitlement/engine/core/EntitlementUtils.java
+++ b/entitlement/src/main/java/org/killbill/billing/entitlement/engine/core/EntitlementUtils.java
@@ -31,6 +31,7 @@ import org.killbill.billing.entitlement.api.BlockingState;
 import org.killbill.billing.entitlement.api.BlockingStateType;
 import org.killbill.billing.entitlement.api.DefaultEntitlementApi;
 import org.killbill.billing.entitlement.dao.BlockingStateDao;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.subscription.api.SubscriptionBaseInternalApi;
 import org.killbill.billing.subscription.api.user.SubscriptionBaseApiException;
 import org.killbill.notificationq.api.NotificationQueueService;
@@ -97,7 +98,7 @@ public class EntitlementUtils {
         return Iterables.tryFind(nonAddonUUIDs, new Predicate<UUID>() {
             @Override
             public boolean apply(final UUID input) {
-                final BlockingState state = dao.getBlockingStateForService(input, BlockingStateType.SUBSCRIPTION, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME, tenantContext);
+                final BlockingState state = dao.getBlockingStateForService(input, BlockingStateType.SUBSCRIPTION, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), tenantContext);
                 return (state == null || !state.getStateName().equals(DefaultEntitlementApi.ENT_STATE_CANCELLED));
             }
         }).orNull();
diff --git a/entitlement/src/test/java/org/killbill/billing/entitlement/api/TestBlockingStateOrdering.java b/entitlement/src/test/java/org/killbill/billing/entitlement/api/TestBlockingStateOrdering.java
index 02a7581..5fa19d9 100644
--- a/entitlement/src/test/java/org/killbill/billing/entitlement/api/TestBlockingStateOrdering.java
+++ b/entitlement/src/test/java/org/killbill/billing/entitlement/api/TestBlockingStateOrdering.java
@@ -26,6 +26,7 @@ import org.joda.time.DateTime;
 import org.killbill.billing.entitlement.DefaultEntitlementService;
 import org.killbill.billing.entitlement.EntitlementTestSuiteNoDB;
 import org.killbill.billing.junction.DefaultBlockingState;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.subscription.api.user.SubscriptionBaseTransition;
 import org.mockito.Mockito;
 import org.testng.Assert;
@@ -42,8 +43,8 @@ public class TestBlockingStateOrdering extends EntitlementTestSuiteNoDB {
         final UUID subscriptionId1 = UUID.randomUUID();
 
         final Collection<BlockingState> blockingStates = new LinkedList<BlockingState>();
-        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME, false, false, now));
-        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, "stuff", DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME, false, false, now.plusDays(1)));
+        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), false, false, now));
+        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, "stuff", KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), false, false, now.plusDays(1)));
 
         final LinkedList<SubscriptionEvent> allEvents = new LinkedList<SubscriptionEvent>();
         allEvents.add(createEvent(subscriptionId1, SubscriptionEventType.START_BILLING, now));
@@ -63,7 +64,7 @@ public class TestBlockingStateOrdering extends EntitlementTestSuiteNoDB {
         final UUID subscriptionId1 = UUID.randomUUID();
 
         final Collection<BlockingState> blockingStates = new LinkedList<BlockingState>();
-        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME, false, false, now));
+        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), false, false, now));
         blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, "svc1", false, false, now.plusDays(1)));
         blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_CANCELLED, "svc1", false, false, now.plusDays(2)));
 
@@ -87,7 +88,7 @@ public class TestBlockingStateOrdering extends EntitlementTestSuiteNoDB {
         final UUID subscriptionId1 = UUID.randomUUID();
 
         final Collection<BlockingState> blockingStates = new LinkedList<BlockingState>();
-        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME, false, false, now));
+        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), false, false, now));
         blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, "stuff", "svc1", true, true, now));
 
         final LinkedList<SubscriptionEvent> allEvents = new LinkedList<SubscriptionEvent>();
@@ -132,7 +133,7 @@ public class TestBlockingStateOrdering extends EntitlementTestSuiteNoDB {
         final UUID subscriptionId1 = UUID.randomUUID();
 
         final Collection<BlockingState> blockingStates = new LinkedList<BlockingState>();
-        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME, false, false, now));
+        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), false, false, now));
         blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, "stuff", "svc1", true, true, now.plusDays(40)));
 
         final LinkedList<SubscriptionEvent> allEvents = new LinkedList<SubscriptionEvent>();
@@ -155,7 +156,7 @@ public class TestBlockingStateOrdering extends EntitlementTestSuiteNoDB {
         final UUID subscriptionId1 = UUID.randomUUID();
 
         final Collection<BlockingState> blockingStates = new LinkedList<BlockingState>();
-        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME, false, false, now));
+        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), false, false, now));
         blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, "stuff", "svc1", true, true, now.plusDays(30)));
 
         final LinkedList<SubscriptionEvent> allEvents = new LinkedList<SubscriptionEvent>();
@@ -178,7 +179,7 @@ public class TestBlockingStateOrdering extends EntitlementTestSuiteNoDB {
         final UUID subscriptionId1 = UUID.randomUUID();
 
         final Collection<BlockingState> blockingStates = new LinkedList<BlockingState>();
-        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME, false, false, now));
+        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), false, false, now));
         blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, "stuff", "svc1", true, true, now.plusDays(30)));
         blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, "stuff", "svc1", false, false, now.plusDays(30)));
 
@@ -204,7 +205,7 @@ public class TestBlockingStateOrdering extends EntitlementTestSuiteNoDB {
         final UUID subscriptionId1 = UUID.randomUUID();
 
         final Collection<BlockingState> blockingStates = new LinkedList<BlockingState>();
-        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME, false, false, now));
+        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), false, false, now));
         blockingStates.add(createBlockingState(UUID.randomUUID(), BlockingStateType.ACCOUNT, "stuff", "svc1", true, true, now.plusDays(30)));
 
         final LinkedList<SubscriptionEvent> allEvents = new LinkedList<SubscriptionEvent>();
@@ -227,7 +228,7 @@ public class TestBlockingStateOrdering extends EntitlementTestSuiteNoDB {
         final UUID subscriptionId1 = UUID.randomUUID();
 
         final Collection<BlockingState> blockingStates = new LinkedList<BlockingState>();
-        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME, false, false, now));
+        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), false, false, now));
         blockingStates.add(createBlockingState(UUID.randomUUID(), BlockingStateType.ACCOUNT, "stuff", "svc1", false, true, now.plusDays(10)));
         // Same service
         blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, "stuff", "svc1", true, false, now.plusDays(15)));
@@ -257,7 +258,7 @@ public class TestBlockingStateOrdering extends EntitlementTestSuiteNoDB {
         final UUID subscriptionId1 = UUID.randomUUID();
 
         final Collection<BlockingState> blockingStates = new LinkedList<BlockingState>();
-        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME, false, false, now));
+        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), false, false, now));
         blockingStates.add(createBlockingState(UUID.randomUUID(), BlockingStateType.ACCOUNT, "stuff", "svc1", false, true, now.plusDays(10)));
         // Different service
         blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, "stuff", "svc2", true, false, now.plusDays(15)));
@@ -304,8 +305,8 @@ public class TestBlockingStateOrdering extends EntitlementTestSuiteNoDB {
         final DateTime now = clock.getUTCNow();
 
         final Collection<BlockingState> blockingStates = new LinkedList<BlockingState>();
-        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME, false, false, now));
-        blockingStates.add(createBlockingState(subscriptionId2, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME, false, false, now));
+        blockingStates.add(createBlockingState(subscriptionId1, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), false, false, now));
+        blockingStates.add(createBlockingState(subscriptionId2, BlockingStateType.SUBSCRIPTION, DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(), false, false, now));
         blockingStates.add(createBlockingState(UUID.randomUUID(), BlockingStateType.ACCOUNT, "stuff", "svc1", true, true, now.plusDays(30)));
 
         final LinkedList<SubscriptionEvent> allEvents = new LinkedList<SubscriptionEvent>();
diff --git a/entitlement/src/test/java/org/killbill/billing/entitlement/api/TestDefaultSubscriptionApi.java b/entitlement/src/test/java/org/killbill/billing/entitlement/api/TestDefaultSubscriptionApi.java
index 4744f58..a76aef8 100644
--- a/entitlement/src/test/java/org/killbill/billing/entitlement/api/TestDefaultSubscriptionApi.java
+++ b/entitlement/src/test/java/org/killbill/billing/entitlement/api/TestDefaultSubscriptionApi.java
@@ -39,6 +39,7 @@ import org.killbill.billing.entitlement.api.Entitlement.EntitlementActionPolicy;
 import org.killbill.billing.entitlement.api.Entitlement.EntitlementState;
 import org.killbill.billing.junction.DefaultBlockingState;
 import org.killbill.billing.payment.api.PluginProperty;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.util.api.AuditLevel;
 import org.killbill.billing.util.audit.AuditLog;
 import org.killbill.billing.util.audit.ChangeType;
@@ -351,7 +352,7 @@ public class TestDefaultSubscriptionApi extends EntitlementTestSuiteWithEmbedded
         final Iterable<BlockingState> iterableForCreateState = subscriptionApi.getBlockingStates(account.getId(), ImmutableList.of(BlockingStateType.SUBSCRIPTION), null, OrderingType.ASCENDING, SubscriptionApi.ALL_EVENTS, callContext);
         assertTrue(iterableForCreateState.iterator().hasNext());
         final BlockingState createState = iterableForCreateState.iterator().next();
-        assertEquals(createState.getService(), EntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(createState.getService(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertListenerStatus();
 
         testListener.pushExpectedEvent(NextEvent.BLOCK);
diff --git a/entitlement/src/test/java/org/killbill/billing/entitlement/api/TestDefaultSubscriptionBundleTimeline.java b/entitlement/src/test/java/org/killbill/billing/entitlement/api/TestDefaultSubscriptionBundleTimeline.java
index c54cc1f..6ee3003 100644
--- a/entitlement/src/test/java/org/killbill/billing/entitlement/api/TestDefaultSubscriptionBundleTimeline.java
+++ b/entitlement/src/test/java/org/killbill/billing/entitlement/api/TestDefaultSubscriptionBundleTimeline.java
@@ -35,6 +35,7 @@ import org.killbill.billing.entitlement.DefaultEntitlementService;
 import org.killbill.billing.entitlement.EntitlementTestSuiteNoDB;
 import org.killbill.billing.entitlement.EventsStream;
 import org.killbill.billing.junction.DefaultBlockingState;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.subscription.api.SubscriptionBase;
 import org.killbill.billing.subscription.api.user.SubscriptionBaseTransition;
 import org.killbill.billing.subscription.api.user.SubscriptionBaseTransitionData;
@@ -94,7 +95,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
 
         if (!regressionFlagForOlderVersionThan_0_17_X) {
             final BlockingState bsCreate = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                                    DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                    DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                     false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
             blockingStates.add(bsCreate);
         }
@@ -133,7 +134,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         assertEquals(events.get(2).getSubscriptionEventType(), SubscriptionEventType.PHASE);
         assertEquals(events.get(3).getSubscriptionEventType(), SubscriptionEventType.STOP_BILLING);
 
-        assertEquals(events.get(0).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(0).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(1).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
         assertEquals(events.get(2).getServiceName(), EntitlementOrderingBase.ENT_BILLING_SERVICE_NAME);
         assertEquals(events.get(3).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
@@ -176,7 +177,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
 
         if (!regressionFlagForOlderVersionThan_0_17_X) {
             final BlockingState bsCreate = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                                    DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                    DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                     false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
             blockingStates.add(bsCreate);
         }
@@ -185,7 +186,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         allTransitions.add(tr2);
 
         final BlockingState bsCancel = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                                DefaultEntitlementApi.ENT_STATE_CANCELLED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                DefaultEntitlementApi.ENT_STATE_CANCELLED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                 false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
         blockingStates.add(bsCancel);
 
@@ -251,7 +252,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
 
         if (!regressionFlagForOlderVersionThan_0_17_X) {
             final BlockingState bsCreate = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                                    DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                    DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                     false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
             blockingStates.add(bsCreate);
         }
@@ -260,7 +261,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         effectiveDate = effectiveDate.plusDays(15);
         clock.addDays(15);
         final BlockingState bs1 = new DefaultBlockingState(UUID.randomUUID(), bundleId, BlockingStateType.SUBSCRIPTION_BUNDLE,
-                                                           DefaultEntitlementApi.ENT_STATE_CANCELLED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_CANCELLED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
 
         blockingStates.add(bs1);
@@ -293,9 +294,9 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         assertEquals(events.get(2).getSubscriptionEventType(), SubscriptionEventType.STOP_ENTITLEMENT);
         assertEquals(events.get(3).getSubscriptionEventType(), SubscriptionEventType.STOP_BILLING);
 
-        assertEquals(events.get(0).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(0).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(1).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
-        assertEquals(events.get(2).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(2).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(3).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
 
         assertNull(events.get(0).getPrevPhase());
@@ -334,7 +335,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
 
         if (!regressionFlagForOlderVersionThan_0_17_X) {
             final BlockingState bsCreate = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                                    DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                    DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                     false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
 
             blockingStates.add(bsCreate);
@@ -349,7 +350,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         effectiveDate = effectiveDate.plusDays(12);
         clock.addDays(12);
         final BlockingState bs1 = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                           "NothingUseful1", DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           "NothingUseful1", KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, true, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
 
         blockingStates.add(bs1);
@@ -357,7 +358,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         effectiveDate = effectiveDate.plusDays(42);
         clock.addDays(42);
         final BlockingState bs2 = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                           "NothingUseful2", DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           "NothingUseful2", KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 1L);
 
         blockingStates.add(bs2);
@@ -415,14 +416,14 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         assertEquals(events.get(7).getSubscriptionEventType(), SubscriptionEventType.PAUSE_BILLING);
         assertEquals(events.get(8).getSubscriptionEventType(), SubscriptionEventType.RESUME_BILLING);
 
-        assertEquals(events.get(0).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(0).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(1).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
 
         assertEquals(events.get(2).getServiceName(), EntitlementOrderingBase.ENT_BILLING_SERVICE_NAME);
 
-        assertEquals(events.get(3).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(3).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(4).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
-        assertEquals(events.get(5).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(5).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(6).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
 
         assertEquals(events.get(7).getServiceName(), service);
@@ -478,7 +479,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
 
         if (!regressionFlagForOlderVersionThan_0_17_X) {
             final BlockingState bsCreate = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                                    DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                    DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                     false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
 
             blockingStates.add(bsCreate);
@@ -517,7 +518,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         effectiveDate = effectiveDate.plusDays(15);
         clock.addDays(15);
         final BlockingState bs4 = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                           DefaultEntitlementApi.ENT_STATE_CANCELLED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_CANCELLED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 3L);
 
         blockingStates.add(bs4);
@@ -573,7 +574,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         assertEquals(events.get(8).getSubscriptionEventType(), SubscriptionEventType.SERVICE_STATE_CHANGE);
         assertEquals(events.get(9).getSubscriptionEventType(), SubscriptionEventType.STOP_BILLING);
 
-        assertEquals(events.get(0).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(0).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(1).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
 
         assertEquals(events.get(2).getServiceName(), EntitlementOrderingBase.ENT_BILLING_SERVICE_NAME);
@@ -583,7 +584,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         assertEquals(events.get(5).getServiceName(), overdueService);
         assertEquals(events.get(6).getServiceName(), overdueService);
 
-        assertEquals(events.get(7).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(7).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
 
         assertEquals(events.get(8).getServiceName(), overdueService);
         assertEquals(events.get(9).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
@@ -636,7 +637,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         final List<SubscriptionBaseTransition> allTransitions = new ArrayList<SubscriptionBaseTransition>();
         final List<BlockingState> blockingStates = new ArrayList<BlockingState>();
         final BlockingState bs1 = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                           DefaultEntitlementApi.ENT_STATE_BLOCKED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_BLOCKED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, false, clock.getUTCNow(), clock.getUTCNow(), clock.getUTCNow(), 0L);
 
         blockingStates.add(bs1);
@@ -649,7 +650,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
 
         if (!regressionFlagForOlderVersionThan_0_17_X) {
             final BlockingState bsCreate = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                                    DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                    DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                     false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
 
             blockingStates.add(bsCreate);
@@ -697,7 +698,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         assertEquals(events.get(3).getSubscriptionEventType(), SubscriptionEventType.SERVICE_STATE_CHANGE);
         assertEquals(events.get(4).getSubscriptionEventType(), SubscriptionEventType.STOP_BILLING);
 
-        assertEquals(events.get(0).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(0).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(1).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
         assertEquals(events.get(2).getServiceName(), EntitlementOrderingBase.ENT_BILLING_SERVICE_NAME);
         assertEquals(events.get(3).getServiceName(), service);
@@ -743,7 +744,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
 
         if (!regressionFlagForOlderVersionThan_0_17_X) {
             final BlockingState bsCreate = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                                    DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                    DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                     false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
 
             blockingStates.add(bsCreate);
@@ -757,7 +758,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         effectiveDate = effectiveDate.plusDays(5);
         clock.addDays(5);
         final BlockingState bs1 = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                           DefaultEntitlementApi.ENT_STATE_BLOCKED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_BLOCKED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
         blockingStates.add(bs1);
 
@@ -766,7 +767,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         final SubscriptionBaseTransition tr3 = createTransition(entitlementId, EventType.API_USER, ApiEventType.CANCEL, effectiveDate, clock.getUTCNow(), "phase", null);
         allTransitions.add(tr3);
         final BlockingState bs2 = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                           DefaultEntitlementApi.ENT_STATE_CANCELLED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_CANCELLED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 1L);
 
         blockingStates.add(bs2);
@@ -794,11 +795,11 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         assertEquals(events.get(4).getSubscriptionEventType(), SubscriptionEventType.STOP_ENTITLEMENT);
         assertEquals(events.get(5).getSubscriptionEventType(), SubscriptionEventType.STOP_BILLING);
 
-        assertEquals(events.get(0).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(0).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(1).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
         assertEquals(events.get(2).getServiceName(), EntitlementOrderingBase.ENT_BILLING_SERVICE_NAME);
-        assertEquals(events.get(3).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
-        assertEquals(events.get(4).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(3).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
+        assertEquals(events.get(4).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(5).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
 
         assertNull(events.get(0).getPrevPhase());
@@ -848,7 +849,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
 
         if (!regressionFlagForOlderVersionThan_0_17_X) {
             final BlockingState bsCreate = new DefaultBlockingState(UUID.randomUUID(), entitlementId1, BlockingStateType.SUBSCRIPTION,
-                                                                    DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                    DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                     false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
 
             blockingStatesEnt1.add(bsCreate);
@@ -861,7 +862,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
 
         if (!regressionFlagForOlderVersionThan_0_17_X ) {
             final BlockingState bsCreate2 = new DefaultBlockingState(UUID.randomUUID(), entitlementId2, BlockingStateType.SUBSCRIPTION,
-                                                                     DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                     DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                      false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
 
             blockingStatesEnt2.add(bsCreate2);
@@ -875,7 +876,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         effectiveDate = effectiveDate.plusDays(5);
         clock.addDays(5);
         final BlockingState bs1 = new DefaultBlockingState(UUID.randomUUID(), bundleId, BlockingStateType.SUBSCRIPTION_BUNDLE,
-                                                           DefaultEntitlementApi.ENT_STATE_BLOCKED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_BLOCKED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
         blockingStatesEnt1.add(bs1);
         blockingStatesEnt2.add(bs1);
@@ -885,7 +886,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         final SubscriptionBaseTransition ent1Tr3 = createTransition(entitlementId1, EventType.API_USER, ApiEventType.CANCEL, effectiveDate, clock.getUTCNow(), "phase1", null);
         allTransitions1.add(ent1Tr3);
         final BlockingState bs2 = new DefaultBlockingState(UUID.randomUUID(), entitlementId1, BlockingStateType.SUBSCRIPTION,
-                                                           DefaultEntitlementApi.ENT_STATE_CANCELLED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_CANCELLED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 1L);
 
         blockingStatesEnt1.add(bs2);
@@ -928,17 +929,17 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         assertEquals(events.get(7).getSubscriptionEventType(), SubscriptionEventType.STOP_ENTITLEMENT);
         assertEquals(events.get(8).getSubscriptionEventType(), SubscriptionEventType.STOP_BILLING);
 
-        assertEquals(events.get(0).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(0).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(1).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
-        assertEquals(events.get(2).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(2).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(3).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
 
         assertEquals(events.get(4).getServiceName(), EntitlementOrderingBase.ENT_BILLING_SERVICE_NAME);
 
-        assertEquals(events.get(5).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
-        assertEquals(events.get(6).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(5).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
+        assertEquals(events.get(6).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
 
-        assertEquals(events.get(7).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(7).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(8).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
 
         assertNull(events.get(0).getPrevPhase());
@@ -999,7 +1000,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
 
         if (!regressionFlagForOlderVersionThan_0_17_X) {
             final BlockingState bsCreate = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                                    DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                    DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                     false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
 
             blockingStates.add(bsCreate);
@@ -1042,7 +1043,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         assertEquals(eventsWithOverdueEvent.get(4).getSubscriptionEventType(), SubscriptionEventType.STOP_BILLING);
 
         final BlockingState bs2 = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                           DefaultEntitlementApi.ENT_STATE_CANCELLED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_CANCELLED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 1L);
 
         blockingStates.add(bs2);
@@ -1075,11 +1076,11 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         assertEquals(events.get(4).getSubscriptionEventType(), SubscriptionEventType.STOP_ENTITLEMENT);
         assertEquals(events.get(5).getSubscriptionEventType(), SubscriptionEventType.STOP_BILLING);
 
-        assertEquals(events.get(0).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(0).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(1).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
         assertEquals(events.get(2).getServiceName(), EntitlementOrderingBase.ENT_BILLING_SERVICE_NAME);
         assertEquals(events.get(3).getServiceName(), service);
-        assertEquals(events.get(4).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(4).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(5).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
 
         assertNull(events.get(0).getPrevPhase());
@@ -1127,7 +1128,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
 
         if (!regressionFlagForOlderVersionThan_0_17_X) {
             final BlockingState bsCreate = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                                    DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                    DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                     false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
 
             blockingStates.add(bsCreate);
@@ -1137,14 +1138,14 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         effectiveDate = effectiveDate.plusDays(5);
         clock.addDays(5);
         final BlockingState bs1 = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                           DefaultEntitlementApi.ENT_STATE_BLOCKED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_BLOCKED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
         blockingStates.add(bs1);
 
         effectiveDate = effectiveDate.plusDays(1);
         clock.addDays(1);
         final BlockingState bs2 = new DefaultBlockingState(UUID.randomUUID(), bundleId, BlockingStateType.SUBSCRIPTION_BUNDLE,
-                                                           DefaultEntitlementApi.ENT_STATE_BLOCKED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_BLOCKED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 1L);
 
         blockingStates.add(bs2);
@@ -1153,12 +1154,12 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         effectiveDate = effectiveDate.plusDays(1);
         clock.addDays(1);
         final BlockingState bs3 = new DefaultBlockingState(UUID.randomUUID(), accountId, BlockingStateType.ACCOUNT,
-                                                           DefaultEntitlementApi.ENT_STATE_CANCELLED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_CANCELLED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 2L);
 
         blockingStates.add(bs3);
         final BlockingState bs4 = new DefaultBlockingState(UUID.randomUUID(), bundleId, BlockingStateType.SUBSCRIPTION_BUNDLE,
-                                                           DefaultEntitlementApi.ENT_STATE_CANCELLED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_CANCELLED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 3L);
 
         blockingStates.add(bs4);
@@ -1182,10 +1183,10 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         assertEquals(events.get(2).getSubscriptionEventType(), SubscriptionEventType.PAUSE_ENTITLEMENT);
         assertEquals(events.get(3).getSubscriptionEventType(), SubscriptionEventType.STOP_ENTITLEMENT);
 
-        assertEquals(events.get(0).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(0).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(1).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
-        assertEquals(events.get(2).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
-        assertEquals(events.get(3).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(2).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
+        assertEquals(events.get(3).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
 
         assertNull(events.get(0).getPrevPhase());
         assertNull(events.get(1).getPrevPhase());
@@ -1227,7 +1228,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
 
         if (!regressionFlagForOlderVersionThan_0_17_X) {
             final BlockingState bsCreate = new DefaultBlockingState(UUID.randomUUID(), entitlementId, BlockingStateType.SUBSCRIPTION,
-                                                                    DefaultEntitlementApi.ENT_STATE_START, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                    DefaultEntitlementApi.ENT_STATE_START, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                     false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
 
             blockingStates.add(bsCreate);
@@ -1237,12 +1238,12 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         effectiveDate = effectiveDate.plusDays(40);
         clock.addDays(40);
         final BlockingState bs1 = new DefaultBlockingState(UUID.randomUUID(), bundleId, BlockingStateType.SUBSCRIPTION_BUNDLE,
-                                                           DefaultEntitlementApi.ENT_STATE_BLOCKED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_BLOCKED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, true, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 0L);
         blockingStates.add(bs1);
         // Same timestamp on purpose
         final BlockingState bs2 = new DefaultBlockingState(UUID.randomUUID(), bundleId, BlockingStateType.SUBSCRIPTION_BUNDLE,
-                                                           DefaultEntitlementApi.ENT_STATE_CLEAR, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_CLEAR, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 1L);
         blockingStates.add(bs2);
 
@@ -1250,7 +1251,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         effectiveDate = effectiveDate.plusDays(10);
         clock.addDays(10);
         final BlockingState bs3 = new DefaultBlockingState(UUID.randomUUID(), bundleId, BlockingStateType.SUBSCRIPTION_BUNDLE,
-                                                           DefaultEntitlementApi.ENT_STATE_BLOCKED, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_BLOCKED, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            true, true, true, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 2L);
         blockingStates.add(bs3);
 
@@ -1258,7 +1259,7 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
         effectiveDate = effectiveDate.plusDays(10);
         clock.addDays(10);
         final BlockingState bs4 = new DefaultBlockingState(UUID.randomUUID(), bundleId, BlockingStateType.SUBSCRIPTION_BUNDLE,
-                                                           DefaultEntitlementApi.ENT_STATE_CLEAR, DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                           DefaultEntitlementApi.ENT_STATE_CLEAR, KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                            false, false, false, effectiveDate, clock.getUTCNow(), clock.getUTCNow(), 3L);
         blockingStates.add(bs4);
 
@@ -1309,17 +1310,17 @@ public class TestDefaultSubscriptionBundleTimeline extends EntitlementTestSuiteN
 
         assertEquals(events.get(10).getSubscriptionEventType(), SubscriptionEventType.SERVICE_STATE_CHANGE);
 
-        assertEquals(events.get(0).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(0).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(1).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
 
-        assertEquals(events.get(2).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(2).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(3).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
-        assertEquals(events.get(4).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(4).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(5).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
 
-        assertEquals(events.get(6).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(6).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(7).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
-        assertEquals(events.get(8).getServiceName(), DefaultEntitlementService.ENTITLEMENT_SERVICE_NAME);
+        assertEquals(events.get(8).getServiceName(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         assertEquals(events.get(9).getServiceName(), EntitlementOrderingBase.BILLING_SERVICE_NAME);
 
         assertEquals(events.get(10).getServiceName(), overdueService);
diff --git a/entitlement/src/test/java/org/killbill/billing/entitlement/engine/core/TestEntitlementUtils.java b/entitlement/src/test/java/org/killbill/billing/entitlement/engine/core/TestEntitlementUtils.java
index cbbf7eb..ef9f4c0 100644
--- a/entitlement/src/test/java/org/killbill/billing/entitlement/engine/core/TestEntitlementUtils.java
+++ b/entitlement/src/test/java/org/killbill/billing/entitlement/engine/core/TestEntitlementUtils.java
@@ -45,6 +45,7 @@ import org.killbill.billing.entitlement.api.Entitlement;
 import org.killbill.billing.entitlement.api.Entitlement.EntitlementActionPolicy;
 import org.killbill.billing.entitlement.api.EntitlementApiException;
 import org.killbill.billing.payment.api.PluginProperty;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.testng.Assert;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
@@ -396,7 +397,7 @@ public class TestEntitlementUtils extends EntitlementTestSuiteWithEmbeddedDB {
             Assert.assertEquals(blockingState.getBlockedId(), addOnEntitlement.getId());
             Assert.assertEquals(blockingState.getEffectiveDate(), effectiveCancellationDateTime);
             Assert.assertEquals(blockingState.getType(), BlockingStateType.SUBSCRIPTION);
-            Assert.assertEquals(blockingState.getService(), EntitlementService.ENTITLEMENT_SERVICE_NAME);
+            Assert.assertEquals(blockingState.getService(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
             Assert.assertEquals(blockingState.getStateName(), DefaultEntitlementApi.ENT_STATE_CANCELLED);
         }
     }
@@ -424,7 +425,7 @@ public class TestEntitlementUtils extends EntitlementTestSuiteWithEmbeddedDB {
                 Assert.assertEquals(blockingState.getEffectiveDate(), effectiveCancellationDateTime);
             }
             Assert.assertEquals(blockingState.getType(), BlockingStateType.SUBSCRIPTION);
-            Assert.assertEquals(blockingState.getService(), EntitlementService.ENTITLEMENT_SERVICE_NAME);
+            Assert.assertEquals(blockingState.getService(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
             Assert.assertEquals(blockingState.getStateName(), DefaultEntitlementApi.ENT_STATE_CANCELLED);
         }
     }
@@ -442,7 +443,7 @@ public class TestEntitlementUtils extends EntitlementTestSuiteWithEmbeddedDB {
             Assert.assertEquals(blockingStatesForBaseEntitlement.get(1).getBlockedId(), baseEntitlement.getId());
             Assert.assertEquals(blockingStatesForBaseEntitlement.get(1).getEffectiveDate().toLocalDate(), effectiveBaseCancellationDate);
             Assert.assertEquals(blockingStatesForBaseEntitlement.get(1).getType(), BlockingStateType.SUBSCRIPTION);
-            Assert.assertEquals(blockingStatesForBaseEntitlement.get(1).getService(), EntitlementService.ENTITLEMENT_SERVICE_NAME);
+            Assert.assertEquals(blockingStatesForBaseEntitlement.get(1).getService(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
             Assert.assertEquals(blockingStatesForBaseEntitlement.get(1).getStateName(), DefaultEntitlementApi.ENT_STATE_CANCELLED);
         }
 
@@ -451,7 +452,7 @@ public class TestEntitlementUtils extends EntitlementTestSuiteWithEmbeddedDB {
         Assert.assertEquals(blockingStatesForAddOn.get(1).getBlockedId(), addOnEntitlement.getId());
         Assert.assertEquals(blockingStatesForAddOn.get(1).getEffectiveDate().toLocalDate(), effectiveAddOnCancellationDate);
         Assert.assertEquals(blockingStatesForAddOn.get(1).getType(), BlockingStateType.SUBSCRIPTION);
-        Assert.assertEquals(blockingStatesForAddOn.get(1).getService(), EntitlementService.ENTITLEMENT_SERVICE_NAME);
+        Assert.assertEquals(blockingStatesForAddOn.get(1).getService(), KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName());
         Assert.assertEquals(blockingStatesForAddOn.get(1).getStateName(), DefaultEntitlementApi.ENT_STATE_CANCELLED);
     }
 
diff --git a/invoice/src/main/java/org/killbill/billing/invoice/api/DefaultInvoiceService.java b/invoice/src/main/java/org/killbill/billing/invoice/api/DefaultInvoiceService.java
index a081e7b..8a56ce3 100644
--- a/invoice/src/main/java/org/killbill/billing/invoice/api/DefaultInvoiceService.java
+++ b/invoice/src/main/java/org/killbill/billing/invoice/api/DefaultInvoiceService.java
@@ -32,7 +32,6 @@ import com.google.inject.Inject;
 
 public class DefaultInvoiceService implements InvoiceService {
 
-    public static final String INVOICE_SERVICE_NAME = "invoice-service";
     private final NextBillingDateNotifier dateNotifier;
     private final InvoiceListener invoiceListener;
     private final InvoiceTagHandler tagHandler;
@@ -51,7 +50,12 @@ public class DefaultInvoiceService implements InvoiceService {
 
     @Override
     public String getName() {
-        return INVOICE_SERVICE_NAME;
+        return KILLBILL_SERVICES.INVOICE_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.INVOICE_SERVICE.getRegistrationOrdering();
     }
 
     @LifecycleHandlerType(LifecycleHandlerType.LifecycleLevel.INIT_SERVICE)
diff --git a/invoice/src/main/java/org/killbill/billing/invoice/InvoiceDispatcher.java b/invoice/src/main/java/org/killbill/billing/invoice/InvoiceDispatcher.java
index 274925f..3b30603 100644
--- a/invoice/src/main/java/org/killbill/billing/invoice/InvoiceDispatcher.java
+++ b/invoice/src/main/java/org/killbill/billing/invoice/InvoiceDispatcher.java
@@ -85,6 +85,7 @@ import org.killbill.billing.junction.BillingEvent;
 import org.killbill.billing.junction.BillingEventSet;
 import org.killbill.billing.junction.BillingInternalApi;
 import org.killbill.billing.payment.api.PluginProperty;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.subscription.api.SubscriptionBaseInternalApi;
 import org.killbill.billing.subscription.api.user.SubscriptionBaseApiException;
 import org.killbill.billing.util.UUIDs;
@@ -349,7 +350,7 @@ public class InvoiceDispatcher {
                     }
                 }
             } else /* Dry run use cases */ {
-                final NotificationQueue notificationQueue = notificationQueueService.getNotificationQueue(DefaultInvoiceService.INVOICE_SERVICE_NAME,
+                final NotificationQueue notificationQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.INVOICE_SERVICE.getServiceName(),
                                                                                                           DefaultNextBillingDateNotifier.NEXT_BILLING_DATE_NOTIFIER_QUEUE);
                 final Iterable<NotificationEventWithMetadata<NextBillingDateNotificationKey>> futureNotificationsIterable = notificationQueue.getFutureNotificationForSearchKeys(context.getAccountRecordId(), context.getTenantRecordId());
                 // Copy the results as retrieving the iterator will issue a query each time. This also makes sure the underlying JDBC connection is closed.
diff --git a/invoice/src/main/java/org/killbill/billing/invoice/InvoiceListener.java b/invoice/src/main/java/org/killbill/billing/invoice/InvoiceListener.java
index a57f621..b3626df 100644
--- a/invoice/src/main/java/org/killbill/billing/invoice/InvoiceListener.java
+++ b/invoice/src/main/java/org/killbill/billing/invoice/InvoiceListener.java
@@ -173,6 +173,12 @@ public class InvoiceListener extends RetryableService implements InvoiceListener
         return INVOICE_LISTENER_SERVICE_NAME;
     }
 
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.INVOICE_SERVICE.getRegistrationOrdering() + 1;
+    }
+
     @LifecycleHandlerType(LifecycleLevel.INIT_SERVICE)
     public void initialize() {
         super.initialize("invoice-listener", subscriberQueueHandler);
diff --git a/invoice/src/main/java/org/killbill/billing/invoice/InvoiceTagHandler.java b/invoice/src/main/java/org/killbill/billing/invoice/InvoiceTagHandler.java
index 98eb563..c2ec47b 100644
--- a/invoice/src/main/java/org/killbill/billing/invoice/InvoiceTagHandler.java
+++ b/invoice/src/main/java/org/killbill/billing/invoice/InvoiceTagHandler.java
@@ -84,6 +84,11 @@ public class InvoiceTagHandler extends RetryableService implements KillbillServi
         return INVOICE_TAG_HANDLER_SERVICE_NAME;
     }
 
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.INVOICE_SERVICE.getRegistrationOrdering() + 2;
+    }
+
     @LifecycleHandlerType(LifecycleLevel.INIT_SERVICE)
     public void initialize() {
         super.initialize("invoice-tag-handler", subscriberQueueHandler);
diff --git a/invoice/src/main/java/org/killbill/billing/invoice/notification/DefaultNextBillingDateNotifier.java b/invoice/src/main/java/org/killbill/billing/invoice/notification/DefaultNextBillingDateNotifier.java
index 79949d9..a6269c6 100644
--- a/invoice/src/main/java/org/killbill/billing/invoice/notification/DefaultNextBillingDateNotifier.java
+++ b/invoice/src/main/java/org/killbill/billing/invoice/notification/DefaultNextBillingDateNotifier.java
@@ -23,6 +23,7 @@ import java.util.UUID;
 import org.joda.time.DateTime;
 import org.killbill.billing.invoice.InvoiceListener;
 import org.killbill.billing.invoice.api.DefaultInvoiceService;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.subscription.api.SubscriptionBaseInternalApi;
 import org.killbill.billing.util.callcontext.InternalCallContextFactory;
 import org.killbill.clock.Clock;
@@ -93,7 +94,7 @@ public class DefaultNextBillingDateNotifier extends RetryableService implements 
         };
 
         final NotificationQueueHandler retryableHandler = new RetryableHandler(clock, this, notificationQueueHandler);
-        nextBillingQueue = notificationQueueService.createNotificationQueue(DefaultInvoiceService.INVOICE_SERVICE_NAME,
+        nextBillingQueue = notificationQueueService.createNotificationQueue(KILLBILL_SERVICES.INVOICE_SERVICE.getServiceName(),
                                                                             NEXT_BILLING_DATE_NOTIFIER_QUEUE,
                                                                             retryableHandler);
 
diff --git a/invoice/src/main/java/org/killbill/billing/invoice/notification/DefaultNextBillingDatePoster.java b/invoice/src/main/java/org/killbill/billing/invoice/notification/DefaultNextBillingDatePoster.java
index 92b816a..74e69b6 100644
--- a/invoice/src/main/java/org/killbill/billing/invoice/notification/DefaultNextBillingDatePoster.java
+++ b/invoice/src/main/java/org/killbill/billing/invoice/notification/DefaultNextBillingDatePoster.java
@@ -26,6 +26,7 @@ import org.joda.time.DateTime;
 import org.joda.time.LocalDate;
 import org.killbill.billing.callcontext.InternalCallContext;
 import org.killbill.billing.invoice.api.DefaultInvoiceService;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.util.entity.dao.EntitySqlDaoWrapperFactory;
 import org.killbill.notificationq.api.NotificationEventWithMetadata;
 import org.killbill.notificationq.api.NotificationQueue;
@@ -79,7 +80,7 @@ public class DefaultNextBillingDatePoster implements NextBillingDatePoster {
                                                           final InternalCallContext internalCallContext) {
         final NotificationQueue nextBillingQueue;
         try {
-            nextBillingQueue = notificationQueueService.getNotificationQueue(DefaultInvoiceService.INVOICE_SERVICE_NAME,
+            nextBillingQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.INVOICE_SERVICE.getServiceName(),
                                                                              DefaultNextBillingDateNotifier.NEXT_BILLING_DATE_NOTIFIER_QUEUE);
 
             // If we see existing notification for the same date (and isDryRunForInvoiceNotification mode), we don't insert a new notification
diff --git a/invoice/src/main/java/org/killbill/billing/invoice/notification/ParentInvoiceCommitmentNotifier.java b/invoice/src/main/java/org/killbill/billing/invoice/notification/ParentInvoiceCommitmentNotifier.java
index a59e51b..78f68ff 100644
--- a/invoice/src/main/java/org/killbill/billing/invoice/notification/ParentInvoiceCommitmentNotifier.java
+++ b/invoice/src/main/java/org/killbill/billing/invoice/notification/ParentInvoiceCommitmentNotifier.java
@@ -22,6 +22,7 @@ import java.util.UUID;
 import org.joda.time.DateTime;
 import org.killbill.billing.invoice.InvoiceListener;
 import org.killbill.billing.invoice.api.DefaultInvoiceService;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.util.callcontext.InternalCallContextFactory;
 import org.killbill.billing.util.config.definition.InvoiceConfig;
 import org.killbill.notificationq.api.NotificationEvent;
@@ -75,7 +76,7 @@ public class ParentInvoiceCommitmentNotifier implements NextBillingDateNotifier 
             }
         };
 
-        commitInvoiceQueue = notificationQueueService.createNotificationQueue(DefaultInvoiceService.INVOICE_SERVICE_NAME,
+        commitInvoiceQueue = notificationQueueService.createNotificationQueue(KILLBILL_SERVICES.INVOICE_SERVICE.getServiceName(),
                                                                               PARENT_INVOICE_COMMITMENT_NOTIFIER_QUEUE,
                                                                               notificationQueueHandler);
     }
diff --git a/invoice/src/main/java/org/killbill/billing/invoice/notification/ParentInvoiceCommitmentPoster.java b/invoice/src/main/java/org/killbill/billing/invoice/notification/ParentInvoiceCommitmentPoster.java
index b8c7d76..0a8cfb9 100644
--- a/invoice/src/main/java/org/killbill/billing/invoice/notification/ParentInvoiceCommitmentPoster.java
+++ b/invoice/src/main/java/org/killbill/billing/invoice/notification/ParentInvoiceCommitmentPoster.java
@@ -25,6 +25,7 @@ import org.joda.time.DateTime;
 import org.joda.time.LocalDate;
 import org.killbill.billing.callcontext.InternalCallContext;
 import org.killbill.billing.invoice.api.DefaultInvoiceService;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.util.entity.dao.EntitySqlDaoWrapperFactory;
 import org.killbill.notificationq.api.NotificationEventWithMetadata;
 import org.killbill.notificationq.api.NotificationQueue;
@@ -52,7 +53,7 @@ public class ParentInvoiceCommitmentPoster {
                                                            final InternalCallContext internalCallContext) {
         final NotificationQueue commitInvoiceQueue;
         try {
-            commitInvoiceQueue = notificationQueueService.getNotificationQueue(DefaultInvoiceService.INVOICE_SERVICE_NAME,
+            commitInvoiceQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.INVOICE_SERVICE.getServiceName(),
                                                                                ParentInvoiceCommitmentNotifier.PARENT_INVOICE_COMMITMENT_NOTIFIER_QUEUE);
 
             // If we see existing notification for the same date we don't insert a new notification
diff --git a/invoice/src/test/java/org/killbill/billing/invoice/notification/TestNextBillingDateNotifier.java b/invoice/src/test/java/org/killbill/billing/invoice/notification/TestNextBillingDateNotifier.java
index fe11d11..6f4608d 100644
--- a/invoice/src/test/java/org/killbill/billing/invoice/notification/TestNextBillingDateNotifier.java
+++ b/invoice/src/test/java/org/killbill/billing/invoice/notification/TestNextBillingDateNotifier.java
@@ -26,6 +26,7 @@ import org.killbill.billing.ObjectType;
 import org.killbill.billing.account.api.Account;
 import org.killbill.billing.invoice.InvoiceTestSuiteWithEmbeddedDB;
 import org.killbill.billing.invoice.api.DefaultInvoiceService;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.subscription.api.SubscriptionBase;
 import org.killbill.notificationq.api.NotificationQueue;
 import org.testng.Assert;
@@ -47,7 +48,7 @@ public class TestNextBillingDateNotifier extends InvoiceTestSuiteWithEmbeddedDB 
         final UUID subscriptionId = subscription.getId();
         final DateTime now = clock.getUTCNow();
 
-        final NotificationQueue nextBillingQueue = notificationQueueService.getNotificationQueue(DefaultInvoiceService.INVOICE_SERVICE_NAME, DefaultNextBillingDateNotifier.NEXT_BILLING_DATE_NOTIFIER_QUEUE);
+        final NotificationQueue nextBillingQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.INVOICE_SERVICE.getServiceName(), DefaultNextBillingDateNotifier.NEXT_BILLING_DATE_NOTIFIER_QUEUE);
 
         nextBillingQueue.recordFutureNotification(now, new NextBillingDateNotificationKey(null, ImmutableList.<UUID>of(subscriptionId), now, Boolean.FALSE, Boolean.FALSE), internalCallContext.getUserToken(), accountRecordId, internalCallContext.getTenantRecordId());
 
diff --git a/invoice/src/test/java/org/killbill/billing/invoice/notification/TestNextBillingDatePoster.java b/invoice/src/test/java/org/killbill/billing/invoice/notification/TestNextBillingDatePoster.java
index ad6b9bf..841567c 100644
--- a/invoice/src/test/java/org/killbill/billing/invoice/notification/TestNextBillingDatePoster.java
+++ b/invoice/src/test/java/org/killbill/billing/invoice/notification/TestNextBillingDatePoster.java
@@ -31,6 +31,7 @@ import org.killbill.billing.invoice.InvoiceDispatcher.FutureAccountNotifications
 import org.killbill.billing.invoice.InvoiceTestSuiteWithEmbeddedDB;
 import org.killbill.billing.invoice.api.DefaultInvoiceService;
 import org.killbill.billing.platform.api.KillbillConfigSource;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.subscription.api.SubscriptionBase;
 import org.killbill.notificationq.api.NotificationEventWithMetadata;
 import org.killbill.notificationq.api.NotificationQueue;
@@ -66,7 +67,7 @@ public class TestNextBillingDatePoster extends InvoiceTestSuiteWithEmbeddedDB {
         invoiceDao.setFutureAccountNotificationsForEmptyInvoice(account.getId(), futureAccountNotifications, internalCallContext);
         invoiceDao.setFutureAccountNotificationsForEmptyInvoice(account.getId(), futureAccountNotifications, internalCallContext);
 
-        final NotificationQueue nextBillingQueue = notificationQueueService.getNotificationQueue(DefaultInvoiceService.INVOICE_SERVICE_NAME,
+        final NotificationQueue nextBillingQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.INVOICE_SERVICE.getServiceName(),
                                                                                                  DefaultNextBillingDateNotifier.NEXT_BILLING_DATE_NOTIFIER_QUEUE);
         final Iterable<NotificationEventWithMetadata<NextBillingDateNotificationKey>> futureNotifications = nextBillingQueue.getFutureNotificationForSearchKeys(accountRecordId, internalCallContext.getTenantRecordId());
         final ImmutableList<NotificationEventWithMetadata<NextBillingDateNotificationKey>> futureNotificationsList = ImmutableList.copyOf(futureNotifications);
@@ -103,7 +104,7 @@ public class TestNextBillingDatePoster extends InvoiceTestSuiteWithEmbeddedDB {
         invoiceDao.setFutureAccountNotificationsForEmptyInvoice(account.getId(), futureAccountNotifications2, internalCallContext);
 
 
-        final NotificationQueue nextBillingQueue = notificationQueueService.getNotificationQueue(DefaultInvoiceService.INVOICE_SERVICE_NAME,
+        final NotificationQueue nextBillingQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.INVOICE_SERVICE.getServiceName(),
                                                                                                  DefaultNextBillingDateNotifier.NEXT_BILLING_DATE_NOTIFIER_QUEUE);
 
         final Iterable<NotificationEventWithMetadata<NextBillingDateNotificationKey>> futureNotifications = nextBillingQueue.getFutureNotificationForSearchKeys(accountRecordId, internalCallContext.getTenantRecordId());
@@ -148,7 +149,7 @@ public class TestNextBillingDatePoster extends InvoiceTestSuiteWithEmbeddedDB {
 
         invoiceDao.setFutureAccountNotificationsForEmptyInvoice(account.getId(), futureAccountNotifications2, internalCallContext);
 
-        final NotificationQueue nextBillingQueue = notificationQueueService.getNotificationQueue(DefaultInvoiceService.INVOICE_SERVICE_NAME,
+        final NotificationQueue nextBillingQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.INVOICE_SERVICE.getServiceName(),
                                                                                                  DefaultNextBillingDateNotifier.NEXT_BILLING_DATE_NOTIFIER_QUEUE);
         final Iterable<NotificationEventWithMetadata<NextBillingDateNotificationKey>> futureNotifications = nextBillingQueue.getFutureNotificationForSearchKeys(accountRecordId, internalCallContext.getTenantRecordId());
         final ImmutableList<NotificationEventWithMetadata<NextBillingDateNotificationKey>> futureNotificationsList = ImmutableList.copyOf(futureNotifications);
diff --git a/jaxrs/src/main/java/org/killbill/billing/jaxrs/DefaultJaxrsService.java b/jaxrs/src/main/java/org/killbill/billing/jaxrs/DefaultJaxrsService.java
index bbd4d7b..d29cf34 100644
--- a/jaxrs/src/main/java/org/killbill/billing/jaxrs/DefaultJaxrsService.java
+++ b/jaxrs/src/main/java/org/killbill/billing/jaxrs/DefaultJaxrsService.java
@@ -30,7 +30,6 @@ public class DefaultJaxrsService implements JaxrsService {
 
     private static final Logger log = LoggerFactory.getLogger(DefaultJaxrsService.class);
 
-    private static final String JAXRS_SERVICE_NAME = "jaxrs-service";
 
     private final JaxrsExecutors jaxrsExecutors;
 
@@ -41,7 +40,12 @@ public class DefaultJaxrsService implements JaxrsService {
 
     @Override
     public String getName() {
-        return JAXRS_SERVICE_NAME;
+        return KILLBILL_SERVICES.JAXRS_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.JAXRS_SERVICE.getRegistrationOrdering();
     }
 
     @LifecycleHandlerType(LifecycleLevel.INIT_SERVICE)
diff --git a/junction/src/test/java/org/killbill/billing/junction/plumbing/billing/TestDefaultInternalBillingApi.java b/junction/src/test/java/org/killbill/billing/junction/plumbing/billing/TestDefaultInternalBillingApi.java
index debc72c..8c7a0b5 100644
--- a/junction/src/test/java/org/killbill/billing/junction/plumbing/billing/TestDefaultInternalBillingApi.java
+++ b/junction/src/test/java/org/killbill/billing/junction/plumbing/billing/TestDefaultInternalBillingApi.java
@@ -40,6 +40,7 @@ import org.killbill.billing.junction.BillingEvent;
 import org.killbill.billing.junction.DefaultBlockingState;
 import org.killbill.billing.junction.JunctionTestSuiteWithEmbeddedDB;
 import org.killbill.billing.payment.api.PluginProperty;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.subscription.api.SubscriptionBase;
 import org.killbill.billing.subscription.api.SubscriptionBaseTransitionType;
 import org.testng.Assert;
@@ -72,7 +73,7 @@ public class TestDefaultInternalBillingApi extends JunctionTestSuiteWithEmbedded
         final DefaultBlockingState state1 = new DefaultBlockingState(account.getId(),
                                                                      BlockingStateType.ACCOUNT,
                                                                      DefaultEntitlementApi.ENT_STATE_BLOCKED,
-                                                                     EntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                     KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                      true,
                                                                      true,
                                                                      true,
@@ -82,7 +83,7 @@ public class TestDefaultInternalBillingApi extends JunctionTestSuiteWithEmbedded
         final DefaultBlockingState state2 = new DefaultBlockingState(account.getId(),
                                                                      BlockingStateType.ACCOUNT,
                                                                      DefaultEntitlementApi.ENT_STATE_CLEAR,
-                                                                     EntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                     KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                      false,
                                                                      false,
                                                                      false,
@@ -97,7 +98,7 @@ public class TestDefaultInternalBillingApi extends JunctionTestSuiteWithEmbedded
         final DefaultBlockingState state3 = new DefaultBlockingState(entitlement.getBundleId(),
                                                                      BlockingStateType.SUBSCRIPTION_BUNDLE,
                                                                      DefaultEntitlementApi.ENT_STATE_BLOCKED,
-                                                                     EntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                     KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                      true,
                                                                      true,
                                                                      true,
@@ -107,7 +108,7 @@ public class TestDefaultInternalBillingApi extends JunctionTestSuiteWithEmbedded
         final DefaultBlockingState state4 = new DefaultBlockingState(entitlement.getBundleId(),
                                                                      BlockingStateType.SUBSCRIPTION_BUNDLE,
                                                                      DefaultEntitlementApi.ENT_STATE_CLEAR,
-                                                                     EntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                     KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                      false,
                                                                      false,
                                                                      false,
@@ -132,7 +133,7 @@ public class TestDefaultInternalBillingApi extends JunctionTestSuiteWithEmbedded
         final DefaultBlockingState state6 = new DefaultBlockingState(entitlement.getBundleId(),
                                                                      BlockingStateType.SUBSCRIPTION_BUNDLE,
                                                                      DefaultEntitlementApi.ENT_STATE_CLEAR + "-something",
-                                                                     EntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                     KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                      false,
                                                                      false,
                                                                      false,
@@ -141,7 +142,7 @@ public class TestDefaultInternalBillingApi extends JunctionTestSuiteWithEmbedded
         final DefaultBlockingState state5 = new DefaultBlockingState(entitlement.getBundleId(),
                                                                      BlockingStateType.SUBSCRIPTION_BUNDLE,
                                                                      DefaultEntitlementApi.ENT_STATE_BLOCKED + "-something",
-                                                                     EntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                     KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                      true,
                                                                      true,
                                                                      true,
@@ -155,7 +156,7 @@ public class TestDefaultInternalBillingApi extends JunctionTestSuiteWithEmbedded
         final DefaultBlockingState state7 = new DefaultBlockingState(account.getId(),
                                                                      BlockingStateType.ACCOUNT,
                                                                      DefaultEntitlementApi.ENT_STATE_BLOCKED + "-something2",
-                                                                     EntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                     KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                      true,
                                                                      true,
                                                                      true,
@@ -164,7 +165,7 @@ public class TestDefaultInternalBillingApi extends JunctionTestSuiteWithEmbedded
         final DefaultBlockingState state8 = new DefaultBlockingState(account.getId(),
                                                                      BlockingStateType.ACCOUNT,
                                                                      DefaultEntitlementApi.ENT_STATE_CLEAR + "-something2",
-                                                                     EntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                     KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                      false,
                                                                      false,
                                                                      false,
@@ -221,7 +222,7 @@ public class TestDefaultInternalBillingApi extends JunctionTestSuiteWithEmbedded
         final DefaultBlockingState state1 = new DefaultBlockingState(account.getId(),
                                                                      BlockingStateType.ACCOUNT,
                                                                      DefaultEntitlementApi.ENT_STATE_BLOCKED,
-                                                                     EntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                     KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                      true,
                                                                      true,
                                                                      true,
@@ -236,7 +237,7 @@ public class TestDefaultInternalBillingApi extends JunctionTestSuiteWithEmbedded
         final DefaultBlockingState state2 = new DefaultBlockingState(account.getId(),
                                                                      BlockingStateType.ACCOUNT,
                                                                      DefaultEntitlementApi.ENT_STATE_CLEAR,
-                                                                     EntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                     KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                      false,
                                                                      false,
                                                                      false,
@@ -246,7 +247,7 @@ public class TestDefaultInternalBillingApi extends JunctionTestSuiteWithEmbedded
         final DefaultBlockingState state3 = new DefaultBlockingState(account.getId(),
                                                                      BlockingStateType.ACCOUNT,
                                                                      DefaultEntitlementApi.ENT_STATE_BLOCKED,
-                                                                     EntitlementService.ENTITLEMENT_SERVICE_NAME,
+                                                                     KILLBILL_SERVICES.ENTITLEMENT_SERVICE.getServiceName(),
                                                                      true,
                                                                      true,
                                                                      true,
diff --git a/overdue/src/main/java/org/killbill/billing/overdue/applicator/OverdueStateApplicator.java b/overdue/src/main/java/org/killbill/billing/overdue/applicator/OverdueStateApplicator.java
index cc5ecfa..85f0c9f 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/applicator/OverdueStateApplicator.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/applicator/OverdueStateApplicator.java
@@ -141,6 +141,7 @@ public class OverdueStateApplicator {
 
         cancelSubscriptionsIfRequired(effectiveDate, account, nextOverdueState, context);
 
+
         avoid_extra_credit_by_toggling_AUTO_INVOICE_OFF(account, previousOverdueState, nextOverdueState, context);
 
         // Make sure to store the new state last here: the entitlement DAO will send a BlockingTransitionInternalEvent
diff --git a/overdue/src/main/java/org/killbill/billing/overdue/service/DefaultOverdueService.java b/overdue/src/main/java/org/killbill/billing/overdue/service/DefaultOverdueService.java
index 7aa0bed..6d4459f 100644
--- a/overdue/src/main/java/org/killbill/billing/overdue/service/DefaultOverdueService.java
+++ b/overdue/src/main/java/org/killbill/billing/overdue/service/DefaultOverdueService.java
@@ -45,8 +45,6 @@ public class DefaultOverdueService implements OverdueService {
 
     private static final Logger log = LoggerFactory.getLogger(DefaultOverdueService.class);
 
-    public static final String OVERDUE_SERVICE_NAME = "overdue-service";
-
     private final OverdueProperties properties;
     private final OverdueNotifier asyncNotifier;
     private final OverdueNotifier checkNotifier;
@@ -81,7 +79,12 @@ public class DefaultOverdueService implements OverdueService {
 
     @Override
     public String getName() {
-        return OVERDUE_SERVICE_NAME;
+        return KILLBILL_SERVICES.OVERDUE_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.OVERDUE_SERVICE.getRegistrationOrdering();
     }
 
     @LifecycleHandlerType(LifecycleLevel.LOAD_CATALOG)
diff --git a/payment/src/main/java/org/killbill/billing/payment/core/janitor/Janitor.java b/payment/src/main/java/org/killbill/billing/payment/core/janitor/Janitor.java
index cb340c6..881b5ea 100644
--- a/payment/src/main/java/org/killbill/billing/payment/core/janitor/Janitor.java
+++ b/payment/src/main/java/org/killbill/billing/payment/core/janitor/Janitor.java
@@ -27,6 +27,7 @@ import org.joda.time.DateTime;
 import org.killbill.billing.events.PaymentInternalEvent;
 import org.killbill.billing.payment.core.PaymentExecutors;
 import org.killbill.billing.payment.glue.DefaultPaymentService;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.util.config.definition.PaymentConfig;
 import org.killbill.commons.locker.GlobalLocker;
 import org.killbill.notificationq.api.NotificationEvent;
@@ -74,7 +75,7 @@ public class Janitor {
     }
 
     public void initialize() throws NotificationQueueAlreadyExists {
-        janitorQueue = notificationQueueService.createNotificationQueue(DefaultPaymentService.SERVICE_NAME,
+        janitorQueue = notificationQueueService.createNotificationQueue(KILLBILL_SERVICES.PAYMENT_SERVICE.getServiceName(),
                                                                         QUEUE_NAME,
                                                                         new NotificationQueueHandler() {
                                                                             @Override
@@ -140,7 +141,7 @@ public class Janitor {
 
             if (janitorQueue != null) {
                 janitorQueue.stopQueue();
-                notificationQueueService.deleteNotificationQueue(DefaultPaymentService.SERVICE_NAME, QUEUE_NAME);
+                notificationQueueService.deleteNotificationQueue(KILLBILL_SERVICES.PAYMENT_SERVICE.getServiceName(), QUEUE_NAME);
             }
         } catch (final InterruptedException e) {
             Thread.currentThread().interrupt();
diff --git a/payment/src/main/java/org/killbill/billing/payment/core/PaymentProcessor.java b/payment/src/main/java/org/killbill/billing/payment/core/PaymentProcessor.java
index d5cf41d..0b3b7c5 100644
--- a/payment/src/main/java/org/killbill/billing/payment/core/PaymentProcessor.java
+++ b/payment/src/main/java/org/killbill/billing/payment/core/PaymentProcessor.java
@@ -54,6 +54,7 @@ import org.killbill.billing.payment.plugin.api.PaymentPluginApi;
 import org.killbill.billing.payment.plugin.api.PaymentTransactionInfoPlugin;
 import org.killbill.billing.payment.retry.DefaultRetryService;
 import org.killbill.billing.payment.retry.PaymentRetryNotificationKey;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.tag.TagInternalApi;
 import org.killbill.billing.util.callcontext.CallContext;
 import org.killbill.billing.util.callcontext.InternalCallContextFactory;
@@ -182,7 +183,7 @@ public class PaymentProcessor extends ProcessorBase {
 
     public void cancelScheduledPaymentTransaction(final UUID lastPaymentAttemptId, final InternalCallContext internalCallContext) throws PaymentApiException {
         try {
-            final NotificationQueue retryQueue = notificationQueueService.getNotificationQueue(DefaultPaymentService.SERVICE_NAME, DefaultRetryService.QUEUE_NAME);
+            final NotificationQueue retryQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.PAYMENT_SERVICE.getServiceName(), DefaultRetryService.QUEUE_NAME);
             final Iterable<NotificationEventWithMetadata<NotificationEvent>> notificationEventWithMetadatas =
                     retryQueue.getFutureNotificationForSearchKeys(internalCallContext.getAccountRecordId(), internalCallContext.getTenantRecordId());
 
diff --git a/payment/src/main/java/org/killbill/billing/payment/core/PaymentRefresher.java b/payment/src/main/java/org/killbill/billing/payment/core/PaymentRefresher.java
index 359dcfd..19e097d 100644
--- a/payment/src/main/java/org/killbill/billing/payment/core/PaymentRefresher.java
+++ b/payment/src/main/java/org/killbill/billing/payment/core/PaymentRefresher.java
@@ -55,6 +55,7 @@ import org.killbill.billing.payment.plugin.api.PaymentPluginApiException;
 import org.killbill.billing.payment.plugin.api.PaymentTransactionInfoPlugin;
 import org.killbill.billing.payment.retry.DefaultRetryService;
 import org.killbill.billing.payment.retry.PaymentRetryNotificationKey;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.tag.TagInternalApi;
 import org.killbill.billing.util.callcontext.InternalCallContextFactory;
 import org.killbill.billing.util.callcontext.TenantContext;
@@ -489,7 +490,7 @@ public class PaymentRefresher extends ProcessorBase {
 
         // Get Future Payment Attempts from Notification Queue and add them to the list
         try {
-            final NotificationQueue retryQueue = notificationQueueService.getNotificationQueue(DefaultPaymentService.SERVICE_NAME, DefaultRetryService.QUEUE_NAME);
+            final NotificationQueue retryQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.PAYMENT_SERVICE.getServiceName(), DefaultRetryService.QUEUE_NAME);
             final Iterable<NotificationEventWithMetadata<NotificationEvent>> notificationEventWithMetadatas =
                     retryQueue.getFutureNotificationForSearchKeys(internalTenantContext.getAccountRecordId(), internalTenantContext.getTenantRecordId());
 
diff --git a/payment/src/main/java/org/killbill/billing/payment/glue/DefaultPaymentService.java b/payment/src/main/java/org/killbill/billing/payment/glue/DefaultPaymentService.java
index c0180be..37337fc 100644
--- a/payment/src/main/java/org/killbill/billing/payment/glue/DefaultPaymentService.java
+++ b/payment/src/main/java/org/killbill/billing/payment/glue/DefaultPaymentService.java
@@ -41,8 +41,6 @@ public class DefaultPaymentService implements PaymentService {
 
     private static final Logger log = LoggerFactory.getLogger(DefaultPaymentService.class);
 
-    public static final String SERVICE_NAME = "payment-service";
-
     private final PaymentBusEventHandler paymentBusEventHandler;
     private final PaymentTagHandler tagHandler;
     private final PersistentBus eventBus;
@@ -73,7 +71,12 @@ public class DefaultPaymentService implements PaymentService {
 
     @Override
     public String getName() {
-        return SERVICE_NAME;
+        return KILLBILL_SERVICES.PAYMENT_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.PAYMENT_SERVICE.getRegistrationOrdering();
     }
 
     @LifecycleHandlerType(LifecycleLevel.INIT_SERVICE)
diff --git a/payment/src/main/java/org/killbill/billing/payment/retry/BaseRetryService.java b/payment/src/main/java/org/killbill/billing/payment/retry/BaseRetryService.java
index ded591c..07132e7 100644
--- a/payment/src/main/java/org/killbill/billing/payment/retry/BaseRetryService.java
+++ b/payment/src/main/java/org/killbill/billing/payment/retry/BaseRetryService.java
@@ -26,6 +26,7 @@ import org.joda.time.DateTime;
 import org.killbill.billing.ObjectType;
 import org.killbill.billing.callcontext.InternalCallContext;
 import org.killbill.billing.payment.glue.DefaultPaymentService;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.util.callcontext.CallOrigin;
 import org.killbill.billing.util.callcontext.InternalCallContextFactory;
 import org.killbill.billing.util.callcontext.UserType;
@@ -55,12 +56,12 @@ public abstract class BaseRetryService implements RetryService {
                             final InternalCallContextFactory internalCallContextFactory) {
         this.notificationQueueService = notificationQueueService;
         this.internalCallContextFactory = internalCallContextFactory;
-        this.paymentRetryService = DefaultPaymentService.SERVICE_NAME + "-" + getQueueName();
+        this.paymentRetryService = KILLBILL_SERVICES.PAYMENT_SERVICE.getServiceName() + "-" + getQueueName();
     }
 
     @Override
     public void initialize() throws NotificationQueueAlreadyExists {
-        retryQueue = notificationQueueService.createNotificationQueue(DefaultPaymentService.SERVICE_NAME,
+        retryQueue = notificationQueueService.createNotificationQueue(KILLBILL_SERVICES.PAYMENT_SERVICE.getServiceName(),
                                                                       getQueueName(),
                                                                       new NotificationQueueHandler() {
                                                                           @Override
@@ -113,7 +114,7 @@ public abstract class BaseRetryService implements RetryService {
             final InternalCallContext context = createCallContextFromPaymentId(objectType, objectId, tenantRecordId);
 
             try {
-                final NotificationQueue retryQueue = notificationQueueService.getNotificationQueue(DefaultPaymentService.SERVICE_NAME, getQueueName());
+                final NotificationQueue retryQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.PAYMENT_SERVICE.getServiceName(), getQueueName());
                 final NotificationEvent key = new PaymentRetryNotificationKey(attemptId, paymentControlPluginNames);
                 if (retryQueue != null) {
                     log.debug("Scheduling retry timeOfRetry={}, key={}", timeOfRetry, key);
@@ -124,7 +125,7 @@ public abstract class BaseRetryService implements RetryService {
                     }
                 }
             } catch (final NoSuchNotificationQueue e) {
-                log.error("Failed to retrieve notification queue='{}', service='{}'", getQueueName(), DefaultPaymentService.SERVICE_NAME);
+                log.error("Failed to retrieve notification queue='{}', service='{}'", getQueueName(), KILLBILL_SERVICES.PAYMENT_SERVICE.getServiceName());
                 return false;
             } catch (final IOException e) {
                 log.error("Failed to serialize notificationQueue event for objectId='{}'", objectId);
@@ -134,7 +135,7 @@ public abstract class BaseRetryService implements RetryService {
         }
 
         protected InternalCallContext createCallContextFromPaymentId(final ObjectType objectType, final UUID objectId, final Long tenantRecordId) {
-            final String paymentRetryService = DefaultPaymentService.SERVICE_NAME + "-" + getQueueName();
+            final String paymentRetryService = KILLBILL_SERVICES.PAYMENT_SERVICE.getServiceName() + "-" + getQueueName();
             return internalCallContextFactory.createInternalCallContext(objectId, objectType, paymentRetryService, CallOrigin.INTERNAL, UserType.SYSTEM, null, tenantRecordId);
         }
 
diff --git a/payment/src/test/java/org/killbill/billing/payment/TestJanitor.java b/payment/src/test/java/org/killbill/billing/payment/TestJanitor.java
index 7a9a1e1..bf09d24 100644
--- a/payment/src/test/java/org/killbill/billing/payment/TestJanitor.java
+++ b/payment/src/test/java/org/killbill/billing/payment/TestJanitor.java
@@ -54,6 +54,7 @@ import org.killbill.billing.payment.plugin.api.PaymentTransactionInfoPlugin;
 import org.killbill.billing.payment.provider.DefaultNoOpPaymentInfoPlugin;
 import org.killbill.billing.payment.provider.MockPaymentProviderPlugin;
 import org.killbill.billing.platform.api.KillbillConfigSource;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.util.api.AuditLevel;
 import org.killbill.billing.util.audit.AuditLogWithHistory;
 import org.killbill.billing.util.callcontext.InternalCallContextFactory;
@@ -554,7 +555,7 @@ public class TestJanitor extends PaymentTestSuiteWithEmbeddedDB {
                 @Override
                 public Boolean call() throws Exception {
                     boolean completed = true;
-                    final Iterator<NotificationEventWithMetadata<NotificationEvent>> iterator = notificationQueueService.getNotificationQueue(DefaultPaymentService.SERVICE_NAME, Janitor.QUEUE_NAME).getFutureOrInProcessingNotificationForSearchKeys(internalCallContext.getAccountRecordId(), internalCallContext.getTenantRecordId()).iterator();
+                    final Iterator<NotificationEventWithMetadata<NotificationEvent>> iterator = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.PAYMENT_SERVICE.getServiceName(), Janitor.QUEUE_NAME).getFutureOrInProcessingNotificationForSearchKeys(internalCallContext.getAccountRecordId(), internalCallContext.getTenantRecordId()).iterator();
                     try {
                         while (iterator.hasNext()) {
                             final NotificationEventWithMetadata<NotificationEvent> notificationEvent = iterator.next();
@@ -578,7 +579,7 @@ public class TestJanitor extends PaymentTestSuiteWithEmbeddedDB {
 
     private int getPendingNotificationCnt(final InternalCallContext internalCallContext) {
         try {
-            return Iterables.size(notificationQueueService.getNotificationQueue(DefaultPaymentService.SERVICE_NAME, Janitor.QUEUE_NAME).getFutureOrInProcessingNotificationForSearchKeys(internalCallContext.getAccountRecordId(), internalCallContext.getTenantRecordId()));
+            return Iterables.size(notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.PAYMENT_SERVICE.getServiceName(), Janitor.QUEUE_NAME).getFutureOrInProcessingNotificationForSearchKeys(internalCallContext.getAccountRecordId(), internalCallContext.getTenantRecordId()));
         } catch (final Exception e) {
             fail("Test failed ", e);
         }

pom.xml 2(+1 -1)

diff --git a/pom.xml b/pom.xml
index 9824cb1..4490e4a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -21,7 +21,7 @@
     <parent>
         <artifactId>killbill-oss-parent</artifactId>
         <groupId>org.kill-bill.billing</groupId>
-        <version>0.142.3</version>
+        <version>0.142.4</version>
     </parent>
     <artifactId>killbill</artifactId>
     <version>0.20.2-SNAPSHOT</version>
diff --git a/profiles/killbill/src/main/java/org/killbill/billing/server/DefaultServerService.java b/profiles/killbill/src/main/java/org/killbill/billing/server/DefaultServerService.java
index cad84c9..503d151 100644
--- a/profiles/killbill/src/main/java/org/killbill/billing/server/DefaultServerService.java
+++ b/profiles/killbill/src/main/java/org/killbill/billing/server/DefaultServerService.java
@@ -37,8 +37,6 @@ public class DefaultServerService implements ServerService {
 
     private static final Logger log = LoggerFactory.getLogger(DefaultServerService.class);
 
-    public static final String SERVER_SERVICE = "server-service";
-
     private final PersistentBus bus;
     private final PushNotificationListener pushNotificationListener;
     private final PushNotificationRetryService pushNotificationRetryService;
@@ -54,7 +52,12 @@ public class DefaultServerService implements ServerService {
 
     @Override
     public String getName() {
-        return SERVER_SERVICE;
+        return KILLBILL_SERVICES.SERVER_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.SERVER_SERVICE.getRegistrationOrdering();
     }
 
     @LifecycleHandlerType(LifecycleLevel.INIT_SERVICE)
diff --git a/profiles/killbill/src/main/java/org/killbill/billing/server/notifications/PushNotificationListener.java b/profiles/killbill/src/main/java/org/killbill/billing/server/notifications/PushNotificationListener.java
index 4ec1caf..f089441 100644
--- a/profiles/killbill/src/main/java/org/killbill/billing/server/notifications/PushNotificationListener.java
+++ b/profiles/killbill/src/main/java/org/killbill/billing/server/notifications/PushNotificationListener.java
@@ -31,6 +31,7 @@ import org.killbill.billing.ObjectType;
 import org.killbill.billing.callcontext.InternalTenantContext;
 import org.killbill.billing.jaxrs.json.NotificationJson;
 import org.killbill.billing.notification.plugin.api.ExtBusEvent;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.server.DefaultServerService;
 import org.killbill.billing.tenant.api.TenantApiException;
 import org.killbill.billing.tenant.api.TenantKV.TenantKey;
@@ -191,7 +192,7 @@ public class PushNotificationListener {
         final Long accountRecordId = internalCallContextFactory.getRecordIdFromObject(key.getAccountId(), ObjectType.ACCOUNT, tenantContext);
         final Long tenantRecordId = internalCallContextFactory.getRecordIdFromObject(key.getTenantId(), ObjectType.TENANT, tenantContext);
         try {
-            final NotificationQueue notificationQueue = notificationQueueService.getNotificationQueue(DefaultServerService.SERVER_SERVICE, PushNotificationRetryService.QUEUE_NAME);
+            final NotificationQueue notificationQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.SERVER_SERVICE.getServiceName(), PushNotificationRetryService.QUEUE_NAME);
             notificationQueue.recordFutureNotification(nextNotificationTime, key, null, MoreObjects.firstNonNull(accountRecordId, new Long(0)), tenantRecordId);
         } catch (final NoSuchNotificationQueue noSuchNotificationQueue) {
             log.error("Failed to push notification url='{}', tenantId='{}'", key.getUrl(), key.getTenantId(), noSuchNotificationQueue);
diff --git a/profiles/killbill/src/main/java/org/killbill/billing/server/notifications/PushNotificationRetryService.java b/profiles/killbill/src/main/java/org/killbill/billing/server/notifications/PushNotificationRetryService.java
index 5284a21..e735a52 100644
--- a/profiles/killbill/src/main/java/org/killbill/billing/server/notifications/PushNotificationRetryService.java
+++ b/profiles/killbill/src/main/java/org/killbill/billing/server/notifications/PushNotificationRetryService.java
@@ -20,6 +20,7 @@ package org.killbill.billing.server.notifications;
 import java.util.UUID;
 
 import org.joda.time.DateTime;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.server.DefaultServerService;
 import org.killbill.billing.util.callcontext.InternalCallContextFactory;
 import org.killbill.notificationq.api.NotificationEvent;
@@ -38,7 +39,7 @@ public class PushNotificationRetryService {
 
     private static final Logger log = LoggerFactory.getLogger(PushNotificationRetryService.class);
     public static final String QUEUE_NAME = "push-notification-queue";
-    private static final String retryService = DefaultServerService.SERVER_SERVICE + "-" + QUEUE_NAME;
+    private static final String retryService = KILLBILL_SERVICES.SERVER_SERVICE.getServiceName() + "-" + QUEUE_NAME;
 
     private final NotificationQueueService notificationQueueService;
     private final InternalCallContextFactory internalCallContextFactory;
@@ -56,7 +57,7 @@ public class PushNotificationRetryService {
     }
 
     public void initialize() throws NotificationQueueAlreadyExists {
-        retryQueue = notificationQueueService.createNotificationQueue(DefaultServerService.SERVER_SERVICE,
+        retryQueue = notificationQueueService.createNotificationQueue(KILLBILL_SERVICES.SERVER_SERVICE.getServiceName(),
                                                                       QUEUE_NAME,
                                                                       new NotificationQueueHandler() {
                                                                           @Override
diff --git a/profiles/killbill/src/test/java/org/killbill/billing/jaxrs/TestPushNotification.java b/profiles/killbill/src/test/java/org/killbill/billing/jaxrs/TestPushNotification.java
index d7d1d89..664f695 100644
--- a/profiles/killbill/src/test/java/org/killbill/billing/jaxrs/TestPushNotification.java
+++ b/profiles/killbill/src/test/java/org/killbill/billing/jaxrs/TestPushNotification.java
@@ -27,6 +27,7 @@ import org.awaitility.Awaitility;
 import org.joda.time.DateTime;
 import org.killbill.CreatorName;
 import org.killbill.billing.notification.plugin.api.ExtBusEventType;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.server.DefaultServerService;
 import org.killbill.billing.server.notifications.PushNotificationKey;
 import org.killbill.notificationq.NotificationQueueDispatcher;
@@ -64,11 +65,11 @@ public class TestPushNotification extends TestJaxrsBase {
                                                                                                   internalCallContext.getTenantRecordId(),
                                                                                                   UUID.randomUUID(),
                                                                                                   clock.getUTCNow(),
-                                                                                                  DefaultServerService.SERVER_SERVICE + ":testVerify726Backport");
+                                                                                                  KILLBILL_SERVICES.SERVER_SERVICE.getServiceName() + ":testVerify726Backport");
 
         final AtomicReference<PushNotificationKey> notification = new AtomicReference<PushNotificationKey>();
         // Need to create a custom queue to extract the deserialized event
-        final NotificationQueue notificationQueue = notificationQueueService.createNotificationQueue(DefaultServerService.SERVER_SERVICE,
+        final NotificationQueue notificationQueue = notificationQueueService.createNotificationQueue(KILLBILL_SERVICES.SERVER_SERVICE.getServiceName(),
                                                                                                      "testVerify726Backport",
                                                                                                      new NotificationQueueHandler() {
                                                                                                          @Override
diff --git a/subscription/src/main/java/org/killbill/billing/subscription/engine/core/DefaultSubscriptionBaseService.java b/subscription/src/main/java/org/killbill/billing/subscription/engine/core/DefaultSubscriptionBaseService.java
index 2d80b2e..ecac513 100644
--- a/subscription/src/main/java/org/killbill/billing/subscription/engine/core/DefaultSubscriptionBaseService.java
+++ b/subscription/src/main/java/org/killbill/billing/subscription/engine/core/DefaultSubscriptionBaseService.java
@@ -63,7 +63,6 @@ import com.google.inject.Inject;
 public class DefaultSubscriptionBaseService implements EventListener, SubscriptionBaseService {
 
     public static final String NOTIFICATION_QUEUE_NAME = "subscription-events";
-    public static final String SUBSCRIPTION_SERVICE_NAME = "subscription-service";
 
     private static final Logger log = LoggerFactory.getLogger(DefaultSubscriptionBaseService.class);
 
@@ -99,7 +98,12 @@ public class DefaultSubscriptionBaseService implements EventListener, Subscripti
 
     @Override
     public String getName() {
-        return SUBSCRIPTION_SERVICE_NAME;
+        return KILLBILL_SERVICES.SUBSCRIPTION_BASE_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.SUBSCRIPTION_BASE_SERVICE.getRegistrationOrdering();
     }
 
     @LifecycleHandlerType(LifecycleLevel.INIT_SERVICE)
@@ -126,7 +130,7 @@ public class DefaultSubscriptionBaseService implements EventListener, Subscripti
                 }
             };
 
-            subscriptionEventQueue = notificationQueueService.createNotificationQueue(SUBSCRIPTION_SERVICE_NAME,
+            subscriptionEventQueue = notificationQueueService.createNotificationQueue(KILLBILL_SERVICES.SUBSCRIPTION_BASE_SERVICE.getServiceName(),
                                                                                       NOTIFICATION_QUEUE_NAME,
                                                                                       queueHandler);
         } catch (final NotificationQueueAlreadyExists e) {
diff --git a/subscription/src/main/java/org/killbill/billing/subscription/engine/dao/DefaultSubscriptionDao.java b/subscription/src/main/java/org/killbill/billing/subscription/engine/dao/DefaultSubscriptionDao.java
index 8a2ae63..d38160d 100644
--- a/subscription/src/main/java/org/killbill/billing/subscription/engine/dao/DefaultSubscriptionDao.java
+++ b/subscription/src/main/java/org/killbill/billing/subscription/engine/dao/DefaultSubscriptionDao.java
@@ -48,6 +48,7 @@ import org.killbill.billing.catalog.api.ProductCategory;
 import org.killbill.billing.entitlement.api.Entitlement.EntitlementState;
 import org.killbill.billing.entitlement.api.SubscriptionApiException;
 import org.killbill.billing.entity.EntityPersistenceException;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.subscription.api.SubscriptionBase;
 import org.killbill.billing.subscription.api.SubscriptionBaseTransitionType;
 import org.killbill.billing.subscription.api.SubscriptionBaseWithAddOns;
@@ -1134,7 +1135,7 @@ public class DefaultSubscriptionDao extends EntityDaoBase<SubscriptionBundleMode
     private void recordFutureNotificationFromTransaction(final EntitySqlDaoWrapperFactory entitySqlDaoWrapperFactory, final DateTime effectiveDate,
                                                          final NotificationEvent notificationKey, final InternalCallContext context) {
         try {
-            final NotificationQueue subscriptionEventQueue = notificationQueueService.getNotificationQueue(DefaultSubscriptionBaseService.SUBSCRIPTION_SERVICE_NAME,
+            final NotificationQueue subscriptionEventQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.SUBSCRIPTION_BASE_SERVICE.getServiceName(),
                                                                                                            DefaultSubscriptionBaseService.NOTIFICATION_QUEUE_NAME);
             subscriptionEventQueue.recordFutureNotificationFromTransaction(entitySqlDaoWrapperFactory.getHandle().getConnection(), effectiveDate, notificationKey, context.getUserToken(), context.getAccountRecordId(), context.getTenantRecordId());
         } catch (final NoSuchNotificationQueue e) {
diff --git a/subscription/src/test/java/org/killbill/billing/subscription/engine/dao/MockSubscriptionDaoMemory.java b/subscription/src/test/java/org/killbill/billing/subscription/engine/dao/MockSubscriptionDaoMemory.java
index 36b05f0..f4a3a8b 100644
--- a/subscription/src/test/java/org/killbill/billing/subscription/engine/dao/MockSubscriptionDaoMemory.java
+++ b/subscription/src/test/java/org/killbill/billing/subscription/engine/dao/MockSubscriptionDaoMemory.java
@@ -38,6 +38,7 @@ import org.killbill.billing.catalog.api.ProductCategory;
 import org.killbill.billing.catalog.api.TimeUnit;
 import org.killbill.billing.dao.MockNonEntityDao;
 import org.killbill.billing.entitlement.api.SubscriptionApiException;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.subscription.api.SubscriptionBase;
 import org.killbill.billing.subscription.api.SubscriptionBaseWithAddOns;
 import org.killbill.billing.subscription.api.transfer.BundleTransferData;
@@ -467,7 +468,7 @@ public class MockSubscriptionDaoMemory extends MockEntityDaoBase<SubscriptionBun
     private void recordFutureNotificationFromTransaction(final EntitySqlDaoWrapperFactory transactionalDao, final DateTime effectiveDate,
                                                          final NotificationEvent notificationKey, final InternalCallContext context) {
         try {
-            final NotificationQueue subscriptionEventQueue = notificationQueueService.getNotificationQueue(DefaultSubscriptionBaseService.SUBSCRIPTION_SERVICE_NAME,
+            final NotificationQueue subscriptionEventQueue = notificationQueueService.getNotificationQueue(KILLBILL_SERVICES.SUBSCRIPTION_BASE_SERVICE.getServiceName(),
                                                                                                            DefaultSubscriptionBaseService.NOTIFICATION_QUEUE_NAME);
             subscriptionEventQueue.recordFutureNotificationFromTransaction(null, effectiveDate, notificationKey, context.getUserToken(), context.getAccountRecordId(), context.getTenantRecordId());
         } catch (final NoSuchNotificationQueue e) {
diff --git a/tenant/src/main/java/org/killbill/billing/tenant/api/DefaultTenantService.java b/tenant/src/main/java/org/killbill/billing/tenant/api/DefaultTenantService.java
index 58b732d..d01bdf9 100644
--- a/tenant/src/main/java/org/killbill/billing/tenant/api/DefaultTenantService.java
+++ b/tenant/src/main/java/org/killbill/billing/tenant/api/DefaultTenantService.java
@@ -25,8 +25,6 @@ import org.killbill.billing.tenant.api.user.DefaultTenantUserApi;
 
 public class DefaultTenantService implements TenantService {
 
-    private static final String TENANT_SERVICE_NAME = "tenant-service";
-
     private final TenantCacheInvalidation tenantCacheInvalidation;
     private final TenantCacheInvalidationCallback tenantCacheInvalidationCallback;
 
@@ -38,7 +36,12 @@ public class DefaultTenantService implements TenantService {
 
     @Override
     public String getName() {
-        return TENANT_SERVICE_NAME;
+        return KILLBILL_SERVICES.TENANT_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.TENANT_SERVICE.getRegistrationOrdering();
     }
 
     @LifecycleHandlerType(LifecycleLevel.INIT_SERVICE)
diff --git a/util/src/main/java/org/killbill/billing/util/broadcast/DefaultBroadcastService.java b/util/src/main/java/org/killbill/billing/util/broadcast/DefaultBroadcastService.java
index d3c48a0..e22e5b2 100644
--- a/util/src/main/java/org/killbill/billing/util/broadcast/DefaultBroadcastService.java
+++ b/util/src/main/java/org/killbill/billing/util/broadcast/DefaultBroadcastService.java
@@ -42,7 +42,6 @@ public class DefaultBroadcastService implements BroadcastService {
 
     private static final Logger logger = LoggerFactory.getLogger(DefaultBroadcastService.class);
 
-    public static final String BROADCAST_SERVICE_NAME = "broadcast-service";
 
     private final BroadcastConfig broadcastConfig;
     private final BroadcastDao broadcastDao;
@@ -62,7 +61,12 @@ public class DefaultBroadcastService implements BroadcastService {
 
     @Override
     public String getName() {
-        return BROADCAST_SERVICE_NAME;
+        return KILLBILL_SERVICES.BROADCAST_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.BROADCAST_SERVICE.getRegistrationOrdering();
     }
 
     @LifecycleHandlerType(LifecycleLevel.INIT_SERVICE)
diff --git a/util/src/main/java/org/killbill/billing/util/config/DefaultConfigKillbillService.java b/util/src/main/java/org/killbill/billing/util/config/DefaultConfigKillbillService.java
index d0ce0c0..cf83f68 100644
--- a/util/src/main/java/org/killbill/billing/util/config/DefaultConfigKillbillService.java
+++ b/util/src/main/java/org/killbill/billing/util/config/DefaultConfigKillbillService.java
@@ -34,8 +34,6 @@ public class DefaultConfigKillbillService implements ConfigKillbillService {
 
     private static final Logger logger = LoggerFactory.getLogger(DefaultConfigKillbillService.class);
 
-    public static final String CONFIG_SERVICE_NAME = "config-service";
-
     private final TenantInternalApi tenantInternalApi;
     private final CacheInvalidationCallback cacheInvalidationCallback;
 
@@ -47,7 +45,12 @@ public class DefaultConfigKillbillService implements ConfigKillbillService {
 
     @Override
     public String getName() {
-        return CONFIG_SERVICE_NAME;
+        return KILLBILL_SERVICES.CONFIG_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.CONFIG_SERVICE.getRegistrationOrdering();
     }
 
     @LifecycleHandlerType(LifecycleLevel.INIT_SERVICE)
diff --git a/util/src/main/java/org/killbill/billing/util/nodes/DefaultKillbillNodesApi.java b/util/src/main/java/org/killbill/billing/util/nodes/DefaultKillbillNodesApi.java
index 8503a8c..788f5bf 100644
--- a/util/src/main/java/org/killbill/billing/util/nodes/DefaultKillbillNodesApi.java
+++ b/util/src/main/java/org/killbill/billing/util/nodes/DefaultKillbillNodesApi.java
@@ -26,6 +26,7 @@ import org.killbill.CreatorName;
 import org.killbill.billing.broadcast.BroadcastApi;
 import org.killbill.billing.osgi.api.PluginInfo;
 import org.killbill.billing.osgi.api.PluginsInfoApi;
+import org.killbill.billing.platform.api.KillbillService.KILLBILL_SERVICES;
 import org.killbill.billing.util.nodes.dao.NodeInfoDao;
 import org.killbill.billing.util.nodes.dao.NodeInfoModelDao;
 import org.killbill.billing.util.nodes.json.NodeInfoModelJson;
@@ -94,7 +95,7 @@ public class DefaultKillbillNodesApi implements KillbillNodesApi {
         final String event;
         try {
             event = mapper.serializeNodeCommand(nodeCommand.getNodeCommandMetadata());
-            broadcastApi.broadcast(DefaultKillbillNodesService.NODES_SERVICE_NAME, nodeCommand.getNodeCommandType(), event, clock.getUTCNow(), "unset", localNodeOnly);
+            broadcastApi.broadcast(KILLBILL_SERVICES.BROADCAST_SERVICE.getServiceName(), nodeCommand.getNodeCommandType(), event, clock.getUTCNow(), "unset", localNodeOnly);
 
         } catch (JsonProcessingException e) {
             throw new RuntimeException(e);
diff --git a/util/src/main/java/org/killbill/billing/util/nodes/DefaultKillbillNodesService.java b/util/src/main/java/org/killbill/billing/util/nodes/DefaultKillbillNodesService.java
index 6236bb3..f1f0e66 100644
--- a/util/src/main/java/org/killbill/billing/util/nodes/DefaultKillbillNodesService.java
+++ b/util/src/main/java/org/killbill/billing/util/nodes/DefaultKillbillNodesService.java
@@ -44,7 +44,6 @@ public class DefaultKillbillNodesService implements KillbillNodesService {
 
     private static final Logger logger = LoggerFactory.getLogger(DefaultKillbillNodesService.class);
 
-    public static final String NODES_SERVICE_NAME = "nodes-service";
 
     private final NodeInfoDao nodeInfoDao;
     private final PluginsInfoApi pluginInfoApi;
@@ -63,7 +62,12 @@ public class DefaultKillbillNodesService implements KillbillNodesService {
 
     @Override
     public String getName() {
-        return NODES_SERVICE_NAME;
+        return KILLBILL_SERVICES.NODES_SERVICE.getServiceName() ;
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.NODES_SERVICE.getRegistrationOrdering();
     }
 
     @LifecycleHandlerType(LifecycleLevel.BOOT)
diff --git a/util/src/main/java/org/killbill/billing/util/security/api/DefaultSecurityService.java b/util/src/main/java/org/killbill/billing/util/security/api/DefaultSecurityService.java
index 5227be1..f077c1e 100644
--- a/util/src/main/java/org/killbill/billing/util/security/api/DefaultSecurityService.java
+++ b/util/src/main/java/org/killbill/billing/util/security/api/DefaultSecurityService.java
@@ -27,7 +27,6 @@ import org.killbill.billing.platform.api.LifecycleHandlerType.LifecycleLevel;
 
 public class DefaultSecurityService implements SecurityService {
 
-    public static final String SECURITY_SERVICE_NAME = "security-service";
 
     private final SecurityManager securityManager;
 
@@ -38,7 +37,12 @@ public class DefaultSecurityService implements SecurityService {
 
     @Override
     public String getName() {
-        return SECURITY_SERVICE_NAME;
+        return KILLBILL_SERVICES.SECURITY_SERVICE.getServiceName();
+    }
+
+    @Override
+    public int getRegistrationOrdering() {
+        return KILLBILL_SERVICES.SECURITY_SERVICE.getRegistrationOrdering();
     }
 
     @LifecycleHandlerType(LifecycleHandlerType.LifecycleLevel.INIT_SERVICE)