redux-logger#createLogger JavaScript Examples

getMiddleware = () => {
    if (
        process.env.NODE_ENV === "production" ||
        process.env.NODE_ENV === "test"
    ) {
        return applyMiddleware(
            myRouterMiddleware,
            promiseMiddleware,
            localStorageMiddleware
        );
    } else {
        // Enable additional logging in non-production environments.
        return applyMiddleware(
            myRouterMiddleware,
            promiseMiddleware,
            localStorageMiddleware,
            createLogger()
        );
    }
}

initStore = (preloadedState = {}) => {

    return configureStore({
        reducer: persist,
        middleware: [createLogger(), routerMiddleware(history), chatMiddleware, botMiddleware, UnreadMessageMiddleware, thunk],
        preloadedState,
        devTools: devTools,

    })
}

configureStore = () => {
  const middlewares = Array.prototype.concat(
    [],
    [thunk, routerMiddleware(history)],
    process.env.NODE_ENV === 'development' ? [createLogger()] : []
  );

  const composeEnhancers =
    window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose;
  const enhancer = composeEnhancers(
    applyMiddleware(...middlewares),
    responsiveStoreEnhancer
  );

  store = createStore(resetEnhancer(createReducer(history)), enhancer);
  store.asyncReducers = {};

  return {
    store,
    history
  };
}

configureStore = (initialState) => {
  const middleware = [];
  // const enhancers = [];

  // THUNK
  middleware.push(thunk);

  // Logging Middleware
  const logger = createLogger({
    level: 'info',
    collapsed: true
  });
  middleware.push(logger);

  const composeEnhancers = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose;

  store = createStore(rootReducer, initialState, composeEnhancers(
    applyMiddleware(...middleware)
  ));

}

function createMiddlewares() {
  let middlewares = [thunk];
  if ((process.env.NODE_ENV === "development" || process.env.NODE_ENV === "testing") && typeof window !== "undefined") {
    middlewares.push(
      createLogger({
        level: "info",
        collapsed: true
      })
    );
  }

  return middlewares;
}

configureStore = (preloadedState) => {
  const store = createStore(
    rootReducer,
    preloadedState,
    compose(applyMiddleware(thunk, api, createLogger()), DevTools.instrument())
  )

  if (module.hot) {
    // Enable Webpack hot module replacement for reducers
    module.hot.accept('../reducers', () => {
      store.replaceReducer(rootReducer)
    })
  }

  return store
}

function composeMiddleware() {
  if (getConfig().ENVIRONMENT === 'development') {
    const loggerMiddleware = createLogger({
      collapsed: true,
    });
    return composeWithDevTools(applyMiddleware(thunkMiddleware, sagaMiddleware, loggerMiddleware));
  }

  return compose(applyMiddleware(thunkMiddleware, sagaMiddleware));
}

// Fetch config.js on server and merge with default config
fetch('//' + window.location.host + '/config.json')
  .then(response => response.json())
  .catch(err => console.error(err))
  .then(res => {
    if (res) {
      setConfig({ ...res });
      // Enable redux logger if devMode is true
      if(res.devMode) {
        addMiddleware(createLogger());
      }
    }
  });

getMiddleware = () => {
  // we only collect code coverage in non-production environment
  // thus "IF" branch will never get hit
  /* istanbul ignore if */
  if (process.env.NODE_ENV === 'production') {
    return applyMiddleware(
      myRouterMiddleware,
      promiseMiddleware,
      localStorageMiddleware
    )
  } else {
    // Enable additional logging in non-production environments.
    return applyMiddleware(
      myRouterMiddleware,
      promiseMiddleware,
      localStorageMiddleware,
      createLogger()
    )
  }
}

configureStore = (preloadedState) => {
  const store = createStore(
    rootReducer,
    preloadedState,
    compose(applyMiddleware(thunk, api, createLogger()), DevTools.instrument())
  );

  if (module.hot) {
    // Enable Webpack hot module replacement for reducers
    module.hot.accept("../reducers", () => {
      const nextRootReducer = require("../reducers").default;
      store.replaceReducer(nextRootReducer);
    });
  }

  return store;
}

logger = createLogger()

logger = createLogger()

logger =  createLogger ()

logger = createLogger()

logger = createLogger()

logger = createLogger()

logger = createLogger()

logger = createLogger()

loggerMiddleware = createLogger()

function configureStore(initialState = {}, startSagas = false) {
  const sagaMiddleware = createSagaMiddleware();
  const middlewares = [sagaMiddleware];

  if (process.env.DEBUG_MODE === '1') {
    const logLevel = IS_CLIENT ? 'log' : false;
    const logger = createLogger({
      level: {
        prevState: logLevel,
        action: logLevel,
        nextState: logLevel
      },
      collapsed: (getState, action, logEntry) => !logEntry.error
    });

    middlewares.push(logger);
  }

  const store = createStore(
    rootReducer,
    initialState,
    compose(
      composeWithDevTools(applyMiddleware(...middlewares))
    )
  );

  // required for SSR fetching data
  store.runSaga = sagaMiddleware.run;
  store.close = () => store.dispatch(END);

  if (startSagas) {
    SagaManager.startSagas(sagaMiddleware);
  }

  // HMR for reducers and sagas
  /* eslint-disable global-require */
  if (process.env.NODE_ENV === 'development' && module.hot) {
    module.hot.accept('./rootReducer', () => {
      const nextRootReducer = require('./rootReducer').default;
      store.replaceReducer(nextRootReducer);
    });

    module.hot.accept('./sagas/SagaManager', () => {
      SagaManager.cancelSagas(store);
      require('./sagas/SagaManager').default.startSagas(sagaMiddleware);
    });
  }
  /* eslint-enable global-require */

  return store;
}

getMiddleware = () => {
  if (process.env.NODE_ENV === 'production') {
    return applyMiddleware(myRouterMiddleware, promiseMiddleware, localStorageMiddleware);
  } else {
    // Enable additional logging in non-production environments.
    return applyMiddleware(myRouterMiddleware, promiseMiddleware, localStorageMiddleware, createLogger())
  }
}

loggerMiddleware = createLogger()

logger = createLogger({
  collapsed: (getState, action, logEntry) => !logEntry.error,
})

configureStore = (preloadedState) => createStore(
  createRootReducer(history),
  preloadedState,
  compose(
    applyMiddleware(thunk, createLogger(), routerMiddleware(history)),
    DevTools.instrument()
  )
)

configureStore = (initialState?: stateType) => {
  // Redux Configuration
  const middleware = [];
  const enhancers = [];

  // Thunk Middleware
  middleware.push(thunk);

  // Logging Middleware
  const logger = createLogger({
    level: 'info',
    collapsed: true
  });

  // Skip redux logs in console during the tests
  if (process.env.NODE_ENV !== 'test') {
    middleware.push(logger);
  }

  // Router Middleware
  const router = routerMiddleware(history);
  middleware.push(router);

  // Redux DevTools Configuration
  const actionCreators = {
    ...actions,
    ...routerActions
  };
  // If Redux DevTools Extension is installed use it, otherwise use Redux compose
  /* eslint-disable no-underscore-dangle */
  const composeEnhancers = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__
    ? window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
        // Options: http://extension.remotedev.io/docs/API/Arguments.html
        actionCreators
      })
    : compose;
  /* eslint-enable no-underscore-dangle */

  // Apply Middleware & Compose Enhancers
  enhancers.push(applyMiddleware(...middleware));
  const enhancer = composeEnhancers(...enhancers);

  // Create Store
  const store = createStore(rootReducer, initialState, enhancer);

  return store;
}

loggerMiddleware = createLogger()

loggerMiddleware = createLogger()

logger = createLogger()

loggerMiddleware = createLogger()