diff --git a/app/common/directives/app-header.html b/app/common/directives/app-header.html
index 9ae4283..3464518 100644
--- a/app/common/directives/app-header.html
+++ b/app/common/directives/app-header.html
@@ -17,7 +17,7 @@
 			<a class="header__info" ng-click="toggle = !toggle"><span>Server Info</span><i class="icon icon-angle" aria-hidden="true"></i></a>
 			<a href="#/server-health/event-log" class="header__server-health">Server health
 				<i class="icon icon-angle" aria-hidden="true"></i><span ng-class="{'status-light__error': dataService.server_health == 'Critical', 'status-light__warn': dataService.server_health == 'Warning', 'status-light__good': dataService.server_health == 'Good'}">{{dataService.server_health}}</span></a>
-			 <a href="#/server-control/power-operations" class="header__server-power" role="button">Server power 
+			 <a href="#/server-control/power-operations" class="header__server-power" role="button">Server power
                 <i class="icon icon-angle" aria-hidden="true"></i><span ng-class="{'status-light__off': dataService.server_state == 'Off', 'status-light__disabled': dataService.server_state == 'Unreachable', 'status-light__good': dataService.server_state == 'Running', 'status-light__warn': dataService.server_state == 'Quiesced'}">{{dataService.server_state | quiescedToStandBy}}</span></a>
 			<p class="header__refresh">Data last refreshed<span>{{dataService.last_updated |date:'h:mm:ss MMM dd yyyy'}}</span>
 			</p>
diff --git a/app/common/directives/log-filter.html b/app/common/directives/log-filter.html
index eac263f..c1c3122 100644
--- a/app/common/directives/log-filter.html
+++ b/app/common/directives/log-filter.html
@@ -38,17 +38,17 @@
             </button>
             <ul class="dropdown__list inline" ng-show="statusFilter">
                 <li>
-                    <button 
+                    <button
                         ng-click="selectedStatus.all = true; statusFilter = false;"
                         ng-class="{'active' : selectedStatus.all}">All events</button>
                 </li>
                 <li>
-                    <button 
+                    <button
                         ng-click="selectedStatus.all = false; selectedStatus.resolved = true; statusFilter = false;"
                         ng-class="{'active' : selectedStatus.resolved}">Resolved events</button>
                 </li>
                 <li>
-                    <button 
+                    <button
                         ng-click="selectedStatus.all = false; selectedStatus.resolved = false; statusFilter = false;"
                         ng-class="{'active' : !selectedStatus.resolved}">Unresolved events</button>
                 </li>
diff --git a/app/common/directives/log-filter.js b/app/common/directives/log-filter.js
index bc2da0e..370e666 100644
--- a/app/common/directives/log-filter.js
+++ b/app/common/directives/log-filter.js
@@ -33,8 +33,8 @@
                             }
                         }
 
-                        if($scope.selectedSeverity.low && 
-                           $scope.selectedSeverity.medium && 
+                        if($scope.selectedSeverity.low &&
+                           $scope.selectedSeverity.medium &&
                            $scope.selectedSeverity.high){
                             $scope.selectedSeverity.all = true;
                             $scope.selectedSeverity.low = false;
diff --git a/app/common/directives/toggle-flag.js b/app/common/directives/toggle-flag.js
index aca09ca..9c342b0 100644
--- a/app/common/directives/toggle-flag.js
+++ b/app/common/directives/toggle-flag.js
@@ -7,19 +7,19 @@
             return {
                 restrict: 'A',
                 link: function (scope, element, attrs) {
-        
+
                     function elementClick(e) {
                         e.stopPropagation();
                     }
-        
+
                     function documentClick(e) {
                         scope[attrs.toggleFlag] = false;
                         scope.$apply();
                     }
-        
+
                     element.on('click', elementClick);
                     $document.on('click', documentClick);
-        
+
                     // remove event handlers when directive is destroyed
                     scope.$on('$destroy', function () {
                         element.off('click', elementClick);
