use logger instead of console

app.js

 /* global $, config, getRoomName */
 /* application specific logic */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 import "babel-polyfill";
 import "jquery";
             'VideoChat', `Room: ${roomName}`, URL
         );
     } catch (e) {
-        console.warn("Push history state failed with parameters:",
+        logger.warn("Push history state failed with parameters:",
             'VideoChat', `Room: ${roomName}`, URL, e);
         return e;
     }
         }).catch(function (err) {
             APP.UI.hideRingOverLay();
             APP.API.notifyConferenceLeft(APP.conference.roomName);
-            console.error(err);
+            logger.error(err);
         });
     }
 }
                 if (success) {
                     var now = APP.connectionTimes["configuration.fetched"] =
                         window.performance.now();
-                    console.log("(TIME) configuration fetched:\t", now);
+                    logger.log("(TIME) configuration fetched:\t", now);
                     init();
                 } else {
                     // Show obtain config error,
 
 $(document).ready(function () {
     var now = APP.connectionTimes["document.ready"] = window.performance.now();
-    console.log("(TIME) document ready:\t", now);
+    logger.log("(TIME) document ready:\t", now);
 
     URLProcessor.setConfigParametersFromUrl();
     APP.init();

conference.js

 /* global $, APP, JitsiMeetJS, config, interfaceConfig */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 import {openConnection} from './connection';
 import Invite from './modules/UI/invite/Invite';
 import ContactList from './modules/UI/side_pannels/contactlist/ContactList';
     const method = muted ? 'mute' : 'unmute';
 
     localMedia[method]().catch(reason => {
-        console.warn(`${localMediaTypeString} ${method} was rejected:`, reason);
+        logger.warn(`${localMediaTypeString} ${method} was rejected:`, reason);
     });
 }
 
             });
             return tracks;
         }).catch(function (err) {
-            console.error(
+            logger.error(
                 'failed to create local tracks', options.devices, err);
             return Promise.reject(err);
         });
         this._reject(err);
     }
     _onConferenceFailed(err, ...params) {
-        console.error('CONFERENCE FAILED:', err, ...params);
+        logger.error('CONFERENCE FAILED:', err, ...params);
         APP.UI.hideRingOverLay();
         switch (err) {
             // room is locked by the password
         }
     }
     _onConferenceError(err, ...params) {
-        console.error('CONFERENCE Error:', err, params);
+        logger.error('CONFERENCE Error:', err, params);
         switch (err) {
         case ConferenceErrors.CHAT_ERROR:
             {
             }
             break;
         default:
-            console.error("Unknown error.");
+            logger.error("Unknown error.", err);
         }
     }
     _unsubscribe() {
                 analytics.init();
                 return createInitialLocalTracksAndConnect(options.roomName);
             }).then(([tracks, con]) => {
-                console.log('initialized with %s local tracks', tracks.length);
+                logger.log('initialized with %s local tracks', tracks.length);
                 APP.connection = connection = con;
                 this._bindConnectionFailedHandler(con);
                 this._createRoom(tracks);
                 // - item-not-found
                 // - connection dropped(closed by Strophe unexpectedly
                 //   possible due too many transport errors)
-                console.error("XMPP connection error: " + errMsg);
+                logger.error("XMPP connection error: " + errMsg);
                 APP.UI.showPageReloadOverlay();
                 connection.removeEventListener(
                     ConnectionEvents.CONNECTION_FAILED, handler);
             } else if (track.isVideoTrack()) {
                 return this.useVideoStream(track);
             } else {
-                console.error(
+                logger.error(
                     "Ignored not an audio nor a video track: ", track);
                 return Promise.resolve();
             }
     videoSwitchInProgress: false,
     toggleScreenSharing (shareScreen = !this.isSharingScreen) {
         if (this.videoSwitchInProgress) {
-            console.warn("Switch in progress.");
+            logger.warn("Switch in progress.");
             return;
         }
         if (!this.isDesktopSharingEnabled) {
-            console.warn("Cannot toggle screen sharing: not supported.");
+            logger.warn("Cannot toggle screen sharing: not supported.");
             return;
         }
 
                 this.videoSwitchInProgress = false;
                 JitsiMeetJS.analytics.sendEvent(
                     'conference.sharingDesktop.start');
-                console.log('sharing local desktop');
+                logger.log('sharing local desktop');
             }).catch((err) => {
                 // close external installation dialog to show the error.
                 if(externalInstallation)
                     return;
                 }
 
-                console.error('failed to share local desktop', err);
+                logger.error('failed to share local desktop', err);
 
                 if (err.name === TrackErrors.FIREFOX_EXTENSION_NEEDED) {
                     APP.UI.showExtensionRequiredDialog(
                 this.videoSwitchInProgress = false;
                 JitsiMeetJS.analytics.sendEvent(
                     'conference.sharingDesktop.stop');
-                console.log('sharing local video');
+                logger.log('sharing local video');
             }).catch((err) => {
                 this.useVideoStream(null);
                 this.videoSwitchInProgress = false;
-                console.error('failed to share local video', err);
+                logger.error('failed to share local video', err);
             });
         }
     },
             if (user.isHidden())
                 return;
 
-            console.log('USER %s connnected', id, user);
+            logger.log('USER %s connnected', id, user);
             APP.API.notifyUserJoined(id);
             APP.UI.addUser(user);
 
             APP.UI.updateUserRole(user);
         });
         room.on(ConferenceEvents.USER_LEFT, (id, user) => {
-            console.log('USER %s LEFT', id, user);
+            logger.log('USER %s LEFT', id, user);
             APP.API.notifyUserLeft(id);
             APP.UI.removeUser(id, user.getDisplayName());
             APP.UI.onSharedVideoStop(id);
 
         room.on(ConferenceEvents.USER_ROLE_CHANGED, (id, role) => {
             if (this.isLocalId(id)) {
-                console.info(`My role changed, new role: ${role}`);
+                logger.info(`My role changed, new role: ${role}`);
                 if (this.isModerator !== room.isModerator()) {
                     this.isModerator = room.isModerator();
                     APP.UI.updateLocalRole(room.isModerator());
             {
                 this.audioLevelsMap[id] = lvl;
                 if(config.debugAudioLevels)
-                    console.log("AudioLevel:" + id + "/" + lvl);
+                    logger.log("AudioLevel:" + id + "/" + lvl);
             }
 
             APP.UI.setAudioLevel(id, lvl);
         });
 
         room.on(ConferenceEvents.RECORDER_STATE_CHANGED, (status, error) => {
-            console.log("Received recorder status change: ", status, error);
+            logger.log("Received recorder status change: ", status, error);
             APP.UI.updateRecordingState(status);
         });
 
                 })
                 .then(([stream]) => {
                     this.useVideoStream(stream);
-                    console.log('switched local video device');
+                    logger.log('switched local video device');
                     APP.settings.setCameraDeviceId(cameraDeviceId, true);
                 })
                 .catch((err) => {
                 })
                 .then(([stream]) => {
                     this.useAudioStream(stream);
-                    console.log('switched local audio device');
+                    logger.log('switched local audio device');
                     APP.settings.setMicDeviceId(micDeviceId, true);
                 })
                 .catch((err) => {
                 JitsiMeetJS.analytics.sendEvent(
                     'settings.changeDevice.audioOut');
                 APP.settings.setAudioOutputDeviceId(audioOutputDeviceId)
-                    .then(() => console.log('changed audio output device'))
+                    .then(() => logger.log('changed audio output device'))
                     .catch((err) => {
-                        console.warn('Failed to change audio output device. ' +
+                        logger.warn('Failed to change audio output device. ' +
                             'Default or previously set audio output device ' +
                             'will be used instead.', err);
                         APP.UI.setSelectedAudioOutputFromSettings();

connection.js

 /* global APP, JitsiMeetJS, config */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 import AuthHandler from './modules/UI/authentication/AuthHandler';
 import jitsiLocalStorage from './modules/util/JitsiLocalStorage';
 
 
         function handleConnectionFailed(err) {
             unsubscribe();
-            console.error("CONNECTION FAILED:", err);
+            logger.error("CONNECTION FAILED:", err);
             reject(err);
         }
 

modules/API/API.js

 /* global APP, getConfigParamsFromUrl */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 /**
  * Implements API class that communicates with external api class
  * and provides interface to access Jitsi Meet features by external
     switch (message.type) {
         case "eventStatus":
             if(!message.name || !message.value) {
-                console.warn("Unknown system message format", message);
+                logger.warn("Unknown system message format", message);
                 break;
             }
             events[message.name] = message.value;
             break;
         default:
-            console.warn("Unknown system message type", message);
+            logger.warn("Unknown system message type", message);
     }
 }
 

modules/API/external/external_api.js

+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 /**
  * Implements API class that embeds Jitsi Meet in external applications.
  */
  */
 function changeEventStatus(postis, event, status) {
     if(!(event in events)) {
-        console.error("Not supported event name.");
+        logger.error("Not supported event name.");
         return;
     }
     sendMessage(postis, {
  */
 JitsiMeetExternalAPI.prototype.executeCommand = function(name, argumentsList) {
     if(!(name in commands)) {
-        console.error("Not supported command name.");
+        logger.error("Not supported command name.");
         return;
     }
     var argumentsArray = argumentsList;
  */
 JitsiMeetExternalAPI.prototype.addEventListener = function(event, listener) {
     if(!(event in events)) {
-        console.error("Not supported event name.");
+        logger.error("Not supported event name.");
         return;
     }
     // We cannot remove listeners from postis that's why we are handling the
 JitsiMeetExternalAPI.prototype.removeEventListener = function(event) {
     if(!(event in this.eventHandlers))
     {
-        console.error("The event " + event + " is not registered.");
+        logger.error("The event " + event + " is not registered.");
         return;
     }
     delete this.eventHandlers[event];

modules/FollowMe.js

  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 import UIEvents from '../service/UI/UIEvents';
 import VideoLayout from './UI/videolayout/VideoLayout';
 
         if (!this._conference.isParticipantModerator(id))
         {
-            console.warn('Received follow-me command ' +
+            logger.warn('Received follow-me command ' +
                 'not from moderator');
             return;
         }

modules/UI/UI.js

 /* global APP, JitsiMeetJS, $, config, interfaceConfig, toastr */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 var UI = {};
 
 import Chat from "./side_pannels/chat/Chat";
         VideoLayout.changeLocalVideo(track);
         break;
     default:
-        console.error("Unknown stream type: " + track.getType());
+        logger.error("Unknown stream type: " + track.getType());
         break;
     }
 };
     if (etherpadManager || !config.etherpad_base || !name) {
         return;
     }
-    console.log('Etherpad is enabled');
+    logger.log('Etherpad is enabled');
     etherpadManager
         = new EtherpadManager(config.etherpad_base, name, eventEmitter);
     Toolbar.showEtherpadButton();
 
 // FIXME check if someone user this
 UI.showLoginPopup = function(callback) {
-    console.log('password is required');
+    logger.log('password is required');
 
     let message = (
         `<input name="username" type="text"

modules/UI/authentication/AuthHandler.js

 /* global APP, config, JitsiMeetJS, Promise */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 import LoginDialog from './LoginDialog';
 import UIUtil from '../util/UIUtil';
 function initJWTTokenListener(room) {
     var listener = function (event) {
         if (externalAuthWindow !== event.source) {
-            console.warn("Ignored message not coming " +
+            logger.warn("Ignored message not coming " +
                 "from external authnetication window");
             return;
         }
         if (event.data && event.data.jwtToken) {
             config.token = event.data.jwtToken;
-            console.info("Received JWT token:", config.token);
+            logger.info("Received JWT token:", config.token);
             var roomName = room.getName();
             openConnection({retry: false, roomName: roomName })
                 .then(function (connection) {
                         // to upgrade user's role
                         room.room.moderator.authenticate()
                             .then(function () {
-                                console.info("User role upgrade done !");
+                                logger.info("User role upgrade done !");
                                 unregister();
                             }).catch(function (err, errCode) {
-                                console.error(
+                                logger.error(
                                     "Authentication failed: ", err, errCode);
                                 unregister();
                             }
                     }).catch(function (error, code) {
                         unregister();
                         connection.disconnect();
-                        console.error(
+                        logger.error(
                             'Authentication failed on the new connection',
                             error, code);
                     });
                 }, function (err) {
                     unregister();
-                    console.error("Failed to open new connection", err);
+                    logger.error("Failed to open new connection", err);
                 });
         }
     };
             }).catch(function (error, code) {
                 connection.disconnect();
 
-                console.error('Auth on the fly failed', error);
+                logger.error('Auth on the fly failed', error);
 
                 loginDialog.displayError(
                     'connection.GET_SESSION_ID_ERROR', {code: code});

modules/UI/avatar/Avatar.js

  */
 
 /* global MD5, config, interfaceConfig, APP */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 let users = {};
 
         let random = !avatarId || avatarId.indexOf('@') < 0;
 
         if (!avatarId) {
-            console.warn(
+            logger.warn(
                 `No avatar stored yet for ${userId} - using ID as avatar ID`);
             avatarId = userId;
         }

modules/UI/invite/Invite.js

 /* global JitsiMeetJS, APP */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 import InviteDialogView from './InviteDialogView';
 import createRoomLocker from './RoomLocker';
         this.conference.on(ConferenceEvents.LOCK_STATE_CHANGED,
             (locked, error) => {
 
-            console.log("Received channel password lock change: ", locked,
+            logger.log("Received channel password lock change: ", locked,
                 error);
 
             if (!locked) {

modules/UI/invite/InviteDialogView.js

 /* global $, APP, JitsiMeetJS */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 /**
  * Substate for password
                     this.blur();
                 }
                 catch (err) {
-                    console.error('error when copy the text');
+                    logger.error('error when copy the text');
                 }
             }
         });

modules/UI/invite/RoomLocker.js

 /* global APP, JitsiMeetJS */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 import RequirePasswordDialog from './RequirePasswordDialog';
 
 /**
  * because server doesn't support that.
  */
 function notifyPasswordNotSupported () {
-    console.warn('room passwords not supported');
+    logger.warn('room passwords not supported');
     APP.UI.messageHandler.showError(
         "dialog.warning", "dialog.passwordNotSupported");
 }
  * @param {Error} err error
  */
 function notifyPasswordFailed(err) {
-    console.warn('setting password failed', err);
+    logger.warn('setting password failed', err);
     APP.UI.messageHandler.showError(
         "dialog.lockTitle", "dialog.lockMessage");
 }
                 if (!password)
                     lockedElsewhere = false;
             }).catch(function (err) {
-                console.error(err);
+                logger.error(err);
                 if (err === ConferenceErrors.PASSWORD_NOT_SUPPORTED) {
                     notifyPasswordNotSupported();
                 } else {
                     // pass stays between attempts
                     password = null;
                     if (reason !== APP.UI.messageHandler.CANCEL)
-                        console.error(reason);
+                        logger.error(reason);
                 }
             );
         },

modules/UI/recording/Recording.js

  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 import UIEvents from "../../../service/UI/UIEvents";
 import UIUtil from '../util/UIUtil';
 import VideoLayout from '../videolayout/VideoLayout';
                         }).catch(
                             reason => {
                                 if (reason !== APP.UI.messageHandler.CANCEL)
-                                    console.error(reason);
+                                    logger.error(reason);
                                 else
                                     JitsiMeetJS.analytics.sendEvent(
                                         'recording.canceled');
                         }).catch(
                             reason => {
                                 if (reason !== APP.UI.messageHandler.CANCEL)
-                                    console.error(reason);
+                                    logger.error(reason);
                                 else
                                     JitsiMeetJS.analytics.sendEvent(
                                         'recording.canceled');

modules/UI/reload_overlay/PageReloadOverlay.js

 /* global $, APP, AJS */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 import Overlay from '../overlay/Overlay';
 
             }
         }.bind(this), 1000);
 
-        console.info(
+        logger.info(
             "The conference will be reloaded after "
                 + this.timeLeft + " seconds.");
     }

modules/UI/shared_video/SharedVideo.js

 /* global $, APP, YT, onPlayerReady, onPlayerStateChange, onPlayerError,
 JitsiMeetJS */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 import UIUtil from '../util/UIUtil';
 import UIEvents from '../../../service/UI/UIEvents';
                         JitsiMeetJS.analytics.sendEvent('sharedvideo.started');
                     },
                     err => {
-                        console.log('SHARED VIDEO CANCELED', err);
+                        logger.log('SHARED VIDEO CANCELED', err);
                         JitsiMeetJS.analytics.sendEvent('sharedvideo.canceled');
                     }
             );
         };
 
         window.onPlayerError = function(event) {
-            console.error("Error in the player:", event.data);
+            logger.error("Error in the player:", event.data);
             // store the error player, so we can remove it
             self.errorInPlayer = event.target;
         };
                 && player.getVolume() != attributes.volume) {
 
                 player.setVolume(attributes.volume);
-                console.info("Player change of volume:" + attributes.volume);
+                logger.info("Player change of volume:" + attributes.volume);
                 this.showSharedVideoMutedPopup(false);
             }
 
     processTime (player, attributes, forceSeek)
     {
         if(forceSeek) {
-            console.info("Player seekTo:", attributes.time);
+            logger.info("Player seekTo:", attributes.time);
             player.seekTo(attributes.time);
             return;
         }
         // if we drift more than the interval for checking
         // sync, the interval is in milliseconds
         if(diff > updateInterval/1000) {
-            console.info("Player seekTo:", attributes.time,
+            logger.info("Player seekTo:", attributes.time,
                 " current time is:", currentPosition, " diff:", diff);
             player.seekTo(attributes.time);
         }
  * Removes RemoteVideo from the page.
  */
 SharedVideoThumb.prototype.remove = function () {
-    console.log("Remove shared video thumb", this.id);
+    logger.log("Remove shared video thumb", this.id);
 
     // Make sure that the large video is updated if are removing its
     // corresponding small video.
  */
 SharedVideoThumb.prototype.setDisplayName = function(displayName) {
     if (!this.container) {
-        console.warn( "Unable to set displayName - " + this.videoSpanId +
+        logger.warn( "Unable to set displayName - " + this.videoSpanId +
             " does not exist");
         return;
     }

modules/UI/side_pannels/contactlist/ContactListView.js

 /* global $, APP, interfaceConfig */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 import Avatar from '../../avatar/Avatar';
 import UIEvents from '../../../../service/UI/UIEvents';
 import UIUtil from '../../util/UIUtil';
     numberOfContacts += delta;
 
     if (numberOfContacts <= 0) {
-        console.error("Invalid number of participants: " + numberOfContacts);
+        logger.error("Invalid number of participants: " + numberOfContacts);
         return;
     }
 

modules/UI/util/MessageHandler.js

 /* global $, APP, toastr */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 import UIUtil from './UIUtil';
 import jitsiLocalStorage from '../../util/JitsiLocalStorage';
 function dontShowAgainSubmitFunctionWrapper(options, submitFunction) {
     if(isDontShowAgainEnabled(options)) {
         return (...args) => {
-            console.debug(args, options.buttonValues);
+            logger.debug(args, options.buttonValues);
             //args[1] is the value associated with the pressed button
             if(!options.buttonValues || options.buttonValues.length === 0
                 || options.buttonValues.indexOf(args[1]) !== -1 ) {
      */
     openReportDialog: function(titleKey, msgKey, error) {
         this.openMessageDialog(titleKey, msgKey);
-        console.log(error);
+        logger.log(error);
         //FIXME send the error to the server
     },
 

modules/UI/videolayout/LargeVideoManager.js

 /* global $, APP, interfaceConfig */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 import Avatar from "../avatar/Avatar";
 import {createDeferred} from '../../util/helpers';
             const { id, stream, videoType, resolve } = this.newStreamData;
             this.newStreamData = null;
 
-            console.info("hover in %s", id);
+            logger.info("hover in %s", id);
             this.state = videoType;
             const container = this.getContainer(this.state);
             container.setStream(stream, videoType);

modules/UI/videolayout/LocalVideo.js

 /* global $, config, interfaceConfig, APP, JitsiMeetJS */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 import ConnectionIndicator from "./ConnectionIndicator";
 import UIUtil from "../util/UIUtil";
 import UIEvents from "../../../service/UI/UIEvents";
  */
 LocalVideo.prototype.setDisplayName = function(displayName) {
     if (!this.container) {
-        console.warn(
+        logger.warn(
                 "Unable to set displayName - " + this.videoSpanId +
                 " does not exist");
         return;

modules/UI/videolayout/RemoteVideo.js

 /* global $, APP, interfaceConfig */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 import ConnectionIndicator from './ConnectionIndicator';
 
         }
     }).catch(e => {
         //currently shouldn't be called
-        console.error(e);
+        logger.error(e);
     });
 
     this.popover.forceHide();
         this.wasVideoPlayed = false;
     }
 
-    console.info((isVideo ? "Video" : "Audio") +
+    logger.info((isVideo ? "Video" : "Audio") +
                  " removed " + this.id, select);
 
     // when removing only the video element and we are on stage
         }
     }
 
-    console.debug(this.id + " thumbnail is connection active ? " + isActive);
+    logger.debug(this.id + " thumbnail is connection active ? " + isActive);
 
     // Update 'mutedWhileDisconnected' flag
     this._figureOutMutedWhileDisconnected(!isActive);
  * Removes RemoteVideo from the page.
  */
 RemoteVideo.prototype.remove = function () {
-    console.log("Remove thumbnail", this.id);
+    logger.log("Remove thumbnail", this.id);
     this.removeConnectionIndicator();
     // Make sure that the large video is updated if are removing its
     // corresponding small video.
  */
 RemoteVideo.prototype.setDisplayName = function(displayName) {
     if (!this.container) {
-        console.warn( "Unable to set displayName - " + this.videoSpanId +
+        logger.warn( "Unable to set displayName - " + this.videoSpanId +
                 " does not exist");
         return;
     }

modules/UI/videolayout/SmallVideo.js

 /* global $, JitsiMeetJS, interfaceConfig */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 import Avatar from "../avatar/Avatar";
 import UIUtil from "../util/UIUtil";
 import UIEvents from "../../../service/UI/UIEvents";
             // Init avatar
             this.avatarChanged(Avatar.getAvatarUrl(this.id));
         } else {
-            console.error("Unable to init avatar - no id", this);
+            logger.error("Unable to init avatar - no id", this);
             return;
         }
     }
         return;
 
     if (!this.container) {
-        console.warn( "Unable to set dominant speaker indicator - "
+        logger.warn( "Unable to set dominant speaker indicator - "
             + this.videoSpanId + " does not exist");
         return;
     }
  */
 SmallVideo.prototype.showRaisedHandIndicator = function (show) {
     if (!this.container) {
-        console.warn( "Unable to raised hand indication - "
+        logger.warn( "Unable to raised hand indication - "
             + this.videoSpanId + " does not exist");
         return;
     }

modules/UI/videolayout/VideoLayout.js

 /* global config, APP, $, interfaceConfig */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 import FilmStrip from "./FilmStrip";
 import UIEvents from "../../../service/UI/UIEvents";
         if (lastVisible.length) {
             let id = getPeerContainerResourceId(lastVisible[0]);
             if (remoteVideos[id]) {
-                console.info("electLastVisibleVideo: " + id);
+                logger.info("electLastVisibleVideo: " + id);
                 return id;
             }
             // The RemoteVideo was removed (but the DOM elements may still
             // exist).
         }
 
-        console.info("Last visible video no longer exists");
+        logger.info("Last visible video no longer exists");
         thumbs = FilmStrip.getThumbs().remoteThumbs;
         if (thumbs.length) {
             let id = getPeerContainerResourceId(thumbs[0]);
             if (remoteVideos[id]) {
-                console.info("electLastVisibleVideo: " + id);
+                logger.info("electLastVisibleVideo: " + id);
                 return id;
             }
             // The RemoteVideo was removed (but the DOM elements may
         }
 
         // Go with local video
-        console.info("Fallback to local video...");
+        logger.info("Fallback to local video...");
 
         let id = APP.conference.getMyUserId();
-        console.info("electLastVisibleVideo: " + id);
+        logger.info("electLastVisibleVideo: " + id);
 
         return id;
     },
     // FIXME: what does this do???
     remoteVideoActive(videoElement, resourceJid) {
 
-        console.info(resourceJid + " video is now active", videoElement);
+        logger.info(resourceJid + " video is now active", videoElement);
 
         VideoLayout.resizeThumbnails(
             false, false, function() {$(videoElement).show();});
             if (resourceJid &&
                 lastNEndpoints.indexOf(resourceJid) < 0 &&
                 localLastNSet.indexOf(resourceJid) < 0) {
-                console.log("Remove from last N", resourceJid);
+                logger.log("Remove from last N", resourceJid);
                 if (smallVideo)
                     smallVideo.showPeerContainer('hide');
                 else if (!APP.conference.isLocalId(resourceJid))
-                    console.error("No remote video for: " + resourceJid);
+                    logger.error("No remote video for: " + resourceJid);
                 isReceived = false;
             } else if (resourceJid &&
                 //TOFIX: smallVideo may be undefined
                 if (smallVideo)
                     smallVideo.showPeerContainer('avatar');
                 else if (!APP.conference.isLocalId(resourceJid))
-                    console.error("No remote video for: " + resourceJid);
+                    logger.error("No remote video for: " + resourceJid);
                 isReceived = false;
             }
 
                     remoteVideo.showPeerContainer('show');
 
                 if (!remoteVideo.isVisible()) {
-                    console.log("Add to last N", resourceJid);
+                    logger.log("Add to last N", resourceJid);
 
                     remoteVideo.addRemoteStreamElement(remoteVideo.videoStream);
 
     removeParticipantContainer (id) {
         // Unlock large video
         if (pinnedId === id) {
-            console.info("Focused video owner has left the conference");
+            logger.info("Focused video owner has left the conference");
             pinnedId = null;
         }
 
         if (currentDominantSpeaker === id) {
-            console.info("Dominant speaker has left the conference");
+            logger.info("Dominant speaker has left the conference");
             currentDominantSpeaker = null;
         }
 
         var remoteVideo = remoteVideos[id];
         if (remoteVideo) {
             // Remove remote video
-            console.info("Removing remote video: " + id);
+            logger.info("Removing remote video: " + id);
             delete remoteVideos[id];
             remoteVideo.remove();
         } else {
-            console.warn("No remote video for " + id);
+            logger.warn("No remote video for " + id);
         }
 
         VideoLayout.resizeThumbnails();
             return;
         }
 
-        console.info("Peer video type changed: ", id, newVideoType);
+        logger.info("Peer video type changed: ", id, newVideoType);
 
         var smallVideo;
         if (APP.conference.isLocalId(id)) {
             if (!localVideoThumbnail) {
-                console.warn("Local video not ready yet");
+                logger.warn("Local video not ready yet");
                 return;
             }
             smallVideo = localVideoThumbnail;
             if (remoteVideo) {
                 remoteVideo.connectionIndicator.showMore();
             } else {
-                console.info("Error - no remote video for id: " + id);
+                logger.info("Error - no remote video for id: " + id);
             }
         }
     },
         if (smallVideo) {
             smallVideo.avatarChanged(avatarUrl);
         } else {
-            console.warn(
+            logger.warn(
                 "Missed avatar update - no small video yet for " + id
             );
         }

modules/URL/ConferenceUrl.js

-/* global console */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 import { redirect } from '../util/helpers';
 
          */
         this.inviteURL
             = location.protocol + "//" + location.host + location.pathname;
-        console.info("Stored original conference URL: " + this.originalURL);
-        console.info("Conference URL for invites: " + this.inviteURL);
+        logger.info("Stored original conference URL: " + this.originalURL);
+        logger.info("Conference URL for invites: " + this.inviteURL);
     }
     /**
      * Obtains the conference invite URL.
      * Reloads the conference using original URL with all of the parameters.
      */
     reload() {
-        console.info("Reloading the conference using URL: " + this.originalURL);
+        logger.info("Reloading the conference using URL: " + this.originalURL);
         redirect(this.originalURL);
     }
 }

modules/config/BoshAddressChoice.js

+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 var JSSHA = require('jssha');
 
 module.exports = {
         var attemptFirstAddress;
 
         config.bosh = config.boshList[idx];
-        console.log('Setting config.bosh to ' + config.bosh +
+        logger.log('Setting config.bosh to ' + config.bosh +
             ' (idx=' + idx + ')');
 
         if (config.boshAttemptFirstList &&
 
             if (attemptFirstAddress != config.bosh) {
                 config.boshAttemptFirst = attemptFirstAddress;
-                console.log('Setting config.boshAttemptFirst=' +
+                logger.log('Setting config.boshAttemptFirst=' +
                     attemptFirstAddress + ' (idx=' + idx + ')');
             } else {
-                console.log('Not setting boshAttemptFirst, address matches.');
+                logger.log('Not setting boshAttemptFirst, address matches.');
             }
         }
     }

modules/config/HttpConfigFetch.js

 /* global $, config, interfaceConfig */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 var configUtil = require('./Util');
 
      * @param complete
      */
     obtainConfig: function (endpoint, roomName, complete) {
-        console.info(
+        logger.info(
             "Send config request to " + endpoint + " for room: " + roomName);
 
 
                 data: JSON.stringify({"roomName": roomName}),
                 dataType: 'json',
                 error: function(jqXHR, textStatus, errorThrown) {
-                    console.error("Get config error: ", jqXHR, errorThrown);
+                    logger.error("Get config error: ", jqXHR, errorThrown);
                     var error = "Get config response status: " + textStatus;
                     complete(false, error);
                 },
                         complete(true);
                         return;
                     } catch (exception) {
-                        console.error("Parse config error: ", exception);
+                        logger.error("Parse config error: ", exception);
                         complete(false, exception);
                     }
                 }

modules/config/URLProcessor.js

 /* global config, interfaceConfig, getConfigParamsFromUrl */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 var configUtils = require('./Util');
 var params = {};
 
         };
         for (var key in params) {
             if (typeof key !== "string") {
-                console.warn("Invalid config key: ", key);
+                logger.warn("Invalid config key: ", key);
                 continue;
             }
             var confObj = null, confKey;

modules/config/Util.js

+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 var ConfigUtil = {
     /**
      * Method overrides JSON properties in <tt>config</tt> and
             for (key in newConfig[configRoot]) {
                 value = newConfig[configRoot][key];
                 if (confObj[key] && typeof confObj[key] !== typeof value) {
-                    console.log("Overriding a " + configRoot +
+                    logger.log("Overriding a " + configRoot +
                         " property with a property of different type.");
                 }
-                console.info("Overriding " + key + " with: " + value);
+                logger.info("Overriding " + key + " with: " + value);
                 confObj[key] = value;
             }
         }

modules/settings/Settings.js

 /* global JitsiMeetJS */
+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 import UIUtil from '../UI/util/UIUtil';
 import jitsiLocalStorage from '../util/JitsiLocalStorage';
 
     JitsiMeetJS.mediaDevices.getAudioOutputDevice()) {
     JitsiMeetJS.mediaDevices.setAudioOutputDevice(audioOutputDeviceId)
         .catch((ex) => {
-            console.warn('Failed to set audio output device from local ' +
+            logger.warn('Failed to set audio output device from local ' +
                 'storage. Default audio output device will be used' +
                 'instead.', ex);
         });

modules/util/helpers.js

+const logger = require("jitsi-meet-logger").getLogger(__filename);
+
 /**
  * Create deferred object.
  * @returns {{promise, resolve, reject}}
  * @param msg {string} [optional] the message printed in addition to the error
  */
 export function reportError (e, msg = "") {
-    console.error(msg, e);
+    logger.error(msg, e);
     if(window.onerror)
         window.onerror(msg, null, null,
             null, e);

package.json

     "haste-resolver-webpack-plugin": "^0.2.2",
     "i18next": "3.4.4",
     "i18next-xhr-backend": "1.1.0",
+    "jitsi-meet-logger": "jitsi/jitsi-meet-logger",
     "jquery": "~2.1.1",
     "jquery-contextmenu": "*",
     "jquery-i18next": "1.1.0",