diff --git a/kubernetes/aai/charts/aai-graphadmin/resources/config/application.properties b/kubernetes/aai/charts/aai-graphadmin/resources/config/application.properties
index 81a9c7b..c23c5fa 100644
--- a/kubernetes/aai/charts/aai-graphadmin/resources/config/application.properties
+++ b/kubernetes/aai/charts/aai-graphadmin/resources/config/application.properties
@@ -45,9 +45,9 @@
 
 server.port=8449
 server.ssl.enabled-protocols=TLSv1.1,TLSv1.2
-server.ssl.key-store=${server.local.startpath}etc/auth/{{ .Values.global.config.keystore.filename }}
+server.ssl.key-store=${server.local.startpath}/etc/auth/{{ .Values.global.config.keystore.filename }}
 server.ssl.key-store-password=password({{ .Values.global.config.keystore.passwd }})
-server.ssl.trust-store=${server.local.startpath}etc/auth/{{ .Values.global.config.truststore.filename }}
+server.ssl.trust-store=${server.local.startpath}/etc/auth/{{ .Values.global.config.truststore.filename }}
 server.ssl.trust-store-password=password({{ .Values.global.config.truststore.passwd }})
 server.ssl.client-auth=want
 server.ssl.key-store-type=JKS
@@ -86,3 +86,14 @@
 # Specifies the version that the application should default to
 schema.version.api.default={{ .Values.global.config.schema.version.api.default }}
 
+schema.translator.list={{ .Values.global.config.schema.translator.list }}
+schema.service.base.url=https://aai-schema-service.{{ include "common.namespace" . }}:8452/aai/schema-service/v1/
+schema.service.nodes.endpoint=nodes?version=
+schema.service.edges.endpoint=edgerules?version=
+schema.service.versions.endpoint=versions
+schema.service.client={{ .Values.global.config.schema.service.client }}
+
+schema.service.ssl.key-store=${server.local.startpath}/etc/auth/{{ .Values.global.config.keystore.filename }}
+schema.service.ssl.trust-store=${server.local.startpath}/etc/auth/{{ .Values.global.config.truststore.filename }}
+schema.service.ssl.key-store-password=password({{ .Values.global.config.keystore.passwd }})
+schema.service.ssl.trust-store-password=password({{ .Values.global.config.truststore.passwd }})
diff --git a/kubernetes/aai/charts/aai-graphadmin/resources/config/logback.xml b/kubernetes/aai/charts/aai-graphadmin/resources/config/logback.xml
index 787fc64..e5e6ab5 100644
--- a/kubernetes/aai/charts/aai-graphadmin/resources/config/logback.xml
+++ b/kubernetes/aai/charts/aai-graphadmin/resources/config/logback.xml
@@ -3,7 +3,7 @@
     ============LICENSE_START=======================================================
     org.onap.aai
     ================================================================================
-    Copyright 2018 AT&T Intellectual Property. All rights reserved.
+    Copyright 2019 AT&T Intellectual Property. All rights reserved.
     ================================================================================
     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
@@ -20,689 +20,595 @@
 
 -->
 <configuration scan="true" scanPeriod="60 seconds" debug="false">
-	<statusListener class="ch.qos.logback.core.status.NopStatusListener" />
+  <statusListener class="ch.qos.logback.core.status.NopStatusListener" />
 
-	<property resource="application.properties" />
+  <property resource="application.properties" />
 
-	<property name="namespace" value="graph-admin"/>
+  <property name="namespace" value="graph-admin"/>
 
-	<property name="AJSC_HOME" value="${AJSC_HOME:-.}" />
-	
-	<property name="logDirectory" value="${AJSC_HOME}/logs" />
-	<property name="eelfLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%ecompStatusCode|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
-	<property name="eelfAuditLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%ecompStatusCode|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n|\r\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
-	<property name="eelfMetricLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompStatusCode|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{targetVirtualEntity}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
-	<!--  <property name="eelfErrorLogPattern" value="%ecompStartTime|%X{requestId}|%-10t|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompErrorCategory|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n|\r\n', '^'}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/> -->
-	<property name="eelfErrorLogPattern" value="%ecompStartTime|%X{requestId}|%-10t|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompErrorCategory|%ecompResponseCode|%ecompResponseDescription|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <property name="AJSC_HOME" value="${AJSC_HOME:-.}" />
+  
+  <property name="logDirectory" value="${AJSC_HOME}/logs" />
+  <property name="eelfLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%ecompStatusCode|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <property name="eelfAuditLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%ecompStatusCode|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n|\r\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <property name="eelfMetricLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompStatusCode|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{targetVirtualEntity}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <!--  <property name="eelfErrorLogPattern" value="%ecompStartTime|%X{requestId}|%-10t|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompErrorCategory|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n|\r\n', '^'}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/> -->
+  <property name="eelfErrorLogPattern" value="%ecompStartTime|%X{requestId}|%-10t|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompErrorCategory|%ecompResponseCode|%ecompResponseDescription|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
     <property name="eelfTransLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%ecompStatusCode|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{partnerName}:%m%n"/>
-	
+  
     <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
     <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
     <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
-	<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-		<encoder>
-			<pattern>
-				%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}
-			</pattern>
-		</encoder>
-	</appender>
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <encoder>
+      <pattern>
+        %clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}
+      </pattern>
+    </encoder>
+  </appender>
 
-	<appender name="SANE" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<file>${logDirectory}/rest/sane.log</file>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/rest/sane.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder>
-			<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{1024} - %msg%n
-			</pattern>
-		</encoder>
-	</appender>
+  <appender name="SANE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <file>${logDirectory}/rest/sane.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/sane.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{1024} - %msg%n
+      </pattern>
+    </encoder>
+  </appender>
 
-	<appender name="asyncSANE" class="ch.qos.logback.classic.AsyncAppender">
-		<queueSize>1000</queueSize>
-		<includeCallerData>true</includeCallerData>
-		<appender-ref ref="SANE" />
-	</appender>
+  <appender name="asyncSANE" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="SANE" />
+  </appender>
 
-	<appender name="METRIC"
-		class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>INFO</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<file>${logDirectory}/rest/metrics.log</file>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/rest/metrics.log.%d{yyyy-MM-dd}
-			</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfMetricLogPattern}</pattern>
-		</encoder>
-	</appender>
-	<appender name="asyncMETRIC" class="ch.qos.logback.classic.AsyncAppender">
-		<queueSize>1000</queueSize>
-		<includeCallerData>true</includeCallerData>
-		<appender-ref ref="METRIC" />
-	</appender>
+  <appender name="METRIC"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>INFO</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <file>${logDirectory}/rest/metrics.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/metrics.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfMetricLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncMETRIC" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="METRIC" />
+  </appender>
 
-	<appender name="DEBUG"
-		class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>DEBUG</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<file>${logDirectory}/rest/debug.log</file>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/rest/debug.log.%d{yyyy-MM-dd}
-			</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfLogPattern}</pattern>
-		</encoder>
-	</appender>
+  <appender name="DEBUG"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <file>${logDirectory}/rest/debug.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/debug.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="asyncDEBUG" class="ch.qos.logback.classic.AsyncAppender">
-		<queueSize>1000</queueSize>
-		<includeCallerData>true</includeCallerData>
-		<appender-ref ref="DEBUG" />
-	</appender>
+  <appender name="asyncDEBUG" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="DEBUG" />
+  </appender>
 
-	<appender name="ERROR"
-		class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-			<level>WARN</level>
-		</filter>
-		<file>${logDirectory}/rest/error.log</file>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/rest/error.log.%d{yyyy-MM-dd}
-			</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${"eelfErrorLogPattern"}</pattern>
-		</encoder>
-	</appender>
+  <appender name="ERROR"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <file>${logDirectory}/rest/error.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/error.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${"eelfErrorLogPattern"}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="asyncERROR" class="ch.qos.logback.classic.AsyncAppender">
-		<queueSize>1000</queueSize>
-		<includeCallerData>true</includeCallerData>
-		<appender-ref ref="ERROR" />
-	</appender>
+  <appender name="asyncERROR" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="ERROR" />
+  </appender>
 
-	<appender name="AUDIT"
-		class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<file>${logDirectory}/rest/audit.log</file>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/rest/audit.log.%d{yyyy-MM-dd}
-			</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfAuditLogPattern}</pattern>
-		</encoder>
-	</appender>
+  <appender name="AUDIT"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <file>${logDirectory}/rest/audit.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/audit.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfAuditLogPattern}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="asyncAUDIT" class="ch.qos.logback.classic.AsyncAppender">
-		<queueSize>1000</queueSize>
-		<includeCallerData>true</includeCallerData>
-		<appender-ref ref="AUDIT" />
-	</appender>
+  <appender name="asyncAUDIT" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="AUDIT" />
+  </appender>
 
-	<appender name="translog"
-		class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>DEBUG</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<file>${logDirectory}/rest/translog.log</file>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/rest/translog.log.%d{yyyy-MM-dd}
-			</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfTransLogPattern}</pattern>
-		</encoder>
-	</appender>
-	
-	<appender name="asynctranslog" class="ch.qos.logback.classic.AsyncAppender">
-		<queueSize>1000</queueSize>
-		<includeCallerData>true</includeCallerData>
-		<appender-ref ref="translog" />
-	</appender>
+  <appender name="translog"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <file>${logDirectory}/rest/translog.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/translog.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfTransLogPattern}</pattern>
+    </encoder>
+  </appender>
+  
+  <appender name="asynctranslog" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="translog" />
+  </appender>
 
-	<appender name="dmaapAAIEventConsumer"
-		class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-			<level>WARN</level>
-		</filter>
-		<File>${logDirectory}/dmaapAAIEventConsumer/error.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/error.log.%d{yyyy-MM-dd}
-			</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${"eelfErrorLogPattern"}</pattern>
-		</encoder>
-	</appender>
+  <appender name="dmaapAAIEventConsumer"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <File>${logDirectory}/dmaapAAIEventConsumer/error.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/error.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${"eelfErrorLogPattern"}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="dmaapAAIEventConsumerDebug"
-		class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>DEBUG</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<File>${logDirectory}/dmaapAAIEventConsumer/debug.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/debug.log.%d{yyyy-MM-dd}
-			</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfLogPattern}</pattern>
-		</encoder>
-	</appender>
-	<appender name="dmaapAAIEventConsumerMetric"
-		class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>INFO</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<File>${logDirectory}/dmaapAAIEventConsumer/metrics.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/metrics.log.%d{yyyy-MM-dd}
-			</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfMetricLogPattern}</pattern>
-		</encoder>
-	</appender>
-	<appender name="external"
-		class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-			<level>WARN</level>
-		</filter>
-		<file>${logDirectory}/external/external.log</file>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/external/external.log.%d{yyyy-MM-dd}
-			</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfLogPattern}</pattern>
-		</encoder>
-	</appender>
-	
-	<!-- DataGrooming logs started -->
-	<appender name="dataGrooming" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-			<level>WARN</level>
-		</filter>
-		<File>${logDirectory}/dataGrooming/error.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/dataGrooming/error.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfErrorLogPattern}</pattern>
-		</encoder>
-	</appender>
+  <appender name="dmaapAAIEventConsumerDebug"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/dmaapAAIEventConsumer/debug.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/debug.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="dmaapAAIEventConsumerMetric"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>INFO</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/dmaapAAIEventConsumer/metrics.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/metrics.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfMetricLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="external"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <file>${logDirectory}/external/external.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/external/external.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
+  
+  <!-- DataGrooming logs started -->
+  <appender name="dataGrooming" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <File>${logDirectory}/dataGrooming/error.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dataGrooming/error.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfErrorLogPattern}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="dataGroomingdebug" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>DEBUG</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<File>${logDirectory}/dataGrooming/debug.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/dataGrooming/debug.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfLogPattern}</pattern>
-		</encoder>
-	</appender>
+  <appender name="dataGroomingdebug" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/dataGrooming/debug.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dataGrooming/debug.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="dataGroomingmetric" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>INFO</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<File>${logDirectory}/dataGrooming/metrics.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/dataGrooming/metrics.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfMetricLogPattern}</pattern>
-		</encoder>
-	</appender>
-	
-	<!-- DataGrooming logs ended -->
-	
-	<!-- DataSnapshot logs started -->
-	<appender name="dataSnapshot" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-			<level>WARN</level>
-		</filter>
-		<File>${logDirectory}/dataSnapshot/error.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/dataSnapshot/error.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfErrorLogPattern}</pattern>
-		</encoder>
-	</appender>
+  <appender name="dataGroomingmetric" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>INFO</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/dataGrooming/metrics.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dataGrooming/metrics.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfMetricLogPattern}</pattern>
+    </encoder>
+  </appender>
+  
+  <!-- DataGrooming logs ended -->
+  
+  <!-- DataSnapshot logs started -->
+  <appender name="dataSnapshot" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <File>${logDirectory}/dataSnapshot/error.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dataSnapshot/error.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfErrorLogPattern}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="dataSnapshotdebug" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>DEBUG</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<File>${logDirectory}/dataSnapshot/debug.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/dataSnapshot/debug.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfLogPattern}</pattern>
-		</encoder>
-	</appender>
+  <appender name="dataSnapshotdebug" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/dataSnapshot/debug.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dataSnapshot/debug.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="dataSnapshotmetric" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>INFO</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<File>${logDirectory}/dataSnapshot/metrics.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/dataSnapshot/metrics.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfMetricLogPattern}</pattern>
-		</encoder>
-	</appender>
-	
-	<!-- DataSnapshot logs ended -->
-	
-	<!-- CreateDBSchema logs started  -->
-	<appender name="createDBSchema" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-			<level>WARN</level>
-		</filter>
-		<File>${logDirectory}/createDBSchema/error.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/createDBSchema/error.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${"eelfErrorLogPattern"}</pattern>
-		</encoder>
-	</appender>
+  <appender name="dataSnapshotmetric" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>INFO</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/dataSnapshot/metrics.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dataSnapshot/metrics.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfMetricLogPattern}</pattern>
+    </encoder>
+  </appender>
+  
+  <!-- DataSnapshot logs ended -->
+  
+  <!-- CreateDBSchema logs started  -->
+  <appender name="createDBSchema" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <File>${logDirectory}/createDBSchema/error.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/createDBSchema/error.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${"eelfErrorLogPattern"}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="createDBSchemadebug" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>DEBUG</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<File>${logDirectory}/createDBSchema/debug.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/createDBSchema/debug.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfLogPattern}</pattern>
-		</encoder>
-	</appender>
+  <appender name="createDBSchemadebug" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/createDBSchema/debug.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/createDBSchema/debug.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="createDBSchemametric" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>INFO</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<File>${logDirectory}/createDBSchema/metrics.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/createDBSchema/metrics.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfMetricLogPattern}</pattern>
-		</encoder>
-	</appender>
-	<!-- CreateDBSchema logs ended  -->	
-	
-	<!-- DataCleanupTasks logs started  -->
-	<appender name="dataCleanuperror" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-			<level>WARN</level>
-		</filter>
-		<File>${logDirectory}/misc/error.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/misc/error.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${"eelfErrorLogPattern"}</pattern>
-		</encoder>
-	</appender>
+  <appender name="createDBSchemametric" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>INFO</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/createDBSchema/metrics.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/createDBSchema/metrics.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfMetricLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <!-- CreateDBSchema logs ended  -->  
+  
+  <!-- DataCleanupTasks logs started  -->
+  <appender name="dataCleanuperror" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <File>${logDirectory}/misc/error.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/misc/error.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${"eelfErrorLogPattern"}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="dataCleanupdebug" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>DEBUG</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<File>${logDirectory}/misc/debug.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/misc/debug.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfLogPattern}</pattern>
-		</encoder>
-	</appender>
+  <appender name="dataCleanupdebug" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/misc/debug.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/misc/debug.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="dataCleanupmetric" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>INFO</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<File>${logDirectory}/misc/metrics.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/misc/metrics.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfMetricLogPattern}</pattern>
-		</encoder>
-	</appender>
-	<!-- DataCleanupTasks logs ended  -->	
-			
-	<!-- pullInvData logs started -->
-	<appender name="pullInvData" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-			<level>WARN</level>
-		</filter>
-		<File>${logDirectory}/pullInvData/error.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/pullInvData/error.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${"eelfErrorLogPattern"}</pattern>
-		</encoder>
-	</appender>
+  <appender name="dataCleanupmetric" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>INFO</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/misc/metrics.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/misc/metrics.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfMetricLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <!-- DataCleanupTasks logs ended  -->  
+      
+  <!-- pullInvData logs started -->
+  <appender name="pullInvData" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <File>${logDirectory}/pullInvData/error.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/pullInvData/error.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${"eelfErrorLogPattern"}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="pullInvDatadebug" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>DEBUG</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<File>${logDirectory}/pullInvData/debug.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/pullInvData/debug.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfLogPattern}</pattern>
-		</encoder>
-	</appender>
+  <appender name="pullInvDatadebug" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/pullInvData/debug.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/pullInvData/debug.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="pullInvDatametric" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>INFO</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<File>${logDirectory}/pullInvData/metrics.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/pullInvData/metrics.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfMetricLogPattern}</pattern>
-		</encoder>
-	</appender>
-	<!-- pullInvData logs ended -->
-				<!-- DataGrooming logs started -->
-	<appender name="dataExportError" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-			<level>WARN</level>
-		</filter>
-		<File>${logDirectory}/dataExport/error.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/dataExport/error.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfErrorLogPattern}</pattern>
-		</encoder>
-	</appender>
+  <appender name="pullInvDatametric" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>INFO</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/pullInvData/metrics.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/pullInvData/metrics.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfMetricLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <!-- pullInvData logs ended -->
+        <!-- DataGrooming logs started -->
+  <appender name="dataExportError" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <File>${logDirectory}/dataExport/error.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dataExport/error.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfErrorLogPattern}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="dataExportDebug" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>DEBUG</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<File>${logDirectory}/dataExport/debug.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/dataExport/debug.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfLogPattern}</pattern>
-		</encoder>
-	</appender>
+  <appender name="dataExportDebug" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/dataExport/debug.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dataExport/debug.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
 
-	<appender name="dataExportMetric" class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.LevelFilter">
-			<level>INFO</level>
-			<onMatch>ACCEPT</onMatch>
-			<onMismatch>DENY</onMismatch>
-		</filter>
-		<File>${logDirectory}/dataExport/metrics.log</File>
-		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-			<fileNamePattern>${logDirectory}/dataExport/metrics.log.%d{yyyy-MM-dd}</fileNamePattern>
-		</rollingPolicy>
-		<encoder class="org.onap.aai.logging.EcompEncoder">
-			<pattern>${eelfMetricLogPattern}</pattern>
-		</encoder>
-	</appender>
-	
-	<logger name="org.onap.aai" level="DEBUG" additivity="false">
-		<appender-ref ref="asyncDEBUG" />
-		<appender-ref ref="asyncERROR" />
-		<appender-ref ref="asyncMETRIC" />
-		<appender-ref ref="asyncSANE" />
-	</logger>
+  <appender name="dataExportMetric" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>INFO</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/dataExport/metrics.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dataExport/metrics.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfMetricLogPattern}</pattern>
+    </encoder>
+  </appender>
+  
+  <logger name="org.onap.aai" level="DEBUG" additivity="false">
+    <appender-ref ref="asyncDEBUG" />
+    <appender-ref ref="asyncERROR" />
+    <appender-ref ref="asyncMETRIC" />
+    <appender-ref ref="asyncSANE" />
+    <appender-ref ref="STDOUT"/>
+  </logger>
 
-	<!-- Spring related loggers -->
-	<logger name="org.springframework" level="WARN" />
-	<logger name="org.springframework.beans" level="WARN" />
-	<logger name="org.springframework.web" level="WARN" />
-	<logger name="com.blog.spring.jms" level="WARN" />
-	<logger name="com.jayway.jsonpath" level="WARN" />
+  <!-- Spring related loggers -->
+  <logger name="org.springframework" level="WARN" />
+  <logger name="org.springframework.beans" level="WARN" />
+  <logger name="org.springframework.web" level="WARN" />
+  <logger name="com.blog.spring.jms" level="WARN" />
+  <logger name="com.jayway.jsonpath" level="WARN" />
 
-	<!-- AJSC Services (bootstrap services) -->
-	<logger name="ajsc" level="WARN" />
-	<logger name="ajsc.RouteMgmtService" level="WARN" />
-	<logger name="ajsc.ComputeService" level="WARN" />
-	<logger name="ajsc.VandelayService" level="WARN" />
-	<logger name="ajsc.FilePersistenceService" level="WARN" />
-	<logger name="ajsc.UserDefinedJarService" level="WARN" />
-	<logger name="ajsc.UserDefinedBeansDefService" level="WARN" />
-	<logger name="ajsc.LoggingConfigurationService" level="WARN" />
 
-	<!-- AJSC related loggers (DME2 Registration, csi logging, restlet, servlet 
-		logging) -->
-	<logger name="org.codehaus.groovy" level="WARN" />
-	<logger name="com.att.scamper" level="WARN" />
-	<logger name="ajsc.utils" level="WARN" />
-	<logger name="ajsc.utils.DME2Helper" level="WARN" />
-	<logger name="ajsc.filters" level="WARN" />
-	<logger name="ajsc.beans.interceptors" level="WARN" />
-	<logger name="ajsc.restlet" level="WARN" />
-	<logger name="ajsc.servlet" level="WARN" />
-	<logger name="com.att.ajsc" level="WARN" />
-	<logger name="com.att.ajsc.csi.logging" level="WARN" />
-	<logger name="com.att.ajsc.filemonitor" level="WARN" />
-	<logger name="com.netflix.loadbalancer" level="WARN" />
+  <!-- logback internals logging -->
+  <logger name="ch.qos.logback.classic" level="WARN" />
+  <logger name="ch.qos.logback.core" level="WARN" />
 
-	<logger name="org.apache.zookeeper" level="WARN" />
+  <logger name="org.eclipse.jetty" level="WARN" />
 
-	<!-- Other Loggers that may help troubleshoot -->
-	<logger name="net.sf" level="WARN" />
-	<logger name="org.apache.commons.httpclient" level="WARN" />
-	<logger name="org.apache.commons" level="WARN" />
-	<logger name="org.apache.coyote" level="WARN" />
-	<logger name="org.apache.jasper" level="WARN" />
+  <logger name="org.onap.aai.interceptors.post" level="DEBUG"
+      additivity="false">
+    <appender-ref ref="asynctranslog" />
+  </logger>
 
-	<!-- Camel Related Loggers (including restlet/servlet/jaxrs/cxf logging. 
-		May aid in troubleshooting) -->
-	<logger name="org.apache.camel" level="WARN" />
-	<logger name="org.apache.cxf" level="WARN" />
-	<logger name="org.apache.camel.processor.interceptor" level="WARN" />
-	<logger name="org.apache.cxf.jaxrs.interceptor" level="WARN" />
-	<logger name="org.apache.cxf.service" level="WARN" />
-	<logger name="org.restlet" level="WARN" />
-	<logger name="org.apache.camel.component.restlet" level="WARN" />
+  <logger name="org.onap.aai.interceptors.pre.SetLoggingContext" level="DEBUG">
+    <appender-ref ref="asyncAUDIT"/>
+  </logger>
 
-	<logger name="org.hibernate.validator" level="WARN" />
-	<logger name="org.hibernate" level="WARN" />
-	<logger name="org.hibernate.ejb" level="OFF" />
+  <logger name="org.onap.aai.interceptors.post.ResetLoggingContext" level="DEBUG">
+    <appender-ref ref="asyncAUDIT"/>
+  </logger>
 
-	<!-- logback internals logging -->
-	<logger name="ch.qos.logback.classic" level="WARN" />
-	<logger name="ch.qos.logback.core" level="WARN" />
+  <logger name="org.onap.aai.dmaap" level="DEBUG" additivity="false">
+    <appender-ref ref="dmaapAAIEventConsumer" />
+    <appender-ref ref="dmaapAAIEventConsumerDebug" />
+    <appender-ref ref="dmaapAAIEventConsumerMetric" />
+  </logger>
 
-	<logger name="org.eclipse.jetty" level="WARN" />
+  <logger name="org.onap.aai.datasnapshot" level="DEBUG" additivity="false">
+    <appender-ref ref="dataSnapshot"/>
+    <appender-ref ref="dataSnapshotdebug"/>
+    <appender-ref ref="dataSnapshotmetric"/>
+    <appender-ref ref="STDOUT"/>
+  </logger>
 
-	<!-- logback jms appenders & loggers definition starts here -->
-	<appender name="auditLogs"
-		class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.ThresholdFilter" />
-		<file>${logDirectory}/perf-audit/Audit-${lrmRVer}-${lrmRO}-${Pid}.log
-		</file>
-		<rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
-			<fileNamePattern>${logDirectory}/perf-audit/Audit-${lrmRVer}-${lrmRO}-${Pid}.%i.log.zip
-			</fileNamePattern>
-			<minIndex>1</minIndex>
-			<maxIndex>9</maxIndex>
-		</rollingPolicy>
-		<triggeringPolicy
-			class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
-			<maxFileSize>5MB</maxFileSize>
-		</triggeringPolicy>
-		<encoder>
-			<pattern>eelfAuditLogPattern</pattern>
-		</encoder>
-	</appender>
-	<appender name="perfLogs"
-		class="ch.qos.logback.core.rolling.RollingFileAppender">
-		<filter class="ch.qos.logback.classic.filter.ThresholdFilter" />
-		<file>${logDirectory}/perf-audit/Perform-${lrmRVer}-${lrmRO}-${Pid}.log
-		</file>
-		<rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
-			<fileNamePattern>${logDirectory}/perf-audit/Perform-${lrmRVer}-${lrmRO}-${Pid}.%i.log.zip
-			</fileNamePattern>
-			<minIndex>1</minIndex>
-			<maxIndex>9</maxIndex>
-		</rollingPolicy>
-		<triggeringPolicy
-			class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
-			<maxFileSize>5MB</maxFileSize>
-		</triggeringPolicy>
-		<encoder>
-			<pattern>"%d [%thread] %-5level %logger{1024} - %msg%n"</pattern>
-		</encoder>
-	</appender>
-	<logger name="AuditRecord" level="INFO" additivity="false">
-		<appender-ref ref="auditLogs" />
-	</logger>
-	<logger name="AuditRecord_DirectCall" level="INFO" additivity="false">
-		<appender-ref ref="auditLogs" />
-	</logger>
-	<logger name="PerfTrackerRecord" level="INFO" additivity="false">
-		<appender-ref ref="perfLogs" />
-	</logger>
-	<!-- logback jms appenders & loggers definition ends here -->
+  <logger name="org.onap.aai.datagrooming" level="DEBUG" additivity="false">
+    <appender-ref ref="dataGrooming"/>
+    <appender-ref ref="dataGroomingdebug"/>
+    <appender-ref ref="dataGroomingmetric"/>
+    <appender-ref ref="STDOUT"/>
+  </logger>
 
-	<logger name="org.onap.aai.interceptors.post" level="DEBUG"
-			additivity="false">
-		<appender-ref ref="asynctranslog" />
-	</logger>
+  <logger name="org.onap.aai.schema" level="DEBUG" additivity="false">
+    <appender-ref ref="createDBSchema"/>
+    <appender-ref ref="createDBSchemadebug"/>
+    <appender-ref ref="createDBSchemametric"/>
+    <appender-ref ref="STDOUT" />
+  </logger>
 
-	<logger name="org.onap.aai.interceptors.pre.SetLoggingContext" level="DEBUG">
-		<appender-ref ref="asyncAUDIT"/>
-	</logger>
+  <logger name="org.onap.aai.dbgen" level="DEBUG" additivity="false">
+    <appender-ref ref="createDBSchema"/>
+    <appender-ref ref="createDBSchemadebug"/>
+    <appender-ref ref="createDBSchemametric"/>
+    <appender-ref ref="STDOUT" />
+  </logger>
 
-	<logger name="org.onap.aai.interceptors.post.ResetLoggingContext" level="DEBUG">
-		<appender-ref ref="asyncAUDIT"/>
-	</logger>
+  <logger name="org.onap.aai.dbgen.PullInvData" level="DEBUG" additivity="false">
+    <appender-ref ref="pullInvData"/>
+    <appender-ref ref="pullInvDatadebug"/>
+    <appender-ref ref="pullInvDatametric"/>
+  </logger>
+  
+  <logger name="org.onap.aai.datacleanup" level="INFO" additivity="false">
+  <appender-ref ref="dataCleanuperror" />
+  <appender-ref ref="dataCleanupdebug" />
+  <appender-ref ref="dataCleanupmetric" />
+  <appender-ref ref="STDOUT"/>
+  </logger>
+  <logger name="org.onap.aai.dataexport" level="DEBUG" additivity="false">
+    <appender-ref ref="dataExportError"/>
+    <appender-ref ref="dataExportDebug"/>
+    <appender-ref ref="dataExportMetric"/>
+    <appender-ref ref="STDOUT"/>
+  </logger>
+  <logger name="org.apache" level="WARN" />
+  <logger name="org.zookeeper" level="WARN" />
+  <logger name="com.netflix" level="WARN" />
+  <logger name="org.janusgraph" level="WARN" />
+  <logger name="com.att.aft.dme2" level="WARN" />
 
-	<logger name="org.onap.aai.dmaap" level="DEBUG" additivity="false">
-		<appender-ref ref="dmaapAAIEventConsumer" />
-		<appender-ref ref="dmaapAAIEventConsumerDebug" />
-		<appender-ref ref="dmaapAAIEventConsumerMetric" />
-	</logger>
+  <!-- ============================================================================ -->
+  <!-- General EELF logger -->
+  <!-- ============================================================================ -->
+  <logger name="com.att.eelf" level="WARN" additivity="false">
+    <appender-ref ref="asyncDEBUG" />
+    <appender-ref ref="asyncERROR" />
+    <appender-ref ref="asyncMETRIC" />
+  </logger>
 
-	<logger name="org.onap.aai.datasnapshot" level="DEBUG" additivity="false">
-		<appender-ref ref="dataSnapshot"/>
-		<appender-ref ref="dataSnapshotdebug"/>
-		<appender-ref ref="dataSnapshotmetric"/>
-		<appender-ref ref="STDOUT"/>
-	</logger>
-
-	<logger name="org.onap.aai.datagrooming" level="DEBUG" additivity="false">
-		<appender-ref ref="dataGrooming"/>
-		<appender-ref ref="dataGroomingdebug"/>
-		<appender-ref ref="dataGroomingmetric"/>
-		<appender-ref ref="STDOUT"/>
-	</logger>
-
-	<logger name="org.onap.aai.schema" level="DEBUG" additivity="false">
-		<appender-ref ref="createDBSchema"/>
-		<appender-ref ref="createDBSchemadebug"/>
-		<appender-ref ref="createDBSchemametric"/>
-	</logger>
-
-	<logger name="org.onap.aai.dbgen" level="DEBUG" additivity="false">
-		<appender-ref ref="createDBSchema"/>
-		<appender-ref ref="createDBSchemadebug"/>
-		<appender-ref ref="createDBSchemametric"/>
-	</logger>
-
-	<logger name="org.onap.aai.dbgen.PullInvData" level="DEBUG" additivity="false">
-		<appender-ref ref="pullInvData"/>
-		<appender-ref ref="pullInvDatadebug"/>
-		<appender-ref ref="pullInvDatametric"/>
-	</logger>
-	
-	<logger name="org.onap.aai.datacleanup" level="INFO" additivity="false">
-	<appender-ref ref="dataCleanuperror" />
-	<appender-ref ref="dataCleanupdebug" />
-	<appender-ref ref="dataCleanupmetric" />
-	<appender-ref ref="STDOUT"/>
-	</logger>
-	<logger name="org.onap.aai.dataexport" level="DEBUG" additivity="false">
-		<appender-ref ref="dataExportError"/>
-		<appender-ref ref="dataExportDebug"/>
-		<appender-ref ref="dataExportMetric"/>
-		<appender-ref ref="STDOUT"/>
-	</logger>
-	<logger name="org.apache" level="WARN" />
-	<logger name="org.zookeeper" level="WARN" />
-	<logger name="com.netflix" level="WARN" />
-	<logger name="org.janusgraph" level="WARN" />
-	<logger name="com.att.aft.dme2" level="WARN" />
-
-	<!-- ============================================================================ -->
-	<!-- General EELF logger -->
-	<!-- ============================================================================ -->
-	<logger name="com.att.eelf" level="WARN" additivity="false">
-		<appender-ref ref="asyncDEBUG" />
-		<appender-ref ref="asyncERROR" />
-		<appender-ref ref="asyncMETRIC" />
-	</logger>
-
-	<root level="DEBUG">
-		<appender-ref ref="external" />
-		{{ if .Values.global.config.logback.console.enabled }}
-		<appender-ref ref="STDOUT" />
-		{{ end }}
-	</root>
+  <root level="DEBUG">
+    <appender-ref ref="external" />
+    {{ if .Values.global.config.logback.console.enabled }}
+    <appender-ref ref="STDOUT" />
+    {{ end }}
+  </root>
 </configuration>
diff --git a/kubernetes/aai/charts/aai-graphadmin/templates/deployment.yaml b/kubernetes/aai/charts/aai-graphadmin/templates/deployment.yaml
index 869eac0..ce9a8eb 100644
--- a/kubernetes/aai/charts/aai-graphadmin/templates/deployment.yaml
+++ b/kubernetes/aai/charts/aai-graphadmin/templates/deployment.yaml
@@ -55,6 +55,8 @@
         args:
         - --container-name
         - aai-cassandra
+        - --container-name
+        - aai-schema-service
       {{  end  }}
         env:
         - name: NAMESPACE
@@ -72,9 +74,9 @@
         imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
         env:
         - name: LOCAL_USER_ID
-          value: {{ .Values.config.userId | quote }}
+          value: {{ .Values.global.config.userId | quote }}
         - name: LOCAL_GROUP_ID
-          value: {{ .Values.config.groupId | quote }}
+          value: {{ .Values.global.config.groupId | quote }}
         volumeMounts:
         - mountPath: /etc/localtime
           name: localtime
@@ -183,7 +185,7 @@
          name: {{ include "common.fullname" . }}-realm-configmap
       - name: {{ include "common.fullname" . }}-auth-truststore-sec
         secret:
-         secretName: aai-auth-truststore-secret
+         secretName: aai-common-truststore
          items:
           {{ range $job := .Values.global.config.auth.files }}
            - key: {{ . }}
diff --git a/kubernetes/aai/charts/aai-graphadmin/templates/job.yaml b/kubernetes/aai/charts/aai-graphadmin/templates/job.yaml
index cdcf2b1..7f90f64 100644
--- a/kubernetes/aai/charts/aai-graphadmin/templates/job.yaml
+++ b/kubernetes/aai/charts/aai-graphadmin/templates/job.yaml
@@ -49,8 +49,6 @@
         app: {{ include "common.name" . }}-job
         release: {{ .Release.Name }}
       name: {{ include "common.name" . }}
-      annotations:
-        checksum/config: {{ include (print $.Template.BasePath "/configmap.yaml") . | sha256sum }}
     spec:
       initContainers:
       - command:
@@ -58,6 +56,8 @@
         args:
         - --container-name
         - aai-cassandra
+        - --container-name
+        - aai-schema-service
         env:
         - name: NAMESPACE
           valueFrom:
@@ -154,7 +154,7 @@
          name: {{ include "common.fullname" . }}-realm-configmap
       - name: {{ include "common.fullname" . }}-auth-truststore-sec
         secret:
-         secretName: aai-auth-truststore-secret
+         secretName: aai-common-truststore
          items:
           {{ range $job := .Values.global.config.auth.files }}
            - key: {{ . }}
diff --git a/kubernetes/aai/charts/aai-graphadmin/values.yaml b/kubernetes/aai/charts/aai-graphadmin/values.yaml
index b6192c3..d87aa74 100644
--- a/kubernetes/aai/charts/aai-graphadmin/values.yaml
+++ b/kubernetes/aai/charts/aai-graphadmin/values.yaml
@@ -28,7 +28,7 @@
 
 # application image
 repository: nexus3.onap.org:10001
-image: onap/aai-graphadmin:1.0.1
+image: onap/aai-graphadmin:1.1-STAGING-latest
 pullPolicy: Always
 restartPolicy: Always
 flavor: small
diff --git a/kubernetes/aai/charts/aai-resources/resources/config/aaiconfig.properties b/kubernetes/aai/charts/aai-resources/resources/config/aaiconfig.properties
index 4b5ab07..f2e7caa 100644
--- a/kubernetes/aai/charts/aai-resources/resources/config/aaiconfig.properties
+++ b/kubernetes/aai/charts/aai-resources/resources/config/aaiconfig.properties
@@ -69,7 +69,7 @@
 
 aai.transaction.logging=true
 aai.transaction.logging.get=false
-aai.transaction.logging.post=false
+aai.transaction.logging.post=true
 
 aai.realtime.clients={{ .Values.global.config.realtime.clients }}
 
diff --git a/kubernetes/aai/charts/aai-resources/resources/config/application.properties b/kubernetes/aai/charts/aai-resources/resources/config/application.properties
index c8648e4..7237c56 100644
--- a/kubernetes/aai/charts/aai-resources/resources/config/application.properties
+++ b/kubernetes/aai/charts/aai-resources/resources/config/application.properties
@@ -40,9 +40,9 @@
 
 server.port=8447
 server.ssl.enabled-protocols=TLSv1.1,TLSv1.2
-server.ssl.key-store=${server.local.startpath}etc/auth/{{ .Values.global.config.keystore.filename }}
+server.ssl.key-store=${server.local.startpath}/etc/auth/{{ .Values.global.config.keystore.filename }}
 server.ssl.key-store-password=password({{ .Values.global.config.keystore.passwd }})
-server.ssl.trust-store=${server.local.startpath}etc/auth/{{ .Values.global.config.truststore.filename }}
+server.ssl.trust-store=${server.local.startpath}/etc/auth/{{ .Values.global.config.truststore.filename }}
 server.ssl.trust-store-password=password({{ .Values.global.config.truststore.passwd }})
 server.ssl.client-auth=want
 server.ssl.key-store-type=JKS
@@ -81,3 +81,14 @@
 # Specifies the version that the application should default to
 schema.version.api.default={{ .Values.global.config.schema.version.api.default }}
 
+schema.translator.list={{ .Values.global.config.schema.translator.list }}
+schema.service.base.url=https://aai-schema-service.{{ include "common.namespace" . }}:8452/aai/schema-service/v1/
+schema.service.nodes.endpoint=nodes?version=
+schema.service.edges.endpoint=edgerules?version=
+schema.service.versions.endpoint=versions
+schema.service.client={{ .Values.global.config.schema.service.client }}
+
+schema.service.ssl.key-store=${server.local.startpath}/etc/auth/{{ .Values.global.config.keystore.filename }}
+schema.service.ssl.trust-store=${server.local.startpath}/etc/auth/{{ .Values.global.config.truststore.filename }}
+schema.service.ssl.key-store-password=password({{ .Values.global.config.keystore.passwd }})
+schema.service.ssl.trust-store-password=password({{ .Values.global.config.truststore.passwd }})
diff --git a/kubernetes/aai/charts/aai-resources/resources/config/logback.xml b/kubernetes/aai/charts/aai-resources/resources/config/logback.xml
index 9a7216c..0afc6f9 100644
--- a/kubernetes/aai/charts/aai-resources/resources/config/logback.xml
+++ b/kubernetes/aai/charts/aai-resources/resources/config/logback.xml
@@ -1,356 +1,267 @@
 <!--
-    ============LICENSE_START=======================================================
-    org.onap.aai
-    ================================================================================
-    Copyright © 2017 AT&T Intellectual Property. All rights reserved.
-    Modifications Copyright © 2018 Amdocs, Bell Canada
-    ================================================================================
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-       http://www.apache.org/licenses/LICENSE-2.0
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-    ============LICENSE_END=========================================================
-    ECOMP is a trademark and service mark of AT&T Intellectual Property.
+  ============LICENSE_START=======================================================
+  org.onap.aai
+  ================================================================================
+  Copyright © 2017 AT&T Intellectual Property. All rights reserved.
+  Modifications Copyright © 2018 Amdocs, Bell Canada
+  ================================================================================
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+     http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+  ============LICENSE_END=========================================================
+  ECOMP is a trademark and service mark of AT&T Intellectual Property.
 -->
 <configuration scan="true" scanPeriod="60 seconds" debug="false">
-    <statusListener class="ch.qos.logback.core.status.NopStatusListener" />
-    <property resource="application.properties" />
-    <property name="namespace" value="aai-resources"/>
-    <property name="AJSC_HOME" value="${AJSC_HOME:-.}" />
-    <jmxConfigurator />
-    <property name="logDirectory" value="${AJSC_HOME}/logs" />
-    <property name="eelfLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
-    <property name="eelfAuditLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n|\r\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
-    <property name="eelfMetricLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{targetVirtualEntity}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
-    <!--  <property name="eelfErrorLogPattern" value="%ecompStartTime|%X{requestId}|%-10t|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompErrorCategory|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n|\r\n', '^'}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/> -->
-    <property name="eelfErrorLogPattern" value="%ecompStartTime|%X{requestId}|%-10t|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompErrorCategory|%ecompResponseCode|%ecompResponseDescription|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
-    <property name="eelfTransLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{partnerName}:%m%n"/>
-    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
-    <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
-    <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
-    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <encoder>
-            <pattern>
-                %clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}
-            </pattern>
-        </encoder>
-    </appender>
-    <appender name="SANE" class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <file>${logDirectory}/rest/sane.log</file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/rest/sane.log.%d{yyyy-MM-dd}</fileNamePattern>
-        </rollingPolicy>
-        <encoder>
-            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{1024} - %msg%n
-            </pattern>
-        </encoder>
-    </appender>
-    <appender name="asyncSANE" class="ch.qos.logback.classic.AsyncAppender">
-        <queueSize>1000</queueSize>
-        <includeCallerData>true</includeCallerData>
-        <appender-ref ref="SANE" />
-    </appender>
-    <appender name="METRIC"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.LevelFilter">
-            <level>INFO</level>
-            <onMatch>ACCEPT</onMatch>
-            <onMismatch>DENY</onMismatch>
-        </filter>
-        <file>${logDirectory}/rest/metrics.log</file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/rest/metrics.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfMetricLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="asyncMETRIC" class="ch.qos.logback.classic.AsyncAppender">
-        <queueSize>1000</queueSize>
-        <includeCallerData>true</includeCallerData>
-        <appender-ref ref="METRIC" />
-    </appender>
-    <appender name="DEBUG"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.LevelFilter">
-            <level>DEBUG</level>
-            <onMatch>ACCEPT</onMatch>
-            <onMismatch>DENY</onMismatch>
-        </filter>
-        <file>${logDirectory}/rest/debug.log</file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/rest/debug.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="asyncDEBUG" class="ch.qos.logback.classic.AsyncAppender">
-        <queueSize>1000</queueSize>
-        <includeCallerData>true</includeCallerData>
-        <appender-ref ref="DEBUG" />
-    </appender>
-    <appender name="ERROR"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-            <level>WARN</level>
-        </filter>
-        <file>${logDirectory}/rest/error.log</file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/rest/error.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfErrorLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="asyncERROR" class="ch.qos.logback.classic.AsyncAppender">
-        <queueSize>1000</queueSize>
-        <includeCallerData>true</includeCallerData>
-        <appender-ref ref="ERROR" />
-    </appender>
-    <appender name="AUDIT"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <file>${logDirectory}/rest/audit.log</file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/rest/audit.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfAuditLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="asyncAUDIT" class="ch.qos.logback.classic.AsyncAppender">
-        <queueSize>1000</queueSize>
-        <includeCallerData>true</includeCallerData>
-        <appender-ref ref="AUDIT" />
-    </appender>
-    <appender name="translog"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.LevelFilter">
-            <level>DEBUG</level>
-            <onMatch>ACCEPT</onMatch>
-            <onMismatch>DENY</onMismatch>
-        </filter>
-        <file>${logDirectory}/rest/translog.log</file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/rest/translog.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfTransLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="asynctranslog" class="ch.qos.logback.classic.AsyncAppender">
-        <queueSize>1000</queueSize>
-        <includeCallerData>true</includeCallerData>
-        <appender-ref ref="translog" />
-    </appender>
-    <appender name="dmaapAAIEventConsumer"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-            <level>WARN</level>
-        </filter>
-        <File>${logDirectory}/dmaapAAIEventConsumer/error.log</File>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/error.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="dmaapAAIEventConsumerDebug"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.LevelFilter">
-            <level>DEBUG</level>
-            <onMatch>ACCEPT</onMatch>
-            <onMismatch>DENY</onMismatch>
-        </filter>
-        <File>${logDirectory}/dmaapAAIEventConsumer/debug.log</File>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/debug.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="dmaapAAIEventConsumerMetric"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.LevelFilter">
-            <level>INFO</level>
-            <onMatch>ACCEPT</onMatch>
-            <onMismatch>DENY</onMismatch>
-        </filter>
-        <File>${logDirectory}/dmaapAAIEventConsumer/metrics.log</File>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/metrics.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfMetricLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="external"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-            <level>WARN</level>
-        </filter>
-        <file>${logDirectory}/external/external.log</file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/external/external.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <logger name="org.onap.aai" level="DEBUG" additivity="false">
-        <appender-ref ref="asyncDEBUG" />
-        <appender-ref ref="asyncERROR" />
-        <appender-ref ref="asyncMETRIC" />
-        <appender-ref ref="asyncSANE" />
-    </logger>
-    <!-- Spring related loggers -->
-    <logger name="org.springframework" level="WARN" />
-    <logger name="org.springframework.beans" level="WARN" />
-    <logger name="org.springframework.web" level="WARN" />
-    <logger name="com.blog.spring.jms" level="WARN" />
-    <logger name="com.jayway.jsonpath" level="WARN" />
-    <!-- AJSC Services (bootstrap services) -->
-    <logger name="ajsc" level="WARN" />
-    <logger name="ajsc.RouteMgmtService" level="WARN" />
-    <logger name="ajsc.ComputeService" level="WARN" />
-    <logger name="ajsc.VandelayService" level="WARN" />
-    <logger name="ajsc.FilePersistenceService" level="WARN" />
-    <logger name="ajsc.UserDefinedJarService" level="WARN" />
-    <logger name="ajsc.UserDefinedBeansDefService" level="WARN" />
-    <logger name="ajsc.LoggingConfigurationService" level="WARN" />
-    <!-- AJSC related loggers (DME2 Registration, csi logging, restlet, servlet
-        logging) -->
-    <logger name="org.codehaus.groovy" level="WARN" />
-    <logger name="com.att.scamper" level="WARN" />
-    <logger name="ajsc.utils" level="WARN" />
-    <logger name="ajsc.utils.DME2Helper" level="WARN" />
-    <logger name="ajsc.filters" level="WARN" />
-    <logger name="ajsc.beans.interceptors" level="WARN" />
-    <logger name="ajsc.restlet" level="WARN" />
-    <logger name="ajsc.servlet" level="WARN" />
-    <logger name="com.att.ajsc" level="WARN" />
-    <logger name="com.att.ajsc.csi.logging" level="WARN" />
-    <logger name="com.att.ajsc.filemonitor" level="WARN" />
-    <logger name="com.netflix.loadbalancer" level="WARN" />
-    <logger name="org.apache.zookeeper" level="OFF" />
-    <!-- Other Loggers that may help troubleshoot -->
-    <logger name="net.sf" level="WARN" />
-    <logger name="org.apache.commons.httpclient" level="WARN" />
-    <logger name="org.apache.commons" level="WARN" />
-    <logger name="org.apache.coyote" level="WARN" />
-    <logger name="org.apache.jasper" level="WARN" />
-    <!-- Camel Related Loggers (including restlet/servlet/jaxrs/cxf logging.
-        May aid in troubleshooting) -->
-    <logger name="org.apache.camel" level="WARN" />
-    <logger name="org.apache.cxf" level="WARN" />
-    <logger name="org.apache.camel.processor.interceptor" level="WARN" />
-    <logger name="org.apache.cxf.jaxrs.interceptor" level="WARN" />
-    <logger name="org.apache.cxf.service" level="WARN" />
-    <logger name="org.restlet" level="WARN" />
-    <logger name="org.apache.camel.component.restlet" level="WARN" />
-    <logger name="org.hibernate.validator" level="WARN" />
-    <logger name="org.hibernate" level="WARN" />
-    <logger name="org.hibernate.ejb" level="OFF" />
-    <!-- logback internals logging -->
-    <logger name="ch.qos.logback.classic" level="WARN" />
-    <logger name="ch.qos.logback.core" level="WARN" />
-    <logger name="org.eclipse.jetty" level="WARN" />
-    <!-- logback jms appenders & loggers definition starts here -->
-    <appender name="auditLogs"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.ThresholdFilter" />
-        <file>${logDirectory}/perf-audit/Audit-${lrmRVer}-${lrmRO}-${Pid}.log
-        </file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
-            <fileNamePattern>${logDirectory}/perf-audit/Audit-${lrmRVer}-${lrmRO}-${Pid}.%i.log.zip
-            </fileNamePattern>
-            <minIndex>1</minIndex>
-            <maxIndex>9</maxIndex>
-        </rollingPolicy>
-        <triggeringPolicy
-            class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
-            <maxFileSize>5MB</maxFileSize>
-        </triggeringPolicy>
-        <encoder>
-            <pattern>"%d [%thread] %-5level %logger{1024} - %msg%n"</pattern>
-        </encoder>
-    </appender>
-    <appender name="perfLogs"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.ThresholdFilter" />
-        <file>${logDirectory}/perf-audit/Perform-${lrmRVer}-${lrmRO}-${Pid}.log
-        </file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
-            <fileNamePattern>${logDirectory}/perf-audit/Perform-${lrmRVer}-${lrmRO}-${Pid}.%i.log.zip
-            </fileNamePattern>
-            <minIndex>1</minIndex>
-            <maxIndex>9</maxIndex>
-        </rollingPolicy>
-        <triggeringPolicy
-            class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
-            <maxFileSize>5MB</maxFileSize>
-        </triggeringPolicy>
-        <encoder>
-            <pattern>"%d [%thread] %-5level %logger{1024} - %msg%n"</pattern>
-        </encoder>
-    </appender>
-    <logger name="AuditRecord" level="INFO" additivity="false">
-        <appender-ref ref="auditLogs" />
-    </logger>
-    <logger name="AuditRecord_DirectCall" level="INFO" additivity="false">
-        <appender-ref ref="auditLogs" />
-    </logger>
-    <logger name="PerfTrackerRecord" level="INFO" additivity="false">
-        <appender-ref ref="perfLogs" />
-    </logger>
-    <!-- logback jms appenders & loggers definition ends here -->
-    <logger name="org.onap.aai.interceptors.post" level="DEBUG"
-            additivity="false">
-        <appender-ref ref="asynctranslog" />
-    </logger>
-    <logger name="org.onap.aai.interceptors.pre.SetLoggingContext" level="DEBUG">
-        <appender-ref ref="asyncAUDIT"/>
-    </logger>
-    <logger name="org.onap.aai.interceptors.post.ResetLoggingContext" level="DEBUG">
-        <appender-ref ref="asyncAUDIT"/>
-    </logger>
-    <logger name="org.onap.aai.dmaap" level="DEBUG" additivity="false">
-        <appender-ref ref="dmaapAAIEventConsumer" />
-        <appender-ref ref="dmaapAAIEventConsumerDebug" />
-        <appender-ref ref="dmaapAAIEventConsumerMetric" />
-    </logger>
-    <logger name="org.apache" level="OFF" />
-    <logger name="org.zookeeper" level="OFF" />
-    <logger name="com.thinkaurelius" level="WARN" />
-    <logger name="com.att.aft.dme2" level="WARN" />
-    <!-- ============================================================================ -->
-    <!-- General EELF logger -->
-    <!-- ============================================================================ -->
-    <logger name="com.att.eelf" level="WARN" additivity="false">
-        <appender-ref ref="asyncDEBUG" />
-        <appender-ref ref="asyncERROR" />
-        <appender-ref ref="asyncMETRIC" />
-    </logger>
-    <root level="DEBUG">
-        <appender-ref ref="external" />
-        {{ if .Values.global.config.logback.console.enabled }}
-        <appender-ref ref="STDOUT" />
-        {{ end }}
-    </root>
+  <statusListener class="ch.qos.logback.core.status.NopStatusListener" />
+  <property resource="application.properties" />
+  <property name="namespace" value="aai-resources"/>
+  <property name="AJSC_HOME" value="${AJSC_HOME:-.}" />
+  <jmxConfigurator />
+  <property name="logDirectory" value="${AJSC_HOME}/logs" />
+  <property name="eelfLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <property name="eelfAuditLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n|\r\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <property name="eelfMetricLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{targetVirtualEntity}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <!--  <property name="eelfErrorLogPattern" value="%ecompStartTime|%X{requestId}|%-10t|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompErrorCategory|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n|\r\n', '^'}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/> -->
+  <property name="eelfErrorLogPattern" value="%ecompStartTime|%X{requestId}|%-10t|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompErrorCategory|%ecompResponseCode|%ecompResponseDescription|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <property name="eelfTransLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{partnerName}:%m%n"/>
+  <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
+  <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
+  <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <encoder>
+      <pattern>
+        %clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}
+      </pattern>
+    </encoder>
+  </appender>
+  <appender name="SANE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <file>${logDirectory}/rest/sane.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/sane.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{1024} - %msg%n
+      </pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncSANE" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="SANE" />
+  </appender>
+  <appender name="METRIC"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>INFO</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <file>${logDirectory}/rest/metrics.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/metrics.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfMetricLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncMETRIC" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="METRIC" />
+  </appender>
+  <appender name="DEBUG"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <file>${logDirectory}/rest/debug.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/debug.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncDEBUG" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="DEBUG" />
+  </appender>
+  <appender name="ERROR"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <file>${logDirectory}/rest/error.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/error.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfErrorLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncERROR" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="ERROR" />
+  </appender>
+  <appender name="AUDIT"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <file>${logDirectory}/rest/audit.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/audit.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfAuditLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncAUDIT" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="AUDIT" />
+  </appender>
+  <appender name="translog"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <file>${logDirectory}/rest/translog.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/translog.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfTransLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asynctranslog" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="translog" />
+  </appender>
+  <appender name="dmaapAAIEventConsumer"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <File>${logDirectory}/dmaapAAIEventConsumer/error.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/error.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="dmaapAAIEventConsumerDebug"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/dmaapAAIEventConsumer/debug.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/debug.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="dmaapAAIEventConsumerMetric"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>INFO</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/dmaapAAIEventConsumer/metrics.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/metrics.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfMetricLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="external"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <file>${logDirectory}/external/external.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/external/external.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <logger name="org.onap.aai" level="DEBUG" additivity="false">
+    <appender-ref ref="asyncDEBUG" />
+    <appender-ref ref="asyncERROR" />
+    <appender-ref ref="asyncMETRIC" />
+    <appender-ref ref="asyncSANE" />
+    <appender-ref ref="STDOUT" />
+  </logger>
+  <!-- Spring related loggers -->
+  <logger name="org.springframework" level="WARN" />
+  <logger name="org.springframework.beans" level="WARN" />
+  <logger name="org.springframework.web" level="WARN" />
+  <logger name="com.blog.spring.jms" level="WARN" />
+  <logger name="com.jayway.jsonpath" level="WARN" />
+
+  <logger name="ch.qos.logback.classic" level="WARN" />
+  <logger name="ch.qos.logback.core" level="WARN" />
+  <logger name="org.eclipse.jetty" level="WARN" />
+
+  <logger name="org.onap.aai.interceptors.post" level="DEBUG"
+      additivity="false">
+    <appender-ref ref="asynctranslog" />
+  </logger>
+  <logger name="org.onap.aai.interceptors.pre.SetLoggingContext" level="DEBUG">
+    <appender-ref ref="asyncAUDIT"/>
+  </logger>
+  <logger name="org.onap.aai.interceptors.post.ResetLoggingContext" level="DEBUG">
+    <appender-ref ref="asyncAUDIT"/>
+  </logger>
+  <logger name="org.onap.aai.dmaap" level="DEBUG" additivity="false">
+    <appender-ref ref="dmaapAAIEventConsumer" />
+    <appender-ref ref="dmaapAAIEventConsumerDebug" />
+    <appender-ref ref="dmaapAAIEventConsumerMetric" />
+  </logger>
+  <logger name="org.apache" level="OFF" />
+  <logger name="org.zookeeper" level="OFF" />
+  <logger name="com.thinkaurelius" level="WARN" />
+  <logger name="com.att.aft.dme2" level="WARN" />
+  <!-- ============================================================================ -->
+  <!-- General EELF logger -->
+  <!-- ============================================================================ -->
+  <logger name="com.att.eelf" level="WARN" additivity="false">
+    <appender-ref ref="asyncDEBUG" />
+    <appender-ref ref="asyncERROR" />
+    <appender-ref ref="asyncMETRIC" />
+  </logger>
+  <root level="DEBUG">
+    <appender-ref ref="external" />
+    {{ if .Values.global.config.logback.console.enabled }}
+    <appender-ref ref="STDOUT" />
+    {{ end }}
+  </root>
 </configuration>
diff --git a/kubernetes/aai/charts/aai-resources/templates/deployment.yaml b/kubernetes/aai/charts/aai-resources/templates/deployment.yaml
index cac8f4b..d30b90b 100644
--- a/kubernetes/aai/charts/aai-resources/templates/deployment.yaml
+++ b/kubernetes/aai/charts/aai-resources/templates/deployment.yaml
@@ -563,6 +563,8 @@
         args:
         - --container-name
         - aai-cassandra
+        - --container-name
+        - aai-schema-service
       {{  end  }}
         env:
         - name: NAMESPACE
@@ -815,7 +817,7 @@
          name: {{ include "common.fullname" . }}-realm-configmap
       - name: {{ include "common.fullname" . }}-auth-truststore-sec
         secret:
-         secretName: aai-auth-truststore-secret
+         secretName: aai-common-truststore
          items:
           {{ range $job := .Values.global.config.auth.files }}
            - key: {{ . }}
diff --git a/kubernetes/aai/charts/aai-resources/values.yaml b/kubernetes/aai/charts/aai-resources/values.yaml
index e0a1156..ea40973 100644
--- a/kubernetes/aai/charts/aai-resources/values.yaml
+++ b/kubernetes/aai/charts/aai-resources/values.yaml
@@ -22,7 +22,7 @@
 
 # application image
 repository: nexus3.onap.org:10001
-image: onap/aai-resources:1.3.4
+image: onap/aai-resources:1.4-STAGING-latest
 pullPolicy: Always
 restartPolicy: Always
 flavor: small
diff --git a/kubernetes/aai/charts/aai-schema-service/.helmignore b/kubernetes/aai/charts/aai-schema-service/.helmignore
new file mode 100644
index 0000000..daebc7d
--- /dev/null
+++ b/kubernetes/aai/charts/aai-schema-service/.helmignore
@@ -0,0 +1,21 @@
+# Patterns to ignore when building packages.
+# This supports shell glob matching, relative path matching, and
+# negation (prefixed with !). Only one pattern per line.
+.DS_Store
+# Common VCS dirs
+.git/
+.gitignore
+.bzr/
+.bzrignore
+.hg/
+.hgignore
+.svn/
+# Common backup files
+*.swp
+*.bak
+*.tmp
+*~
+# Various IDEs
+.project
+.idea/
+*.tmproj
diff --git a/kubernetes/aai/charts/aai-schema-service/Chart.yaml b/kubernetes/aai/charts/aai-schema-service/Chart.yaml
new file mode 100644
index 0000000..af462f0
--- /dev/null
+++ b/kubernetes/aai/charts/aai-schema-service/Chart.yaml
@@ -0,0 +1,19 @@
+# Copyright © 2019 AT&T
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+apiVersion: v1
+description: ONAP AAI Schema Service
+name: aai-schema-service
+version: 4.0.0
diff --git a/kubernetes/aai/charts/aai-schema-service/config/aaiconfig.properties b/kubernetes/aai/charts/aai-schema-service/config/aaiconfig.properties
new file mode 100644
index 0000000..2172d71
--- /dev/null
+++ b/kubernetes/aai/charts/aai-schema-service/config/aaiconfig.properties
@@ -0,0 +1,43 @@
+#
+# ============LICENSE_START=======================================================
+# org.onap.aai
+# ================================================================================
+# Copyright © 2019 AT&T Intellectual Property. All rights reserved.
+# ================================================================================
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============LICENSE_END=========================================================
+
+aai.server.url.base=https://aai.{{ include "common.namespace" . }}:8443/aai/
+aai.server.url=https://aai.{{ include "common.namespace" . }}:8443/aai/{{ .Values.global.config.schema.version.api.default }}/
+aai.global.callback.url=https://aai.{{ include "common.namespace" . }}:8443/aai/
+
+{{ if .Values.global.config.basic.auth.enabled }}
+aai.tools.enableBasicAuth=true
+aai.tools.username={{ .Values.global.config.basic.auth.username }}
+aai.tools.password={{ .Values.global.config.basic.auth.passwd }}
+{{ end }}
+
+aai.truststore.filename={{ .Values.global.config.truststore.filename }}
+aai.truststore.passwd.x={{ .Values.global.config.truststore.passwd }}
+aai.keystore.filename={{ .Values.global.config.keystore.filename }}
+aai.keystore.passwd.x={{ .Values.global.config.keystore.passwd }}
+
+aai.default.api.version={{ .Values.global.config.schema.version.api.default }}
+
+aai.logging.trace.enabled=true
+aai.logging.trace.logrequest=false
+aai.logging.trace.logresponse=false
+
+aai.transaction.logging=true
+aai.transaction.logging.get=false
+aai.transaction.logging.post=false
diff --git a/kubernetes/aai/charts/aai-schema-service/config/application.properties b/kubernetes/aai/charts/aai-schema-service/config/application.properties
new file mode 100644
index 0000000..7b9312f
--- /dev/null
+++ b/kubernetes/aai/charts/aai-schema-service/config/application.properties
@@ -0,0 +1,70 @@
+# Copyright © 2018 Amdocs, Bell Canada, AT&T
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# The following info parameters are being referenced by ajsc6
+info.build.artifact=aai-schema-service
+info.build.name=schema-service
+info.build.description=Schema Service Microservice
+info.build.version=1.1.0
+
+spring.application.name=aai-schema-service
+spring.jersey.type=filter
+
+server.contextPath=/
+spring.autoconfigure.exclude=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration
+
+spring.profiles.active={{ .Values.global.config.profiles.active }}
+spring.jersey.application-path=${schema.uri.base.path}
+server.tomcat.max-threads=200
+server.tomcat.min-Spare-Threads=25
+server.tomcat.max-idle-time=60000
+
+server.local.startpath=aai-schema-service/src/main/resources/
+server.basic.auth.location=${server.local.startpath}/etc/auth/realm.properties
+
+server.port=8452
+server.ssl.enabled-protocols=TLSv1.1,TLSv1.2
+server.ssl.key-store=${server.local.startpath}/etc/auth/{{ .Values.global.config.keystore.filename }}
+server.ssl.key-store-password=password({{ .Values.global.config.keystore.passwd }})
+server.ssl.trust-store=${server.local.startpath}/etc/auth/{{ .Values.global.config.truststore.filename }}
+server.ssl.trust-store-password=password({{ .Values.global.config.truststore.passwd }})
+server.ssl.client-auth=want
+server.ssl.key-store-type=JKS
+
+schema.configuration.location=N/A
+schema.source.name={{ .Values.global.config.schema.source.name }}
+schema.nodes.location=${server.local.startpath}/schema/${schema.source.name}/oxm/
+schema.edges.location=${server.local.startpath}/schema/${schema.source.name}/dbedgerules/
+schema.query.location=${server.local.startpath}/schema/${schema.source.name}/query/
+
+schema.ingest.file=${server.local.startpath}/application.properties
+
+# Schema Version Related Attributes
+schema.uri.base.path={{ .Values.global.config.schema.uri.base.path }}/schema-service
+# Lists all of the versions in the schema
+schema.version.list={{ .Values.global.config.schema.version.list }}
+# Specifies from which version should the depth parameter to default to zero
+schema.version.depth.start={{ .Values.global.config.schema.version.depth }}
+# Specifies from which version should the related link be displayed in response payload
+schema.version.related.link.start={{ .Values.global.config.schema.version.related.link }}
+
+# Specifies from which version should the client see only the uri excluding host info
+# Before this version server base will also be included
+schema.version.app.root.start={{ .Values.global.config.schema.version.app.root }}
+# Specifies from which version should the namespace be changed
+schema.version.namespace.change.start={{ .Values.global.config.schema.version.namespace.change }}
+# Specifies from which version should the client start seeing the edge label in payload
+schema.version.edge.label.start={{ .Values.global.config.schema.version.edge.label }}
+# Specifies the version that the application should default to
+schema.version.api.default={{ .Values.global.config.schema.version.api.default }}
diff --git a/kubernetes/aai/charts/aai-schema-service/config/localhost-access-logback.xml b/kubernetes/aai/charts/aai-schema-service/config/localhost-access-logback.xml
new file mode 100644
index 0000000..447f239
--- /dev/null
+++ b/kubernetes/aai/charts/aai-schema-service/config/localhost-access-logback.xml
@@ -0,0 +1,58 @@
+<!--
+    ============LICENSE_START=======================================================
+    org.onap.aai
+    ================================================================================
+    Copyright © 2019 AT&T Intellectual Property. All rights reserved.
+    ================================================================================
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+    ============LICENSE_END=========================================================
+-->
+<configuration>
+	<property name="AJSC_HOME" value="${AJSC_HOME:-.}" />
+	<appender name="ACCESS"
+		class="ch.qos.logback.core.rolling.RollingFileAppender">
+		<file>${AJSC_HOME}/logs/ajsc-jetty/localhost_access.log</file>
+		<rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+			<fileNamePattern>${AJSC_HOME}/logs/ajsc-jetty/localhost_access.log.%d{yyyy-MM-dd}
+			</fileNamePattern>
+		</rollingPolicy>
+		<encoder class="org.onap.aai.logging.CustomLogPatternLayoutEncoder">
+			<Pattern>%a %u %z [%t] "%m %U%q" %s %b %y %i{X-TransactionId} %i{X-FromAppId} %i{X-Forwarded-For} %i{X-AAI-SSL-Client-CN} %i{X-AAI-SSL-Client-OU} %i{X-AAI-SSL-Client-O} %i{X-AAI-SSL-Client-L} %i{X-AAI-SSL-Client-ST} %i{X-AAI-SSL-Client-C} %i{X-AAI-SSL-Client-NotBefore} %i{X-AAI-SSL-Client-NotAfter} %i{X-AAI-SSL-Client-DN} %D</Pattern>
+		</encoder>
+	</appender>
+	<appender-ref ref="ACCESS" />
+</configuration>
+
+<!-- 
+%a - Remote IP address
+%A - Local IP address
+%b - Bytes sent, excluding HTTP headers, or '-' if no bytes were sent
+%B - Bytes sent, excluding HTTP headers
+%h - Remote host name
+%H - Request protocol
+%l - Remote logical username from identd (always returns '-')
+%m - Request method
+%p - Local port
+%q - Query string (prepended with a '?' if it exists, otherwise an empty string
+%r - First line of the request
+%s - HTTP status code of the response
+%S - User session ID
+%t - Date and time, in Common Log Format format
+%u - Remote user that was authenticated
+%U - Requested URL path
+%v - Local server name
+%I - current request thread name (can compare later with stacktraces)
+
+%z - Custom pattern that parses the cert for the subject
+%y - Custom pattern determines rest or dme2
+ -->
diff --git a/kubernetes/aai/charts/aai-schema-service/config/logback.xml b/kubernetes/aai/charts/aai-schema-service/config/logback.xml
new file mode 100644
index 0000000..f10546a
--- /dev/null
+++ b/kubernetes/aai/charts/aai-schema-service/config/logback.xml
@@ -0,0 +1,237 @@
+<configuration scan="true" scanPeriod="60 seconds" debug="false">
+  <statusListener class="ch.qos.logback.core.status.NopStatusListener" />
+  <property resource="application.properties" />
+  <property name="AJSC_HOME" value="${AJSC_HOME:-.}" />
+  <jmxConfigurator />
+  <property name="logDirectory" value="${AJSC_HOME}/logs" />
+  <property name="eelfLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <property name="eelfAuditLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n|\r\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <property name="eelfMetricLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{targetVirtualEntity}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <!--  <property name="eelfErrorLogPattern" value="%ecompStartTime|%X{requestId}|%-10t|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompErrorCategory|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n|\r\n', '^'}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/> -->
+  <property name="eelfErrorLogPattern" value="%ecompStartTime|%X{requestId}|%-10t|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompErrorCategory|%ecompResponseCode|%ecompResponseDescription|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <property name="eelfTransLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{partnerName}:%m%n"/>
+  <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
+  <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
+  <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <encoder>
+      <pattern>
+        %clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}
+      </pattern>
+    </encoder>
+  </appender>
+  <appender name="SANE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <file>${logDirectory}/rest/sane.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/sane.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{1024} - %msg%n
+      </pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncSANE" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="SANE" />
+  </appender>
+  <appender name="METRIC"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>INFO</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <file>${logDirectory}/rest/metrics.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/metrics.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfMetricLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncMETRIC" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="METRIC" />
+  </appender>
+  <appender name="DEBUG"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <file>${logDirectory}/rest/debug.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/debug.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncDEBUG" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="DEBUG" />
+  </appender>
+  <appender name="ERROR"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <file>${logDirectory}/rest/error.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/error.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfErrorLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncERROR" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="ERROR" />
+  </appender>
+  <appender name="AUDIT"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <file>${logDirectory}/rest/audit.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/audit.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfAuditLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncAUDIT" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="AUDIT" />
+  </appender>
+  <appender name="translog"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <file>${logDirectory}/rest/translog.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/translog.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfTransLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asynctranslog" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="translog" />
+  </appender>
+  <appender name="dmaapAAIEventConsumer"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <File>${logDirectory}/dmaapAAIEventConsumer/error.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/error.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="dmaapAAIEventConsumerDebug"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/dmaapAAIEventConsumer/debug.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/debug.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="dmaapAAIEventConsumerMetric"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>INFO</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/dmaapAAIEventConsumer/metrics.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/metrics.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfMetricLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="external"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <file>${logDirectory}/external/external.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/external/external.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <logger name="org.onap.aai.schemaservice" level="DEBUG" additivity="false">
+    <appender-ref ref="asyncDEBUG" />
+    <appender-ref ref="asyncERROR" />
+    <appender-ref ref="asyncMETRIC" />
+    <appender-ref ref="asyncSANE" />
+    <appender-ref ref="STDOUT" />
+  </logger>
+  <!-- Spring related loggers -->
+  <logger name="org.springframework" level="WARN" />
+  <logger name="org.springframework.beans" level="WARN" />
+  <logger name="org.springframework.web" level="WARN" />
+  <logger name="com.blog.spring.jms" level="WARN" />
+  <!-- logback internals logging -->
+  <logger name="ch.qos.logback.classic" level="WARN" />
+  <logger name="ch.qos.logback.core" level="WARN" />
+  <logger name="org.eclipse.jetty" level="WARN" />
+
+  <logger name="org.onap.aai.schemaservice.interceptors.post" level="DEBUG"
+      additivity="false">
+    <appender-ref ref="asynctranslog" />
+  </logger>
+  <logger name="org.onap.aai.schemaservice.interceptors.pre.SetLoggingContext" level="DEBUG">
+    <appender-ref ref="asyncAUDIT"/>
+  </logger>
+  <logger name="org.onap.aai.schemaservice.interceptors.post.ResetLoggingContext" level="DEBUG">
+    <appender-ref ref="asyncAUDIT"/>
+  </logger>
+  <!-- ============================================================================ -->
+  <!-- General EELF logger -->
+  <!-- ============================================================================ -->
+  <logger name="com.att.eelf" level="WARN" additivity="false">
+    <appender-ref ref="asyncDEBUG" />
+    <appender-ref ref="asyncERROR" />
+    <appender-ref ref="asyncMETRIC" />
+  </logger>
+  <root level="DEBUG">
+    <appender-ref ref="external" />
+    {{ if .Values.global.config.logback.console.enabled }}
+    <appender-ref ref="STDOUT" />
+    {{ end }}
+  </root>
+</configuration>
diff --git a/kubernetes/aai/charts/aai-schema-service/config/realm.properties b/kubernetes/aai/charts/aai-schema-service/config/realm.properties
new file mode 100644
index 0000000..988bb24
--- /dev/null
+++ b/kubernetes/aai/charts/aai-schema-service/config/realm.properties
@@ -0,0 +1,22 @@
+AAI:OBF:1gfr1ev31gg7,admin
+MSO:OBF:1jzx1lz31k01,admin
+SDNC:OBF:1itr1i0l1i151isv,admin
+DCAE:OBF:1g8u1f9d1f991g8w,admin
+POLICY:OBF:1mk61i171ima1im41i0j1mko,admin
+ASDC:OBF:1f991j0u1j001f9d,admin
+VID:OBF:1jm91i0v1jl9,admin
+APPC:OBF:1f991ksf1ksf1f9d,admin
+ModelLoader:OBF:1qvu1v2h1sov1sar1wfw1j7j1wg21saj1sov1v1x1qxw,admin
+AaiUI:OBF:1gfr1p571unz1p4j1gg7,admin
+OOF:OBF:1img1ke71ily,admin
+aai@aai.onap.org:OBF:1fia1ju61l871lfe18xp18xr18xt1lc41l531jrk1fek,admin
+so@so.onap.org:OBF:1fia1ju61l871lfe18xp18xr18xt1lc41l531jrk1fek,admin
+sdnc@sdnc.onap.org:OBF:1fia1ju61l871lfe18xp18xr18xt1lc41l531jrk1fek,admin
+dcae@dcae.onap.org:OBF:1fia1ju61l871lfe18xp18xr18xt1lc41l531jrk1fek,admin
+policy@policy.onap.org:OBF:1fia1ju61l871lfe18xp18xr18xt1lc41l531jrk1fek,admin
+sdc@sdc.onap.org:OBF:1fia1ju61l871lfe18xp18xr18xt1lc41l531jrk1fek,admin
+vid@vid.onap.org:OBF:1fia1ju61l871lfe18xp18xr18xt1lc41l531jrk1fek,admin
+appc@appc.onap.org:OBF:1fia1ju61l871lfe18xp18xr18xt1lc41l531jrk1fek,admin
+oof@oof.onap.org:OBF:1fia1ju61l871lfe18xp18xr18xt1lc41l531jrk1fek,admin
+pomba@pomba.onap.org:OBF:1fia1ju61l871lfe18xp18xr18xt1lc41l531jrk1fek,admin
+vfc@vfc.onap.org:OBF:1fia1ju61l871lfe18xp18xr18xt1lc41l531jrk1fek,admin
diff --git a/kubernetes/aai/charts/aai-schema-service/templates/configmap.yaml b/kubernetes/aai/charts/aai-schema-service/templates/configmap.yaml
new file mode 100644
index 0000000..91a831a
--- /dev/null
+++ b/kubernetes/aai/charts/aai-schema-service/templates/configmap.yaml
@@ -0,0 +1,78 @@
+# Copyright © 2018 Amdocs, Bell Canada, AT&T
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: {{ include "common.fullname" . }}-log
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+data:
+{{ tpl (.Files.Glob "config/logback.xml").AsConfig . | indent 2 }}
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: {{ include "common.fullname" . }}-localhost-access-log-configmap
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+data:
+{{ tpl (.Files.Glob "config/localhost-access-logback.xml").AsConfig . | indent 2 }}
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: {{ include "common.fullname" . }}-aaiconfig-configmap
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+data:
+{{ tpl (.Files.Glob "config/aaiconfig.properties").AsConfig . | indent 2 }}
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: {{ include "common.fullname" . }}-springapp-configmap
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+data:
+{{ tpl (.Files.Glob "config/application.properties").AsConfig . | indent 2 }}
+---
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: {{ include "common.fullname" . }}-realm-configmap
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+data:
+{{ tpl (.Files.Glob "config/realm.properties").AsConfig . | indent 2 }}
diff --git a/kubernetes/aai/charts/aai-schema-service/templates/deployment.yaml b/kubernetes/aai/charts/aai-schema-service/templates/deployment.yaml
new file mode 100644
index 0000000..bd9a85f
--- /dev/null
+++ b/kubernetes/aai/charts/aai-schema-service/templates/deployment.yaml
@@ -0,0 +1,155 @@
+# Copyright © 2017 Amdocs, Bell Canada
+# Modifications Copyright © 2018 AT&T
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+apiVersion: extensions/v1beta1
+kind: Deployment
+metadata:
+  name: {{ include "common.fullname" . }}
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+spec:
+  replicas: {{ .Values.replicaCount }}
+  selector:
+    matchLabels:
+      app: {{ include "common.name" . }}
+  template:
+    metadata:
+      labels:
+        app: {{ include "common.name" . }}
+        release: {{ .Release.Name }}
+      name: {{ include "common.name" . }}
+      annotations:
+        checksum/config: {{ include (print $.Template.BasePath "/configmap.yaml") . | sha256sum }}
+    spec:
+      containers:
+      - name: {{ include "common.name" . }}
+        image: "{{ include "common.repository" . }}/{{ .Values.image }}"
+        imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+        env:
+        - name: LOCAL_USER_ID
+          value: {{ .Values.global.config.userId | quote }}
+        - name: LOCAL_GROUP_ID
+          value: {{ .Values.global.config.groupId | quote }}
+        volumeMounts:
+        - mountPath: /etc/localtime
+          name: localtime
+          readOnly: true
+        - mountPath: /opt/app/aai-schema-service/resources/etc/appprops/aaiconfig.properties
+          name: aaiconfig-conf
+          subPath: aaiconfig.properties
+        - mountPath: /opt/aai/logroot/AAI-SCHEMA-SERVICE
+          name: {{ include "common.fullname" . }}-logs
+        - mountPath: /opt/app/aai-schema-service/resources/logback.xml
+          name: {{ include "common.fullname" . }}-log-conf
+          subPath: logback.xml
+        - mountPath: /opt/app/aai-schema-service/resources/localhost-access-logback.xml
+          name: localhost-access-log-conf
+          subPath: localhost-access-logback.xml
+        - mountPath: /opt/app/aai-schema-service/resources/etc/auth/realm.properties
+          name: realm-conf
+          subPath: realm.properties
+        - mountPath: /opt/app/aai-schema-service/resources/application.properties
+          name: springapp-conf
+          subPath: application.properties
+          {{ $global := . }}
+          {{ range $job := .Values.global.config.auth.files }}
+        - mountPath: /opt/app/aai-schema-service/resources/etc/auth/{{ . }}
+          name: auth-truststore-sec
+          subPath: {{ . }}
+          {{ end }}
+        ports:
+        - containerPort: {{ .Values.service.internalPort }}
+        - containerPort: {{ .Values.service.internalPort2 }}
+        # disable liveness probe when breakpoints set in debugger
+        # so K8s doesn't restart unresponsive container
+        {{ if .Values.liveness.enabled }}
+        livenessProbe:
+          tcpSocket:
+            port: {{ .Values.service.internalPort }}
+          initialDelaySeconds: {{ .Values.liveness.initialDelaySeconds }}
+          periodSeconds: {{ .Values.liveness.periodSeconds }}
+        {{ end }}
+        readinessProbe:
+          tcpSocket:
+            port: {{ .Values.service.internalPort }}
+          initialDelaySeconds: {{ .Values.readiness.initialDelaySeconds }}
+          periodSeconds: {{ .Values.readiness.periodSeconds }}
+        resources:
+{{ include "common.resources" . | indent 12 }}
+      {{- if .Values.nodeSelector }}
+      nodeSelector:
+{{ toYaml .Values.nodeSelector | indent 8 }}
+      {{- end -}}
+      {{- if .Values.affinity }}
+      affinity:
+{{ toYaml .Values.affinity | indent 8 }}
+      {{- end }}
+
+      # side car containers
+      - name: filebeat-onap
+        image: "{{ .Values.global.loggingRepository }}/{{ .Values.global.loggingImage }}"
+        imagePullPolicy: {{ .Values.global.pullPolicy | default .Values.pullPolicy }}
+        volumeMounts:
+        - mountPath: /usr/share/filebeat/filebeat.yml
+          subPath: filebeat.yml
+          name: filebeat-conf
+        - mountPath: /var/log/onap
+          name: {{ include "common.fullname" . }}-logs
+        - mountPath: /usr/share/filebeat/data
+          name: {{ include "common.fullname" . }}-filebeat
+      volumes:
+      - name: aai-common-aai-auth-mount
+        secret:
+          secretName: aai-common-aai-auth
+      - name: localtime
+        hostPath:
+          path: /etc/localtime
+      - name: filebeat-conf
+        configMap:
+          name: aai-filebeat
+      - name: {{ include "common.fullname" . }}-logs
+        emptyDir: {}
+      - name: {{ include "common.fullname" . }}-filebeat
+        emptyDir: {}
+      - name: {{ include "common.fullname" . }}-log-conf
+        configMap:
+         name: {{ include "common.fullname" . }}-log
+      - name: localhost-access-log-conf
+        configMap:
+         name: {{ include "common.fullname" . }}-localhost-access-log-configmap
+      - name: springapp-conf
+        configMap:
+         name: {{ include "common.fullname" . }}-springapp-configmap
+      - name: aaiconfig-conf
+        configMap:
+         name: {{ include "common.fullname" . }}-aaiconfig-configmap
+      - name: realm-conf
+        configMap:
+         name: {{ include "common.fullname" . }}-realm-configmap
+      - name: auth-truststore-sec
+        secret:
+         secretName: aai-common-truststore
+         items:
+          {{ range $job := .Values.global.config.auth.files }}
+           - key: {{ . }}
+             path: {{ . }}
+          {{ end }}
+      restartPolicy: {{ .Values.restartPolicy }}
+      imagePullSecrets:
+      - name: "{{ include "common.namespace" . }}-docker-registry-key"
diff --git a/kubernetes/aai/charts/aai-schema-service/templates/service.yaml b/kubernetes/aai/charts/aai-schema-service/templates/service.yaml
new file mode 100644
index 0000000..d119912
--- /dev/null
+++ b/kubernetes/aai/charts/aai-schema-service/templates/service.yaml
@@ -0,0 +1,44 @@
+# Copyright © 2018 Amdocs, Bell Canada, AT&T
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ include "common.servicename" . }}
+  namespace: {{ include "common.namespace" . }}
+  labels:
+    app: {{ include "common.name" . }}
+    chart: {{ .Chart.Name }}-{{ .Chart.Version | replace "+" "_" }}
+    release: {{ .Release.Name }}
+    heritage: {{ .Release.Service }}
+spec:
+  type: {{ .Values.service.type }}
+  ports:
+  {{if eq .Values.service.type "NodePort" -}}
+  - port: {{ .Values.service.internalPort }}
+    nodePort: {{ .Values.global.nodePortPrefix | default .Values.nodePortPrefix }}{{ .Values.service.nodePort }}
+    name: {{ .Values.service.portName }}
+  - port: {{ .Values.service.internalPort2 }}
+    nodePort: {{ .Values.global.nodePortPrefix | default .Values.nodePortPrefix }}{{ .Values.service.nodePort2 }}
+    name: {{ .Values.service.portName2 }}
+  {{- else -}}
+  - port: {{ .Values.service.internalPort }}
+    name: {{ .Values.service.portName }}
+  - port: {{ .Values.service.internalPort2 }}
+    name: {{ .Values.service.portName2 }}
+  {{- end}}
+  selector:
+    app: {{ include "common.name" . }}
+    release: {{ .Release.Name }}
+  clusterIP: None
diff --git a/kubernetes/aai/charts/aai-schema-service/values.yaml b/kubernetes/aai/charts/aai-schema-service/values.yaml
new file mode 100644
index 0000000..18b11b8
--- /dev/null
+++ b/kubernetes/aai/charts/aai-schema-service/values.yaml
@@ -0,0 +1,90 @@
+# Copyright © 2018 Amdocs, Bell Canada, AT&T
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Default values for resources.
+# This is a YAML-formatted file.
+# Declare variables to be passed into your templates.
+global: # global defaults
+  nodePortPrefix: 302
+  readinessRepository: oomk8s
+  readinessImage: readiness-check:2.0.0
+
+# application image
+repository: nexus3.onap.org:10001
+image: onap/aai-schema-service:1.0-STAGING-latest
+pullPolicy: Always
+restartPolicy: Always
+flavor: small
+# default number of instances
+replicaCount: 1
+
+nodeSelector: {}
+
+affinity: {}
+
+# probe configuration parameters
+liveness:
+  initialDelaySeconds: 60
+  periodSeconds: 60
+  # necessary to disable liveness probe when setting breakpoints
+  # in debugger so K8s doesn't restart unresponsive container
+  enabled: false
+
+readiness:
+  initialDelaySeconds: 60
+  periodSeconds: 10
+
+service:
+  type: ClusterIP
+  portName: aai-schema-service-8452
+  internalPort: 8452
+  portName2: aai-schema-service-5005
+  internalPort2: 5005
+
+ingress:
+  enabled: false
+
+  # We usually recommend not to specify default resources and to leave this as a conscious
+  # choice for the user. This also increases chances charts run on environments with little
+  # resources, such as Minikube. If you do want to specify resources, uncomment the following
+  # lines, adjust them as necessary, and remove the curly braces after 'resources:'.
+  #
+  # Example:
+  # Configure resource requests and limits
+  # ref: http://kubernetes.io/docs/user-guide/compute-resources/
+  # Minimum memory for development is 2 CPU cores and 4GB memory
+  # Minimum memory for production is 4 CPU cores and 8GB memory
+#resources:
+#  limits:
+#    cpu: 2
+#    memory: 4Gi
+#  requests:
+#    cpu: 2
+#    memory: 4Gi
+resources:
+  small:
+    limits:
+      cpu: 2
+      memory: 4Gi
+    requests:
+      cpu: 1
+      memory: 3Gi
+  large:
+    limits:
+      cpu: 4
+      memory: 8Gi
+    requests:
+      cpu: 2
+      memory: 4Gi
+  unlimited: {}
diff --git a/kubernetes/aai/charts/aai-traversal/resources/config/application.properties b/kubernetes/aai/charts/aai-traversal/resources/config/application.properties
index 8d35e2f..a7c86b6 100644
--- a/kubernetes/aai/charts/aai-traversal/resources/config/application.properties
+++ b/kubernetes/aai/charts/aai-traversal/resources/config/application.properties
@@ -40,9 +40,9 @@
 
 server.port=8446
 server.ssl.enabled-protocols=TLSv1.1,TLSv1.2
-server.ssl.key-store=${server.local.startpath}etc/auth/{{ .Values.global.config.keystore.filename }}
+server.ssl.key-store=${server.local.startpath}/etc/auth/{{ .Values.global.config.keystore.filename }}
 server.ssl.key-store-password=password({{ .Values.global.config.keystore.passwd }})
-server.ssl.trust-store=${server.local.startpath}etc/auth/{{ .Values.global.config.truststore.filename }}
+server.ssl.trust-store=${server.local.startpath}/etc/auth/{{ .Values.global.config.truststore.filename }}
 server.ssl.trust-store-password=password({{ .Values.global.config.truststore.passwd }})
 server.ssl.client-auth=want
 server.ssl.key-store-type=JKS
@@ -83,3 +83,15 @@
 # Specifies the version that the application should default to
 schema.version.api.default={{ .Values.global.config.schema.version.api.default }}
 
+schema.translator.list={{ .Values.global.config.schema.translator.list }}
+schema.service.base.url=https://aai-schema-service.{{ include "common.namespace" . }}:8452/aai/schema-service/v1/
+schema.service.nodes.endpoint=nodes?version=
+schema.service.edges.endpoint=edgerules?version=
+schema.service.versions.endpoint=versions
+schema.service.custom.queries.endpoint=stored-queries
+schema.service.client={{ .Values.global.config.schema.service.client }}
+
+schema.service.ssl.key-store=${server.local.startpath}/etc/auth/{{ .Values.global.config.keystore.filename }}
+schema.service.ssl.trust-store=${server.local.startpath}/etc/auth/{{ .Values.global.config.truststore.filename }}
+schema.service.ssl.key-store-password=password({{ .Values.global.config.keystore.passwd }})
+schema.service.ssl.trust-store-password=password({{ .Values.global.config.truststore.passwd }})
diff --git a/kubernetes/aai/charts/aai-traversal/resources/config/logback.xml b/kubernetes/aai/charts/aai-traversal/resources/config/logback.xml
index 96fe005..d466ccf 100644
--- a/kubernetes/aai/charts/aai-traversal/resources/config/logback.xml
+++ b/kubernetes/aai/charts/aai-traversal/resources/config/logback.xml
@@ -1,369 +1,268 @@
 <!--
-    ============LICENSE_START=======================================================
-    org.onap.aai
-    ================================================================================
-    Copyright © 2017 AT&T Intellectual Property. All rights reserved.
-    Modifications Copyright © 2018 Amdocs, Bell Canada
-    ================================================================================
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-       http://www.apache.org/licenses/LICENSE-2.0
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-    ============LICENSE_END=========================================================
-    ECOMP is a trademark and service mark of AT&T Intellectual Property.
+  ============LICENSE_START=======================================================
+  org.onap.aai
+  ================================================================================
+  Copyright © 2017 AT&T Intellectual Property. All rights reserved.
+  Modifications Copyright © 2018 Amdocs, Bell Canada
+  ================================================================================
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+     http://www.apache.org/licenses/LICENSE-2.0
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+  ============LICENSE_END=========================================================
+  ECOMP is a trademark and service mark of AT&T Intellectual Property.
 -->
 <configuration scan="true" scanPeriod="60 seconds" debug="false">
-    <statusListener class="ch.qos.logback.core.status.NopStatusListener" />
-    <property resource="application.properties" />
-    <property name="namespace" value="aai-traversal"/>
-    <property name="AJSC_HOME" value="${AJSC_HOME:-.}" />
-    <jmxConfigurator />
-    <property name="logDirectory" value="${AJSC_HOME}/logs" />
-    <property name="eelfLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
-    <property name="eelfAuditLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n|\r\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
-    <property name="eelfMetricLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{targetVirtualEntity}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
-    <!--  <property name="eelfErrorLogPattern" value="%ecompStartTime|%X{requestId}|%-10t|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompErrorCategory|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n|\r\n', '^'}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/> -->
-    <property name="eelfErrorLogPattern" value="%ecompStartTime|%X{requestId}|%-10t|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompErrorCategory|%ecompResponseCode|%ecompResponseDescription|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
-    <property name="eelfTransLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{partnerName}:%m%n"/>
-    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
-    <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
-    <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
-    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
-        <encoder>
-            <pattern>
-                %clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}
-            </pattern>
-        </encoder>
-    </appender>
-    <appender name="SANE" class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <file>${logDirectory}/rest/sane.log</file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/rest/sane.log.%d{yyyy-MM-dd}</fileNamePattern>
-        </rollingPolicy>
-        <encoder>
-            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{1024} - %msg%n
-            </pattern>
-        </encoder>
-    </appender>
-    <appender name="asyncSANE" class="ch.qos.logback.classic.AsyncAppender">
-        <queueSize>1000</queueSize>
-        <includeCallerData>true</includeCallerData>
-        <appender-ref ref="SANE" />
-    </appender>
-    <appender name="METRIC"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.LevelFilter">
-            <level>INFO</level>
-            <onMatch>ACCEPT</onMatch>
-            <onMismatch>DENY</onMismatch>
-        </filter>
-        <file>${logDirectory}/rest/metrics.log</file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/rest/metrics.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfMetricLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="asyncMETRIC" class="ch.qos.logback.classic.AsyncAppender">
-        <queueSize>1000</queueSize>
-        <includeCallerData>true</includeCallerData>
-        <appender-ref ref="METRIC" />
-    </appender>
-    <appender name="DEBUG"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.LevelFilter">
-            <level>DEBUG</level>
-            <onMatch>ACCEPT</onMatch>
-            <onMismatch>DENY</onMismatch>
-        </filter>
-        <file>${logDirectory}/rest/debug.log</file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/rest/debug.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="asyncDEBUG" class="ch.qos.logback.classic.AsyncAppender">
-        <queueSize>1000</queueSize>
-        <includeCallerData>true</includeCallerData>
-        <appender-ref ref="DEBUG" />
-    </appender>
-    <appender name="ERROR"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-            <level>WARN</level>
-        </filter>
-        <file>${logDirectory}/rest/error.log</file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/rest/error.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfErrorLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="asyncERROR" class="ch.qos.logback.classic.AsyncAppender">
-        <queueSize>1000</queueSize>
-        <includeCallerData>true</includeCallerData>
-        <appender-ref ref="ERROR" />
-    </appender>
-    <appender name="AUDIT"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <file>${logDirectory}/rest/audit.log</file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/rest/audit.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfAuditLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="asyncAUDIT" class="ch.qos.logback.classic.AsyncAppender">
-        <queueSize>1000</queueSize>
-        <includeCallerData>true</includeCallerData>
-        <appender-ref ref="AUDIT" />
-    </appender>
-    <appender name="translog"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.LevelFilter">
-            <level>DEBUG</level>
-            <onMatch>ACCEPT</onMatch>
-            <onMismatch>DENY</onMismatch>
-        </filter>
-        <file>${logDirectory}/rest/translog.log</file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/rest/translog.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfTransLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="asynctranslog" class="ch.qos.logback.classic.AsyncAppender">
-        <queueSize>1000</queueSize>
-        <includeCallerData>true</includeCallerData>
-        <appender-ref ref="translog" />
-    </appender>
-    <appender name="dmaapAAIEventConsumer"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-            <level>WARN</level>
-        </filter>
-        <File>${logDirectory}/dmaapAAIEventConsumer/error.log</File>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/error.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="dmaapAAIEventConsumerDebug"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.LevelFilter">
-            <level>DEBUG</level>
-            <onMatch>ACCEPT</onMatch>
-            <onMismatch>DENY</onMismatch>
-        </filter>
-        <File>${logDirectory}/dmaapAAIEventConsumer/debug.log</File>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/debug.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="dmaapAAIEventConsumerMetric"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.LevelFilter">
-            <level>INFO</level>
-            <onMatch>ACCEPT</onMatch>
-            <onMismatch>DENY</onMismatch>
-        </filter>
-        <File>${logDirectory}/dmaapAAIEventConsumer/metrics.log</File>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/metrics.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfMetricLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <appender name="external"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
-            <level>WARN</level>
-        </filter>
-        <file>${logDirectory}/external/external.log</file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-            <fileNamePattern>${logDirectory}/external/external.log.%d{yyyy-MM-dd}
-            </fileNamePattern>
-        </rollingPolicy>
-        <encoder class="org.onap.aai.logging.EcompEncoder">
-            <pattern>${eelfLogPattern}</pattern>
-        </encoder>
-    </appender>
-    <logger name="org.onap.aai" level="DEBUG" additivity="false">
-        <appender-ref ref="asyncDEBUG" />
-        <appender-ref ref="asyncERROR" />
-        <appender-ref ref="asyncMETRIC" />
-        <appender-ref ref="asyncSANE" />
-    </logger>
-    <!-- Spring related loggers -->
-    <logger name="org.springframework" level="WARN" />
-    <logger name="org.springframework.beans" level="WARN" />
-    <logger name="org.springframework.web" level="WARN" />
-    <logger name="com.blog.spring.jms" level="WARN" />
-    <logger name="com.jayway.jsonpath" level="WARN" />
-    <!-- AJSC Services (bootstrap services) -->
-    <logger name="ajsc" level="WARN" />
-    <logger name="ajsc.RouteMgmtService" level="WARN" />
-    <logger name="ajsc.ComputeService" level="WARN" />
-    <logger name="ajsc.VandelayService" level="WARN" />
-    <logger name="ajsc.FilePersistenceService" level="WARN" />
-    <logger name="ajsc.UserDefinedJarService" level="WARN" />
-    <logger name="ajsc.UserDefinedBeansDefService" level="WARN" />
-    <logger name="ajsc.LoggingConfigurationService" level="WARN" />
-    <!-- AJSC related loggers (DME2 Registration, csi logging, restlet, servlet
-        logging) -->
-    <logger name="org.codehaus.groovy" level="WARN" />
-    <logger name="com.att.scamper" level="WARN" />
-    <logger name="ajsc.utils" level="WARN" />
-    <logger name="ajsc.utils.DME2Helper" level="WARN" />
-    <logger name="ajsc.filters" level="WARN" />
-    <logger name="ajsc.beans.interceptors" level="WARN" />
-    <logger name="ajsc.restlet" level="WARN" />
-    <logger name="ajsc.servlet" level="WARN" />
-    <logger name="com.att.ajsc" level="WARN" />
-    <logger name="com.att.ajsc.csi.logging" level="WARN" />
-    <logger name="com.att.ajsc.filemonitor" level="WARN" />
-    <logger name="com.netflix.loadbalancer" level="WARN" />
-    <logger name="org.apache.zookeeper" level="OFF" />
-    <!-- Other Loggers that may help troubleshoot -->
-    <logger name="net.sf" level="WARN" />
-    <logger name="org.apache.commons.httpclient" level="WARN" />
-    <logger name="org.apache.commons" level="WARN" />
-    <logger name="org.apache.coyote" level="WARN" />
-    <logger name="org.apache.jasper" level="WARN" />
-    <!-- Camel Related Loggers (including restlet/servlet/jaxrs/cxf logging.
-        May aid in troubleshooting) -->
-    <logger name="org.apache.camel" level="WARN" />
-    <logger name="org.apache.cxf" level="WARN" />
-    <logger name="org.apache.camel.processor.interceptor" level="WARN" />
-    <logger name="org.apache.cxf.jaxrs.interceptor" level="WARN" />
-    <logger name="org.apache.cxf.service" level="WARN" />
-    <logger name="org.restlet" level="WARN" />
-    <logger name="org.apache.camel.component.restlet" level="WARN" />
-    <logger name="org.hibernate.validator" level="WARN" />
-    <logger name="org.hibernate" level="WARN" />
-    <logger name="org.hibernate.ejb" level="OFF" />
-    <!-- logback internals logging -->
-    <logger name="ch.qos.logback.classic" level="WARN" />
-    <logger name="ch.qos.logback.core" level="WARN" />
-    <logger name="org.eclipse.jetty" level="WARN" />
-    <!-- logback jms appenders & loggers definition starts here -->
-    <appender name="auditLogs"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.ThresholdFilter" />
-        <file>${logDirectory}/perf-audit/Audit-${lrmRVer}-${lrmRO}-${Pid}.log
-        </file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
-            <fileNamePattern>${logDirectory}/perf-audit/Audit-${lrmRVer}-${lrmRO}-${Pid}.%i.log.zip
-            </fileNamePattern>
-            <minIndex>1</minIndex>
-            <maxIndex>9</maxIndex>
-        </rollingPolicy>
-        <triggeringPolicy
-            class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
-            <maxFileSize>5MB</maxFileSize>
-        </triggeringPolicy>
-        <encoder>
-            <pattern>"%d [%thread] %-5level %logger{1024} - %msg%n"</pattern>
-        </encoder>
-    </appender>
-    <appender name="perfLogs"
-        class="ch.qos.logback.core.rolling.RollingFileAppender">
-        <filter class="ch.qos.logback.classic.filter.ThresholdFilter" />
-        <file>${logDirectory}/perf-audit/Perform-${lrmRVer}-${lrmRO}-${Pid}.log
-        </file>
-        <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
-            <fileNamePattern>${logDirectory}/perf-audit/Perform-${lrmRVer}-${lrmRO}-${Pid}.%i.log.zip
-            </fileNamePattern>
-            <minIndex>1</minIndex>
-            <maxIndex>9</maxIndex>
-        </rollingPolicy>
-        <triggeringPolicy
-            class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
-            <maxFileSize>5MB</maxFileSize>
-        </triggeringPolicy>
-        <encoder>
-            <pattern>"%d [%thread] %-5level %logger{1024} - %msg%n"</pattern>
-        </encoder>
-    </appender>
-    <appender name="miscLogs" class="ch.qos.logback.core.rolling.RollingFileAppender">
-                <file>${logDirectory}/misc/misc.log</file>
-                <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
-                        <fileNamePattern>${logDirectory}/misc/misc.log.%d{yyyy-MM-dd}</fileNamePattern>
-                </rollingPolicy>
-                <encoder>
-                        <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{1024} - %msg%n                                                              
-                        </pattern>
-        </encoder>
-        </appender>
-    <logger name="AuditRecord" level="INFO" additivity="false">
-        <appender-ref ref="auditLogs" />
-    </logger>
-    <logger name="AuditRecord_DirectCall" level="INFO" additivity="false">
-        <appender-ref ref="auditLogs" />
-    </logger>
-    <logger name="PerfTrackerRecord" level="INFO" additivity="false">
-        <appender-ref ref="perfLogs" />
-    </logger>
-    <logger name="MiscRecord" level="INFO" additivity="false">
-                <appender-ref ref="miscLogs" />
-        </logger>
-    <!-- logback jms appenders & loggers definition ends here -->
-    <logger name="org.onap.aai.interceptors.post" level="DEBUG"
-            additivity="false">
-        <appender-ref ref="asynctranslog" />
-    </logger>
-    <logger name="org.onap.aai.interceptors.pre.SetLoggingContext" level="DEBUG">
-        <appender-ref ref="asyncAUDIT"/>
-    </logger>
-    <logger name="org.onap.aai.interceptors.post.ResetLoggingContext" level="DEBUG">
-        <appender-ref ref="asyncAUDIT"/>
-    </logger>
-    <logger name="org.onap.aai.dmaap" level="DEBUG" additivity="false">
-        <appender-ref ref="dmaapAAIEventConsumer" />
-        <appender-ref ref="dmaapAAIEventConsumerDebug" />
-        <appender-ref ref="dmaapAAIEventConsumerMetric" />
-    </logger>
-    <logger name="org.apache" level="OFF" />
-    <logger name="org.zookeeper" level="OFF" />
-    <logger name="com.thinkaurelius" level="WARN" />
-    <logger name="com.att.aft.dme2" level="WARN" />
-    <!-- ============================================================================ -->
-    <!-- General EELF logger -->
-    <!-- ============================================================================ -->
-    <logger name="com.att.eelf" level="WARN" additivity="false">
-        <appender-ref ref="asyncDEBUG" />
-        <appender-ref ref="asyncERROR" />
-        <appender-ref ref="asyncMETRIC" />
-    </logger>
-    <root level="DEBUG">
-        <appender-ref ref="external" />
-        {{if .Values.global.config.logback.console.enabled}}
-        <appender-ref ref="STDOUT" />
-        {{ end }}
-    </root>
+  <statusListener class="ch.qos.logback.core.status.NopStatusListener" />
+  <property resource="application.properties" />
+  <property name="namespace" value="aai-traversal"/>
+  <property name="AJSC_HOME" value="${AJSC_HOME:-.}" />
+  <jmxConfigurator />
+  <property name="logDirectory" value="${AJSC_HOME}/logs" />
+  <property name="eelfLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <property name="eelfAuditLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n|\r\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <property name="eelfMetricLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{targetVirtualEntity}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <!--  <property name="eelfErrorLogPattern" value="%ecompStartTime|%X{requestId}|%-10t|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompErrorCategory|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n|\r\n', '^'}|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/> -->
+  <property name="eelfErrorLogPattern" value="%ecompStartTime|%X{requestId}|%-10t|%X{serviceName}|%X{partnerName}|%X{targetEntity}|%X{targetServiceName}|%ecompErrorCategory|%ecompResponseCode|%ecompResponseDescription|co=%X{component}:%replace(%replace(%m){'\\|', '!'}){'\r|\n', '^'}%n"/>
+  <property name="eelfTransLogPattern" value="%ecompStartTime|%date{yyyy-MM-dd'T'HH:mm:ss.SSSZ, UTC}|%X{requestId}|%X{serviceInstanceId}|%-10t|%X{serverName}|%X{serviceName}|%X{partnerName}|%X{statusCode}|%X{responseCode}|%replace(%replace(%X{responseDescription}){'\\|', '!'}){'\r|\n', '^'}|%X{instanceUUID}|%level|%X{severity}|%X{serverIpAddress}|%ecompElapsedTime|%X{server}|%X{clientIpAddress}|%eelfClassOfCaller|%X{unused}|%X{processKey}|%X{customField1}|%X{customField2}|%X{customField3}|%X{customField4}|co=%X{partnerName}:%m%n"/>
+  <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter" />
+  <conversionRule conversionWord="wex" converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter" />
+  <conversionRule conversionWord="wEx" converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter" />
+  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+    <encoder>
+      <pattern>
+        %clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}
+      </pattern>
+    </encoder>
+  </appender>
+  <appender name="SANE" class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <file>${logDirectory}/rest/sane.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/sane.log.%d{yyyy-MM-dd}</fileNamePattern>
+    </rollingPolicy>
+    <encoder>
+      <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{1024} - %msg%n
+      </pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncSANE" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="SANE" />
+  </appender>
+  <appender name="METRIC"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>INFO</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <file>${logDirectory}/rest/metrics.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/metrics.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfMetricLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncMETRIC" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="METRIC" />
+  </appender>
+  <appender name="DEBUG"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <file>${logDirectory}/rest/debug.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/debug.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncDEBUG" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="DEBUG" />
+  </appender>
+  <appender name="ERROR"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <file>${logDirectory}/rest/error.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/error.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfErrorLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncERROR" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="ERROR" />
+  </appender>
+  <appender name="AUDIT"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <file>${logDirectory}/rest/audit.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/audit.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfAuditLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asyncAUDIT" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="AUDIT" />
+  </appender>
+  <appender name="translog"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <file>${logDirectory}/rest/translog.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/rest/translog.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfTransLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="asynctranslog" class="ch.qos.logback.classic.AsyncAppender">
+    <queueSize>1000</queueSize>
+    <includeCallerData>true</includeCallerData>
+    <appender-ref ref="translog" />
+  </appender>
+  <appender name="dmaapAAIEventConsumer"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <File>${logDirectory}/dmaapAAIEventConsumer/error.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/error.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="dmaapAAIEventConsumerDebug"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>DEBUG</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/dmaapAAIEventConsumer/debug.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/debug.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="dmaapAAIEventConsumerMetric"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.LevelFilter">
+      <level>INFO</level>
+      <onMatch>ACCEPT</onMatch>
+      <onMismatch>DENY</onMismatch>
+    </filter>
+    <File>${logDirectory}/dmaapAAIEventConsumer/metrics.log</File>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/dmaapAAIEventConsumer/metrics.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfMetricLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <appender name="external"
+    class="ch.qos.logback.core.rolling.RollingFileAppender">
+    <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
+      <level>WARN</level>
+    </filter>
+    <file>${logDirectory}/external/external.log</file>
+    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
+      <fileNamePattern>${logDirectory}/external/external.log.%d{yyyy-MM-dd}
+      </fileNamePattern>
+    </rollingPolicy>
+    <encoder class="org.onap.aai.logging.EcompEncoder">
+      <pattern>${eelfLogPattern}</pattern>
+    </encoder>
+  </appender>
+  <logger name="org.onap.aai" level="DEBUG" additivity="false">
+    <appender-ref ref="asyncDEBUG" />
+    <appender-ref ref="asyncERROR" />
+    <appender-ref ref="asyncMETRIC" />
+    <appender-ref ref="asyncSANE" />
+    <appender-ref ref="STDOUT" />
+  </logger>
+
+  <!-- Spring related loggers -->
+  <logger name="org.springframework" level="WARN" />
+  <logger name="org.springframework.beans" level="WARN" />
+  <logger name="org.springframework.web" level="WARN" />
+  <logger name="com.blog.spring.jms" level="WARN" />
+  <logger name="com.jayway.jsonpath" level="WARN" />
+
+  <logger name="ch.qos.logback.classic" level="WARN" />
+  <logger name="ch.qos.logback.core" level="WARN" />
+  <logger name="org.eclipse.jetty" level="WARN" />
+
+  <logger name="org.onap.aai.interceptors.post" level="DEBUG"
+      additivity="false">
+    <appender-ref ref="asynctranslog" />
+  </logger>
+  <logger name="org.onap.aai.interceptors.pre.SetLoggingContext" level="DEBUG">
+    <appender-ref ref="asyncAUDIT"/>
+  </logger>
+  <logger name="org.onap.aai.interceptors.post.ResetLoggingContext" level="DEBUG">
+    <appender-ref ref="asyncAUDIT"/>
+  </logger>
+  <logger name="org.onap.aai.dmaap" level="DEBUG" additivity="false">
+    <appender-ref ref="dmaapAAIEventConsumer" />
+    <appender-ref ref="dmaapAAIEventConsumerDebug" />
+    <appender-ref ref="dmaapAAIEventConsumerMetric" />
+  </logger>
+  <logger name="org.apache" level="OFF" />
+  <logger name="org.zookeeper" level="OFF" />
+  <logger name="com.thinkaurelius" level="WARN" />
+  <logger name="com.att.aft.dme2" level="WARN" />
+  <!-- ============================================================================ -->
+  <!-- General EELF logger -->
+  <!-- ============================================================================ -->
+  <logger name="com.att.eelf" level="WARN" additivity="false">
+    <appender-ref ref="asyncDEBUG" />
+    <appender-ref ref="asyncERROR" />
+    <appender-ref ref="asyncMETRIC" />
+  </logger>
+  <root level="DEBUG">
+    <appender-ref ref="external" />
+    {{if .Values.global.config.logback.console.enabled}}
+    <appender-ref ref="STDOUT" />
+    {{ end }}
+  </root>
 </configuration>
diff --git a/kubernetes/aai/charts/aai-traversal/templates/deployment.yaml b/kubernetes/aai/charts/aai-traversal/templates/deployment.yaml
index 3785de0..e5a4bdf 100644
--- a/kubernetes/aai/charts/aai-traversal/templates/deployment.yaml
+++ b/kubernetes/aai/charts/aai-traversal/templates/deployment.yaml
@@ -324,6 +324,8 @@
         args:
         - --container-name
         - aai-cassandra
+        - --container-name
+        - aai-schema-service
       {{  end  }}
         env:
         - name: NAMESPACE
@@ -486,7 +488,7 @@
          name: {{ include "common.fullname" . }}-realm-configmap
       - name: {{ include "common.fullname" . }}-auth-truststore-sec
         secret:
-         secretName: aai-auth-truststore-secret
+         secretName: aai-common-truststore
          items:
           {{ range $job := .Values.global.config.auth.files }}
            - key: {{ . }}
diff --git a/kubernetes/aai/charts/aai-traversal/templates/job.yaml b/kubernetes/aai/charts/aai-traversal/templates/job.yaml
index e2fe395..a746f54 100644
--- a/kubernetes/aai/charts/aai-traversal/templates/job.yaml
+++ b/kubernetes/aai/charts/aai-traversal/templates/job.yaml
@@ -136,7 +136,7 @@
          name: {{ include "common.fullname" . }}-realm-configmap
       - name: {{ include "common.fullname" . }}-auth-truststore-sec
         secret:
-         secretName: aai-auth-truststore-secret
+         secretName: aai-common-truststore
          items:
           {{ range $job := .Values.global.config.auth.files }}
            - key: {{ . }}
diff --git a/kubernetes/aai/charts/aai-traversal/values.yaml b/kubernetes/aai/charts/aai-traversal/values.yaml
index 92c60a2..0ec1448 100644
--- a/kubernetes/aai/charts/aai-traversal/values.yaml
+++ b/kubernetes/aai/charts/aai-traversal/values.yaml
@@ -23,7 +23,7 @@
 
 # application image
 repository: nexus3.onap.org:10001
-image: onap/aai-traversal:1.3.3
+image: onap/aai-traversal:1.4-STAGING-latest
 pullPolicy: Always
 restartPolicy: Always
 flavor: small
diff --git a/kubernetes/aai/templates/secret.yaml b/kubernetes/aai/templates/secret.yaml
index 8d00a9d..3889805 100644
--- a/kubernetes/aai/templates/secret.yaml
+++ b/kubernetes/aai/templates/secret.yaml
@@ -20,3 +20,12 @@
 type: Opaque
 data:
 {{ tpl (.Files.Glob "resources/config/auth/*").AsSecrets . | indent 2 }}
+---
+apiVersion: v1
+kind: Secret
+metadata:
+  name: aai-common-truststore
+  namespace: {{ include "common.namespace" . }}
+type: Opaque
+data:
+{{ tpl (.Files.Glob "resources/config/aai/*").AsSecrets . | indent 2 }}
diff --git a/kubernetes/aai/values.yaml b/kubernetes/aai/values.yaml
index d5a5db0..dab171d 100644
--- a/kubernetes/aai/values.yaml
+++ b/kubernetes/aai/values.yaml
@@ -160,6 +160,12 @@
 
     # Schema specific properties that include supported versions of api
     schema:
+      # Specifies if the connection should be one way ssl, two way ssl or no auth
+      service:
+        client: one-way-ssl
+      # Specifies which translator to use if it has schema-service, then it will make a rest request to schema service
+      translator:
+        list: schema-service
       source:
         # Specifies which folder to take a look at
         name: onap
@@ -170,14 +176,14 @@
       version:
         # Current version of the REST API
         api:
-          default: v14
+          default: v15
         # Specifies which version the depth parameter is configurable
-        depth: v9
+        depth: v11
         # List of all the supported versions of the API
-        list: v8,v9,v10,v11,v12,v13,v14
+        list: v11,v12,v13,v14,v15
         # Specifies from which version related link should appear
         related:
-          link: v10
+          link: v11
         # Specifies from which version the app root change happened
         app:
           root: v11
