diff --git a/src/main/resources/clds/camel/rest/clamp-api-v2.xml b/src/main/resources/clds/camel/rest/clamp-api-v2.xml
index 7e0c891..692e342 100644
--- a/src/main/resources/clds/camel/rest/clamp-api-v2.xml
+++ b/src/main/resources/clds/camel/rest/clamp-api-v2.xml
@@ -216,7 +216,7 @@
 							<simple> ${exchangeProperty[policyStatus]} == 'SUBMITTED' and
 								${exchangeProperty[dcaeStatus]} == 'NOT_DEPLOYED'
 							</simple>
-							<to uri="direct:deploy-closedloop" />
+							<to uri="direct:deploy-loop" />
 						</when>
 						<otherwise>
 							<log
@@ -268,7 +268,7 @@
 						<when>
 							<simple> ${exchangeProperty[dcaeStatus]} == 'DEPLOYED'
 							</simple>
-							<to uri="direct:undeploy-closedloop" />
+							<to uri="direct:undeploy-loop" />
 						</when>
 						<otherwise>
 							<log
diff --git a/src/main/resources/clds/camel/routes/flexible-flow.xml b/src/main/resources/clds/camel/routes/flexible-flow.xml
index 920e1e5..790a167 100644
--- a/src/main/resources/clds/camel/routes/flexible-flow.xml
+++ b/src/main/resources/clds/camel/routes/flexible-flow.xml
@@ -489,8 +489,8 @@
 			</doFinally>
 		</doTry>
 	</route>
-	<route id="deploy-closedloop">
-		<from uri="direct:deploy-closedloop" />
+	<route id="deploy-loop">
+		<from uri="direct:deploy-loop" />
 		<doTry>
 			<log
 				loggingLevel="INFO"
@@ -535,19 +535,19 @@
 				<to
 					uri="bean:org.onap.clamp.flow.log.FlowLogOperation?method=invokeReturnLog()" />
 				<setProperty propertyName="logMessage">
-					<simple>Deploy closed loop status</simple>
+					<simple>Deploy closed loop status (id:${exchangeProperty[deploymentId]})</simple>
 				</setProperty>
 				<to uri="direct:dump-loop-log-http-response" />
 			</doFinally>
 		</doTry>
 	</route>
 
-	<route id="undeploy-closedloop">
-		<from uri="direct:undeploy-closedloop" />
+	<route id="undeploy-loop">
+		<from uri="direct:undeploy-loop" />
 		<doTry>
 			<log
 				loggingLevel="INFO"
-				message="UNdeploy the closed loop: ${exchangeProperty[loopObject].getName()} : ${exchangeProperty[loopObject].getDcaeDeploymentId()}" />
+				message="Undeploy the closed loop: ${exchangeProperty[loopObject].getName()} : ${exchangeProperty[loopObject].getDcaeDeploymentId()}" />
 			<to
 				uri="bean:org.onap.clamp.flow.log.FlowLogOperation?method=invokeLog('DCAE', 'Undeploy closed loop')" />
 
