How to use the redux-logger function in redux-logger

import { createStore, applyMiddleware, compose } from 'redux';
import thunk from 'redux-thunk';
import createLogger from 'redux-logger';
import { hashHistory } from 'react-router';
import { routerMiddleware, push } from 'react-router-redux';
import rootReducer from '../reducers';
import { CONSTANTS } from '../constants';
import promiseMiddleware from 'redux-promise-middleware';


const actionCreators = {
  // ...counterActions,
  push,
};

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

const router = routerMiddleware(hashHistory);


const enhancer = compose(
  applyMiddleware(thunk, router, logger, promiseMiddleware({
    promiseTypeSuffixes: ['LOADING', 'SUCCESS', 'ERROR']
  })),
  window.devToolsExtension ?
    window.devToolsExtension({ actionCreators }) :
    noop => noop
);

import { IndexRoute, Route } from 'react-router'
import Layout from './layout'
import Explorer from './containers/explorer'
import Query from './containers/query'
import Service from './components/service'
import InjectTapEventPlugin from 'react-tap-event-plugin'
import thunkMiddleware from 'redux-thunk'
import createLogger from 'redux-logger'

import rootReducer from './reducers'
import { createStore, compose, applyMiddleware } from 'redux'
import { Provider } from 'react-redux'
import { ReduxRouter, reduxReactRouter } from 'redux-router'
import { createHistory } from 'history'

const loggerMiddleware = createLogger()

const store = compose(
                applyMiddleware(thunkMiddleware, loggerMiddleware),
                reduxReactRouter({ createHistory })
              )(createStore)(rootReducer)

// Needed for onTouchTap
// Can go away when react 1.0 release
// Check this repo:
// https://github.com/zilverline/react-tap-event-plugin
InjectTapEventPlugin()

ReactDOM.render(
  <div>
    
      </div>

/* global __DEVTOOLS__ */
import { createStore, applyMiddleware, compose } from 'redux'
// reducer
import rootReducer from '../reducers'
// middleware
import thunkMiddleware from 'redux-thunk'
import promiseMiddleware from 'redux-promise'
import createLogger from 'redux-logger'

const loggerMiddleware = createLogger({
  level: 'info',
  collapsed: true
})

const enforceImmutableMiddleware = require('redux-immutable-state-invariant')()

let createStoreWithMiddleware

if (typeof __DEVTOOLS__ !== 'undefined' && __DEVTOOLS__) {
  const { persistState } = require('redux-devtools')
  const DevTools = require('../containers/DevTools')
  createStoreWithMiddleware = compose(
    applyMiddleware(
      enforceImmutableMiddleware,
      thunkMiddleware,
      promiseMiddleware,

export default function configureStore() {
  const pipeline = [
    applyMiddleware(
      promiseMiddleware(),
      thunkMiddleware,
      normalizeErrorMiddleware(),
      createLogger({
        predicate: () => process.env.NODE_ENV !== 'production'
      })
    )
  ];

  if (process.env.NODE_ENV !== 'production') {
    pipeline.push(DevTools.instrument());
  }

  const finalCreateStore = compose(...pipeline)(createStore);
  const store = finalCreateStore(rootReducer, { });

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

export const configureStore = (initialState = {}) => {
  const logger = createLogger();

  // TODO: don't add logger in production.
  const store = createStore(
    rootReducer,
    initialState,
    applyMiddleware(thunk, logger)
  );

  return store;
}

stateTransformer: (state) => state,
  actionTransformer: (action) => action,
  errorTransformer: (error) => error,
  diff: true,
  diffPredicate: (getState, action) => true,
});

let loggerCollapsedBool = createLogger({
  collapsed: true
});

let loggerCollapsedPredicate = createLogger({
  collapsed: (getAction, action) => true
});

let loggerColorsBoolean = createLogger({
  colors: {
    title: false,
    prevState: false,
    action: false,
    nextState: false,
    error: false
  }
});

let loggerColorsFunction = createLogger({
  colors: {
    title: (action) => '#000',
    prevState: (state) => '#000',
    action: (action) => '#000',
    nextState: (state) => '#000',
    error: (error, prevState) => '#000'

import { createStore, applyMiddleware } from "redux";
import rootReducer from "ducks";
import thunk from "redux-thunk";
import createLogger from "redux-logger";

const createStoreWithMiddlewares = applyMiddleware(
	thunk,
	createLogger()
)(createStore);

export default createStoreWithMiddlewares(rootReducer);

import createLogger                      from 'redux-logger'
import { compose }                       from 'redux'
import { applyMiddleware }               from 'redux'
import { combineReducers }               from 'redux'
import { createStore }                   from 'redux'
import { Provider }                      from 'react-redux'
import reduxCrud                         from './redux-crud'
import todosReducer                      from './todos/reducer'
import TodosIndex                        from './todos/Index.jsx'

const log           = bows('app')

const finalCreateStore = compose(
  applyMiddleware(
    thunkMiddleware,
    createLogger()
  )
)(createStore)

const allReducers = combineReducers({
  todos:           todosReducer,
})

const store = finalCreateStore(allReducers)

class AppComponent extends React.Component {
  render() {
    return (
      <section>
        
      </section>
    )

export default function getReduxMiddleware()
{
    const reduxLogger = createReduxLogger({
        level: 'info',
        stateTransformer: state => Im.Map(state).toJS()
    });

    return [thunk, reduxLogger];
}