Clean up logging and formatting. (#1378)

* ref: Do not include the full JSON when firing event (unused).

* ref: Logging and formatting fixes.

modules/RTC/BridgeChannel.js

      */
     constructor(peerconnection, wsUrl, emitter, senderVideoConstraintsChanged) {
         if (!peerconnection && !wsUrl) {
-            throw new TypeError(
-                'At least peerconnection or wsUrl must be given');
+            throw new TypeError('At least peerconnection or wsUrl must be given');
         } else if (peerconnection && wsUrl) {
-            throw new TypeError(
-                'Just one of peerconnection or wsUrl must be given');
+            throw new TypeError('Just one of peerconnection or wsUrl must be given');
         }
 
         if (peerconnection) {
      * @param {number} value The new value for lastN. -1 means unlimited.
      */
     sendSetLastNMessage(value) {
-        const jsonObject = {
+        logger.log(`Sending lastN=${value}.`);
+
+        this._send({
             colibriClass: 'LastNChangedEvent',
             lastN: value
-        };
-
-        this._send(jsonObject);
-        logger.log(`Channel lastN set to: ${value}`);
+        });
     }
 
     /**
      * or from WebSocket#send or Error with "No opened channel" message.
      */
     sendPinnedEndpointMessage(endpointId) {
-        logger.log(
-            'sending pinned changed notification to the bridge for endpoint ',
-            endpointId);
+        logger.log(`Sending pinned endpoint: ${endpointId}.`);
 
         this._send({
             colibriClass: 'PinnedEndpointChangedEvent',
      * or from WebSocket#send or Error with "No opened channel" message.
      */
     sendSelectedEndpointsMessage(endpointIds) {
-        logger.log(
-            'sending selected changed notification to the bridge for endpoints',
-            endpointIds);
+        logger.log(`Sending selected endpoints: ${endpointIds}.`);
 
         this._send({
             colibriClass: 'SelectedEndpointsChangedEvent',
      * in pixels, this receiver is willing to receive
      */
     sendReceiverVideoConstraintMessage(maxFrameHeightPixels) {
-        logger.log('sending a ReceiverVideoConstraint message with '
-            + `a maxFrameHeight of ${maxFrameHeightPixels} pixels`);
+        logger.log(`Sending ReceiverVideoConstraint with maxFrameHeight=${maxFrameHeightPixels}px`);
         this._send({
             colibriClass: 'ReceiverVideoConstraint',
             maxFrameHeight: maxFrameHeightPixels
                 obj = JSON.parse(data);
             } catch (error) {
                 GlobalOnErrorHandler.callErrorHandler(error);
-                logger.error(
-                    'Failed to parse channel message as JSON: ',
-                    data, error);
+                logger.error('Failed to parse channel message as JSON: ', data, error);
 
                 return;
             }
                 // Endpoint ID from the Videobridge.
                 const dominantSpeakerEndpoint = obj.dominantSpeakerEndpoint;
 
-                logger.info(
-                    'Channel new dominant speaker event: ',
-                    dominantSpeakerEndpoint);
-                emitter.emit(
-                    RTCEvents.DOMINANT_SPEAKER_CHANGED,
-                    dominantSpeakerEndpoint);
+                logger.info(`New dominant speaker: ${dominantSpeakerEndpoint}.`);
+                emitter.emit(RTCEvents.DOMINANT_SPEAKER_CHANGED, dominantSpeakerEndpoint);
                 break;
             }
             case 'EndpointConnectivityStatusChangeEvent': {
                 const endpoint = obj.endpoint;
                 const isActive = obj.active === 'true';
 
-                logger.info(
-                    `Endpoint connection status changed: ${endpoint} active ? ${
-                        isActive}`);
-                emitter.emit(RTCEvents.ENDPOINT_CONN_STATUS_CHANGED,
-                    endpoint, isActive);
+                logger.info(`Endpoint connection status changed: ${endpoint} active=${isActive}`);
+                emitter.emit(RTCEvents.ENDPOINT_CONN_STATUS_CHANGED, endpoint, isActive);
 
                 break;
             }
             case 'EndpointMessage': {
-                emitter.emit(
-                    RTCEvents.ENDPOINT_MESSAGE_RECEIVED, obj.from,
-                    obj.msgPayload);
+                emitter.emit(RTCEvents.ENDPOINT_MESSAGE_RECEIVED, obj.from, obj.msgPayload);
 
                 break;
             }
             case 'LastNEndpointsChangeEvent': {
-                // The new/latest list of last-n endpoint IDs.
+                // The new/latest list of last-n endpoint IDs (i.e. endpoints for which the bridge is sending video).
                 const lastNEndpoints = obj.lastNEndpoints;
 
-                logger.info('Channel new last-n event: ',
-                    lastNEndpoints, obj);
-                emitter.emit(RTCEvents.LASTN_ENDPOINT_CHANGED,
-                    lastNEndpoints, obj);
+                logger.info(`New forwarded endpoints: ${lastNEndpoints}`);
+                emitter.emit(RTCEvents.LASTN_ENDPOINT_CHANGED, lastNEndpoints);
 
                 break;
             }