logging: use individual, names loggers

React Native doesn't define __filename nor __dirname so do it artisanally. In
addition, this helps with centralizing the configuration passed to loggers.

react/features/always-on-top/AudioMuteButton.js

 import AbstractAudioMuteButton from '../base/toolbox/components/AbstractAudioMuteButton';
 import type { Props } from '../base/toolbox/components/AbstractButton';
 
+import logger from './logger';
+
 const { api } = window.alwaysOnTop;
-const logger = require('jitsi-meet-logger').getLogger(__filename);
 
 /**
  * The type of the React {@code Component} state of {@link AudioMuteButton}.

react/features/always-on-top/VideoMuteButton.js

 import AbstractVideoMuteButton from '../base/toolbox/components/AbstractVideoMuteButton';
 import type { Props } from '../base/toolbox/components/AbstractButton';
 
+import logger from './logger';
+
 const { api } = window.alwaysOnTop;
-const logger = require('jitsi-meet-logger').getLogger(__filename);
 
 /**
  * The type of the React {@code Component} state of {@link VideoMuteButton}.

react/features/always-on-top/logger.js

+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/always-on-top');

react/features/analytics/functions.js

 import { getJitsiMeetGlobalNS, loadScript } from '../base/util';
 
 import { AmplitudeHandler } from './handlers';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * Sends an event through the lib-jitsi-meet AnalyticsAdapter interface.

react/features/analytics/logger.js

+// @flow
+
+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/analytics');

react/features/app/actions.js

     getDefaultURL,
     getName
 } from './functions';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 declare var APP: Object;
 

react/features/app/components/App.native.js

 import '../../mobile/wake-lock';
 import '../../mobile/watchos';
 
+import logger from '../logger';
 import { AbstractApp } from './AbstractApp';
 import type { Props as AbstractAppProps } from './AbstractApp';
 
 declare var __DEV__;
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * The type of React {@code Component} props of {@link App}.
  */

react/features/app/logger.js

+// @flow
+
+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/app');

react/features/authentication/actions.js

     WAIT_FOR_OWNER
 } from './actionTypes';
 import { LoginDialog, WaitForOwnerDialog } from './components';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * Initiates authenticating and upgrading the role of the local participant to

react/features/authentication/logger.js

+// @flow
+
+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/authentication');

react/features/base/app/components/BaseApp.js

 import { PersistenceRegistry } from '../../storage';
 
 import { appWillMount, appWillUnmount } from '../actions';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from '../logger';
 
 declare var APP: Object;
 

react/features/base/app/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/app');

react/features/base/audio-only/actions.js

 // @flow
 
-import { getLogger } from 'jitsi-meet-logger';
-
 import UIEvents from '../../../../service/UI/UIEvents';
 
 import { createAudioOnlyChangedEvent, sendAnalytics } from '../../analytics';
 
 import { SET_AUDIO_ONLY } from './actionTypes';
+import logger from './logger';
 
 import type { Dispatch } from 'redux';
 
 declare var APP: Object;
-const logger = getLogger('features/base/audio-only');
-
 
 /**
  * Sets the audio-only flag for the current JitsiConference.

react/features/base/audio-only/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/audio-only');

react/features/base/conference/actions.js

 // @flow
 
+import type { Dispatch } from 'redux';
+
 import {
     createStartMutedConfigurationEvent,
     sendAnalytics
     getCurrentConference,
     sendLocalParticipant
 } from './functions';
-import type { Dispatch } from 'redux';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 declare var APP: Object;
 

react/features/base/conference/functions.js

     JITSI_CONFERENCE_URL_KEY,
     VIDEO_QUALITY_LEVELS
 } from './constants';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * Attach a set of local tracks to a conference.

react/features/base/conference/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/conference');

react/features/base/conference/middleware.js

     forEachConference,
     getCurrentConference
 } from './functions';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 declare var APP: Object;
 

react/features/base/config/functions.any.js

 
 import { _CONFIG_STORE_PREFIX } from './constants';
 import parseURLParams from './parseURLParams';
+import logger from './logger';
 
 declare var $: Object;
 
     'webrtcIceUdpDisable'
 ];
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 // XXX The functions getRoomName and parseURLParams are split out of
 // functions.js because they are bundled in both app.bundle and
 // do_external_connect, webpack 1 does not support tree shaking, and we don't

react/features/base/config/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/config');

react/features/base/connection/actions.native.js

     SET_LOCATION_URL
 } from './actionTypes';
 import { JITSI_CONNECTION_URL_KEY } from './constants';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * The error structure passed to the {@link connectionFailed} action.

react/features/base/connection/actions.web.js

 declare var APP: Object;
 declare var config: Object;
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 import { configureInitialDevices } from '../devices';
 
 export {
     connectionFailed,
     setLocationURL
 } from './actions.native';
+import logger from './logger';
 
 /**
  * Opens new connection.

react/features/base/connection/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/connection');

react/features/base/devices/actions.js

     getDevicesFromURL,
     setAudioOutputDeviceId
 } from './functions';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * Maps the WebRTC string for device type to the keys used to store configure,

react/features/base/devices/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/devices');

react/features/base/devices/middleware.js

 import { showNotification, showWarningNotification } from '../../notifications';
 import { updateSettings } from '../settings';
 import { setAudioOutputDeviceId } from './functions';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 const JITSI_TRACK_ERROR_TO_MESSAGE_KEY_MAP = {
     microphone: {

react/features/base/dialog/components/web/DialogWithTabs.js

 import { StatelessDialog } from '../../../dialog';
 import { translate } from '../../../i18n';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from '../../logger';
 
 /**
  * The type of the React {@code Component} props of {@link DialogWithTabs}.

react/features/base/dialog/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/dialog');

react/features/base/lastn/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/lastn');

react/features/base/lastn/middleware.js

 // @flow
 
-import { getLogger } from 'jitsi-meet-logger';
-
 import { SET_FILMSTRIP_ENABLED } from '../../filmstrip/actionTypes';
 import { SELECT_LARGE_VIDEO_PARTICIPANT } from '../../large-video/actionTypes';
 import { APP_STATE_CHANGED } from '../../mobile/background/actionTypes';
 import { getParticipantById } from '../participants/functions';
 import { MiddlewareRegistry } from '../redux';
 
+import logger from './logger';
+
 declare var APP: Object;
-const logger = getLogger('features/base/lastn');
 
 
 MiddlewareRegistry.register(store => next => action => {

react/features/base/lib-jitsi-meet/functions.js

 import { loadScript } from '../util';
 
 import JitsiMeetJS from './_';
+import logger from './logger';
 
 declare var APP: Object;
 
 const JitsiConferenceErrors = JitsiMeetJS.errors.conference;
 const JitsiConnectionErrors = JitsiMeetJS.errors.connection;
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * Creates a {@link JitsiLocalTrack} model from the given device id.
  *

react/features/base/lib-jitsi-meet/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/lib-jitsi-meet');

react/features/base/lib-jitsi-meet/native/RTCPeerConnection.js

 import { NativeModules } from 'react-native';
 import { RTCPeerConnection, RTCSessionDescription } from 'react-native-webrtc';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from '../logger';
 
 /* eslint-disable no-unused-vars */
 

react/features/base/logging/functions.js

+// @flow
+
+import { getLogger as _getLogger } from 'jitsi-meet-logger';
+
+/**
+ * Options for building the logger. We disable the callee info on RN because it's
+ * almost always empty anyway.
+ */
+const DEFAULT_OPTS = {};
+const DEFAULT_RN_OPTS = { disableCallerInfo: true };
+
+/**
+ * Gets a logger for the given id.
+ *
+ * @param {string} id - Name for the logger.
+ * @returns {Object} - The logger object.
+ */
+export function getLogger(id: string) {
+    const opts = navigator.product === 'ReactNative' ? DEFAULT_RN_OPTS : DEFAULT_OPTS;
+
+    return _getLogger(id, undefined, opts);
+}

react/features/base/logging/index.js

 export * from './actions';
 export * from './actionTypes';
+export * from './functions';
 
 import './middleware';
 import './reducer';

react/features/base/media/components/AbstractAudio.js

 
 import { Component } from 'react';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from '../logger';
 
 /**
  * Describes audio element interface used in the base/media feature for audio

react/features/base/media/components/native/Audio.js

 
 import Sound from 'react-native-sound';
 
-import AbstractAudio from '../AbstractAudio';
+import logger from '../../logger';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import AbstractAudio from '../AbstractAudio';
 
 /**
  * The React Native/mobile {@link Component} which is similar to Web's

react/features/base/media/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/media');

react/features/base/media/middleware.js

 
 import { setAudioMuted, setCameraFacingMode, setVideoMuted } from './actions';
 import { CAMERA_FACING_MODE, VIDEO_MUTISM_AUTHORITY } from './constants';
+import logger from './logger';
 import {
     _AUDIO_INITIAL_MEDIA_STATE,
     _VIDEO_INITIAL_MEDIA_STATE
 } from './reducer';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * Implements the entry point of the middleware of the feature base/media.
  *

react/features/base/react/components/web/MultiSelectAutocomplete.js

 import _debounce from 'lodash/debounce';
 import React, { Component } from 'react';
 
-import InlineDialogFailure from './InlineDialogFailure';
+import logger from '../../logger';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import InlineDialogFailure from './InlineDialogFailure';
 
 /**
  * The type of the React {@code Component} props of

react/features/base/react/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/react');

react/features/base/redux/StateListenerRegistry.js

 
 import type { Store } from 'redux';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * The type listener supported for registration with

react/features/base/redux/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/redux');

react/features/base/settings/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/settings');

react/features/base/settings/reducer.js

 import { assignIfDefined } from '../util';
 
 import { SETTINGS_UPDATED } from './actionTypes';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * The default/initial redux state of the feature {@code base/settings}.

react/features/base/sounds/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/sounds');

react/features/base/sounds/middleware.js

 import { MiddlewareRegistry } from '../redux';
 
 import { PLAY_SOUND, STOP_SOUND } from './actionTypes';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * Implements the entry point of the middleware of the feature base/media.

react/features/base/sounds/reducer.js

     REGISTER_SOUND,
     UNREGISTER_SOUND
 } from './actionTypes';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * The structure use by this reducer to describe a sound.

react/features/base/storage/PersistenceRegistry.js

 
 import md5 from 'js-md5';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * The name of the {@code localStorage} store where the app persists its values.

react/features/base/storage/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/storage');

react/features/base/testing/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/testing');

react/features/base/testing/middleware.js

-/* @flow */
-
-import Logger from 'jitsi-meet-logger';
-
-const logger = Logger.getLogger(__filename);
+// @flow
 
 import { MiddlewareRegistry } from '../redux';
 
 import { CONFERENCE_WILL_JOIN } from '../conference';
 import { JitsiConferenceEvents } from '../lib-jitsi-meet';
 import { setConnectionState } from './actions';
+import logger from './logger';
 
 /**
  * The Redux middleware of the feature testing.

react/features/base/tracks/actions.js

     TRACK_WILL_CREATE
 } from './actionTypes';
 import { createLocalTracksF, getLocalTrack, getLocalTracks, getTrackByJitsiTrack } from './functions';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * Requests the creating of the desired media type tracks. Desire is expressed

react/features/base/tracks/functions.js

     getUserSelectedMicDeviceId
 } from '../settings';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * Create local tracks of specific types.

react/features/base/tracks/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/tracks');

react/features/base/util/helpers.js

 // @flow
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * Creates a deferred object.

react/features/base/util/httpUtils.js

 import { timeoutPromise } from './timeoutPromise';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * The number of milliseconds before deciding that we need retry a fetch request.

react/features/base/util/logger.js

+// @flow
+
+import { getLogger } from '../logging/functions';
+
+export default getLogger('features/base/util');

react/features/base/util/uri.js

 // @flow
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * The app linking scheme.

react/features/blur/actions.js

 
 import { BLUR_DISABLED, BLUR_ENABLED } from './actionTypes';
 import { getBlurEffect } from './functions';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
 * Signals the local participant is switching between blurred or non blurred video.

react/features/blur/logger.js

+// @flow
+
+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/blur');

react/features/calendar-sync/actions.web.js

     SET_LOADING_CALENDAR_EVENTS
 } from './actionTypes';
 import { _getCalendarIntegration, isCalendarEnabled } from './functions';
+import logger from './logger';
 
 export * from './actions.any';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * Sets the initial state of calendar integration by loading third party APIs
  * and filling out any data that needs to be fetched.

react/features/calendar-sync/functions.native.js

 import { setCalendarAuthorization } from './actions';
 import { FETCH_END_DAYS, FETCH_START_DAYS } from './constants';
 import { _updateCalendarEntries } from './functions';
+import logger from './logger';
 
 export * from './functions.any';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * Adds a Jitsi link to a calendar entry.
  *

react/features/calendar-sync/functions.web.js

 import { microsoftCalendarApi } from './web/microsoftCalendar';
 import { toState } from '../base/redux';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * Determines whether the calendar feature is enabled by the web.

react/features/calendar-sync/logger.js

+// @flow
+
+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/calendar-sync');

react/features/conference/components/web/Conference.js

 } from '../../../toolbox';
 
 import { maybeShowSuboptimalExperienceNotification } from '../../functions';
+import logger from '../../logger';
 
 import Labels from './Labels';
 import { default as Notice } from './Notice';
     AbstractConference,
     abstractMapStateToProps
 } from '../AbstractConference';
-
 import type { AbstractProps } from '../AbstractConference';
 
 declare var APP: Object;
 declare var config: Object;
 declare var interfaceConfig: Object;
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * DOM events for when full screen mode has changed. Different browsers need
  * different vendor prefixes.

react/features/conference/logger.js

+// @flow
+
+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/conference');

react/features/desktop-picker/functions.js

 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * Begins a request to get available DesktopCapturerSources.

react/features/desktop-picker/logger.js

+// @flow
+
+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/desktop-picker');

react/features/device-selection/actions.js

 
 import { SET_DEVICE_SELECTION_POPUP_DATA } from './actionTypes';
 import { getDeviceSelectionDialogProps, processExternalDeviceRequest } from './functions';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * Opens a popup window with the device selection dialog in it.

react/features/device-selection/components/DeviceSelection.js

 import { translate } from '../../base/i18n';
 import JitsiMeetJS, { createLocalTrack } from '../../base/lib-jitsi-meet';
 
+import logger from '../logger';
+
 import AudioInputPreview from './AudioInputPreview';
 import AudioOutputPreview from './AudioOutputPreview';
 import DeviceSelector from './DeviceSelector';
 import VideoInputPreview from './VideoInputPreview';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * The type of the React {@code Component} props of {@link DeviceSelection}.
  */

react/features/device-selection/logger.js

+// @flow
+
+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/device-selection');

react/features/dropbox/functions.any.js

 export * from './functions';
 
 import { getDisplayName, getSpaceUsage } from './functions';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * Information related to the user's dropbox account.

react/features/dropbox/logger.js

+// @flow
+
+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/dropbox');

react/features/follow-me/logger.js

+// @flow
+
+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/follow-me');

react/features/follow-me/middleware.js

 import { setTileView } from '../video-layout';
 
 import { FOLLOW_ME_COMMAND } from './constants';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 declare var APP: Object;
 

react/features/invite/actions.js

     getDialInNumbers,
     invitePeopleAndChatRooms
 } from './functions';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * Creates a (redux) action to signal that a click/tap has been performed on

react/features/invite/components/add-people-dialog/AbstractAddPeopleDialog.js

     showNotification
 } from '../../../notifications';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from '../../logger';
 
 export type Props = {
 

react/features/invite/components/info-dialog/web/InfoDialog.js

     _getDefaultPhoneNumber,
     getDialInfoPageURL
 } from '../../../functions';
+import logger from '../../../logger';
 import DialInNumber from './DialInNumber';
 import PasswordForm from './PasswordForm';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * The type of the React {@code Component} props of {@link InfoDialog}.
  */

react/features/invite/functions.js

 import { isLocalParticipantModerator } from '../base/participants';
 import { doGetJSON, parseURIString } from '../base/util';
 
+import logger from './logger';
+
 declare var $: Function;
 declare var interfaceConfig: Object;
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * Sends an ajax request to check if the phone number can be called.
  *

react/features/invite/logger.js

+// @flow
+
+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/invite');

react/features/invite/middleware.any.js

     OUTGOING_CALL_RINGING_SOUND_ID,
     OUTGOING_CALL_START_SOUND_ID
 } from './constants';
+import logger from './logger';
 import { sounds } from './sounds';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 declare var interfaceConfig: Object;
 
 /**

react/features/invite/reducer.js

     UPDATE_DIAL_IN_NUMBERS_FAILED,
     UPDATE_DIAL_IN_NUMBERS_SUCCESS
 } from './actionTypes';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 const DEFAULT_STATE = {
     /**

react/features/local-recording/controller/RecordingController.js

 
 import { i18next } from '../../base/i18n';
 
+import logger from '../logger';
 import {
     FlacAdapter,
     OggAdapter,
 } from '../recording';
 import { sessionManager } from '../session';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * XMPP command for signaling the start of local recording to all clients.
  * Should be sent by the moderator only.

react/features/local-recording/logger.js

+// @flow
+
+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/local-recording');

react/features/local-recording/recording/AbstractAudioContextAdapter.js

+import logger from '../logger';
 import { RecordingAdapter } from './RecordingAdapter';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * Base class for {@code AudioContext}-based recording adapters.
  */

react/features/local-recording/recording/OggAdapter.js

+import logger from '../logger';
 import { RecordingAdapter } from './RecordingAdapter';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * Recording adapter that uses {@code MediaRecorder} (default browser encoding
  * with Opus codec).

react/features/local-recording/recording/WavAdapter.js

+import logger from '../logger';
 import { AbstractAudioContextAdapter } from './AbstractAudioContextAdapter';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 const WAV_BITS_PER_SAMPLE = 16;
 
 /**

react/features/local-recording/recording/flac/FlacAdapter.js

+import logger from '../../logger';
 import {
     DEBUG,
     MAIN_THREAD_FINISH,
 
 import { AbstractAudioContextAdapter } from '../AbstractAudioContextAdapter';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * Recording adapter that uses libflac.js in the background.
  */

react/features/local-recording/recording/flac/flacEncodeWorker.js

+import logger from '../../logger';
 import {
     MAIN_THREAD_FINISH,
     MAIN_THREAD_INIT,
     WORKER_LIBFLAC_READY
 } from './messageTypes';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * WebWorker that does FLAC encoding using libflac.js
  */

react/features/local-recording/session/SessionManager.js

 
 import jitsiLocalStorage from '../../../../modules/util/JitsiLocalStorage';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from '../logger';
 
 /**
  * Gets high precision system time.

react/features/mobile/audio-mode/logger.js

+// @flow
+
+import { getLogger } from '../../base/logging/functions';
+
+export default getLogger('features/mobile/audio-mode');

react/features/mobile/audio-mode/middleware.js

 import { MiddlewareRegistry } from '../../base/redux';
 
 import { _SET_AUDIOMODE_DEVICES, _SET_AUDIOMODE_SUBSCRIPTIONS } from './actionTypes';
+import logger from './logger';
 
 const { AudioMode } = NativeModules;
 const AudioModeEmitter = new NativeEventEmitter(AudioMode);
-const logger = require('jitsi-meet-logger').getLogger(__filename);
 
 /**
  * Middleware that captures conference actions and sets the correct audio mode

react/features/mobile/picture-in-picture/actions.js

 import { Platform } from '../../base/react';
 
 import { ENTER_PICTURE_IN_PICTURE } from './actionTypes';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 /**
  * Enters (or rather initiates entering) picture-in-picture.

react/features/mobile/picture-in-picture/logger.js

+// @flow
+
+import { getLogger } from '../../base/logging/functions';
+
+export default getLogger('features/mobile/pip');

react/features/mobile/watchos/logger.js

+// @flow
+
+import { getLogger } from '../../base/logging/functions';
+
+export default getLogger('features/mobile/watchos');

react/features/mobile/watchos/middleware.js

 
 import { setConferenceTimestamp, setSessionId, setWatchReachable } from './actions';
 import { CMD_HANG_UP, CMD_JOIN_CONFERENCE, CMD_SET_MUTED, MAX_RECENT_URLS } from './constants';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
+import logger from './logger';
 
 const watchOSEnabled = Platform.OS === 'ios';
 

react/features/overlay/components/AbstractPageReloadOverlay.js

     isFatalJitsiConnectionError
 } from '../../base/lib-jitsi-meet';
 
+import logger from '../logger';
 import ReloadButton from './web/ReloadButton';
 
 declare var APP: Object;
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * The type of the React {@code Component} props of
  * {@link AbstractPageReloadOverlay}.

react/features/overlay/logger.js

+// @flow
+
+import { getLogger } from '../base/logging/functions';
+
+export default getLogger('features/overlay');