O mecanismo de detecção e monitoramento de servidores foi descontinuado

Estou usando o Mongoose com meu aplicativo Node.js e esta é minha configuração:

mongoose.connect(process.env.MONGO_URI, {
   useNewUrlParser: true,
   useUnifiedTopology: true,
   useCreateIndex: true,
   useFindAndModify: false
}).then(()=>{
    console.log(`connection to database established`)
}).catch(err=>{
    console.log(`db error ${err.message}`);
    process.exit(-1)
})

mas no console ainda me dá o aviso:

Aviso de descontinuação: o mecanismo atual de descoberta e monitoramento do servidor foi descontinuado e será removido em uma versão futura. Para usar o novo mecanismo de descoberta e monitoramento do servidor, passe a opção {useUnifiedTopology: true} para o construtor MongoClient.

Qual é o problema? Eu não estava usando useUnifiedTopologyantes, mas agora aparece no console. Eu o adicionei à configuração, mas ele ainda me dá este aviso, por quê? Eu nem uso MongoClient.

Editar

Como Felipe Plets respondeu, havia um problema no Mongoose e eles consertaram esse bug em versões posteriores. Então você pode resolver o problema atualizando a versão do mangusto.

Atualizar

O Mongoose 5.7.1 foi lançado e parece corrigir o problema, portanto, a configuração da useUnifiedTopologyopção funciona conforme o esperado.

mongoose.connect(mongoConnectionString, {useNewUrlParser: true, useUnifiedTopology: true});

Resposta original

Eu estava enfrentando o mesmo problema e decidi mergulhar fundo no código do Mongoose: https://github.com/Automattic/mongoose/search?q=useUnifiedTopology&unscoped_q=useUnifiedTopology

Parece ser uma opção adicionada na versão 5.7 do Mongoose e ainda não bem documentada. Não consegui nem encontrá-lo mencionado no histórico da biblioteca https://github.com/Automattic/mongoose/blob/master/History.md

De acordo com um comentário no código:

• @param {Boolean} [options.useUnifiedTopology = false] False por padrão. Defina como truepara aceitar o conjunto de réplicas do driver MongoDB e o mecanismo de monitoramento de cluster fragmentado.

Também há um problema no projeto GitHub sobre este erro: https://github.com/Automattic/mongoose/issues/8156

No meu caso, não uso o Mongoose em um conjunto de réplicas ou cluster fragmentado, embora a opção deva ser falsa. Mas se for falso, ele reclama que a configuração deve ser verdadeira. Uma vez que é verdade, ainda não funciona, provavelmente porque meu banco de dados não executa em um conjunto de réplicas ou cluster fragmentado.

Fiz o downgrade para 5.6.13 e meu projeto voltou a funcionar bem. Portanto, a única opção que vejo agora é fazer o downgrade e aguardar a atualização para uma versão mais recente.

No mongoDB, eles descontinuaram o servidor atual e o pacote de monitoramento de mecanismo, então você precisa usar um novo pacote de monitoramento de servidor e mecanismo. Então você apenas usa

{useUnifiedTopology: true}

mongoose.connect("paste db link", {useUnifiedTopology: true, useNewUrlParser: true, useCreateIndex: true });

Isso resolveu meu problema.

 const url = 'mongodb://localhost:27017';

 const client = new MongoClient(url, {useUnifiedTopology: true});

Você pode tentar assíncrono esperar

const connectDB = async () => {
    try {
        await mongoose.connect(<database url>, {
            useNewUrlParser: true,
            useCreateIndex: true,
            useUnifiedTopology: true,
            useFindAndModify: false
        });
        console.log("MongoDB Conected")
    } catch (err) {
        console.error(err.message);
        process.exit(1);
    }
};

Use o seguinte código para evitar esse erro

MongoClient.connect(connectionString, {useNewUrlParser: true, useUnifiedTopology: true});

mongoose.connect('mongodb://localhost:27017/Tododb', { useNewUrlParser: true, useUnifiedTopology: true });

Irá remover os seguintes erros: -

(nó: 7481) Aviso de descontinuação: o analisador de string de URL atual está obsoleto e será removido em uma versão futura. Para usar o novo analisador, passe a opção {useNewUrlParser: true} para MongoClient.connect.

(nó: 7481) Aviso de descontinuação: o mecanismo atual de descoberta e monitoramento do servidor foi descontinuado e será removido em uma versão futura. Para usar o novo mecanismo de descoberta e monitoramento do servidor, passe a opção {useUnifiedTopology: true} para o construtor MongoClient.

Adicione a opção useUnifiedTopology e defina-a como true .

Defina outras 3 configurações das opções de mongoose.connect que lidarão com outros DeprecationWarning restantes .

Essa configuração funciona para mim!

const url = 'mongodb://localhost:27017/db_name';
mongoose.connect(
    url, 
    { 
        useNewUrlParser: true, 
        useUnifiedTopology: true,
        useCreateIndex: true,
        useFindAndModify: false
    }
)

Isso resolverá 4 Aviso de depreciação .

1. O analisador de string de URL atual está obsoleto e será removido em uma versão futura. Para usar o novo analisador, passe a opção {useNewUrlParser: true} para MongoClient.connect.
2. O mecanismo atual de detecção e monitoramento de servidores foi preterido e será removido em uma versão futura. Para usar o novo mecanismo de descoberta e monitoramento do servidor, passe a opção {useUnifiedTopology: true} para o construtor MongoClient.
3. Collection.ensureIndex está obsoleto. Em vez disso, use createIndexes.
4. Aviso de depreciação : Mongoose: findOneAndUpdate()e findOneAndDelete()sem a useFindAndModifyopção definida como false estão obsoletos. Consulte: https://mongoosejs.com/docs/deprecations.html#-findandmodify- .

Espero que ajude.

const mongoose = require("mongoose");

mongoose.connect('mongodb://localhost:27017/Edureka',{ useNewUrlParser: true, useUnifiedTopology: true }, (error)=> {
    const connectionStatus = !error ? 'Success': 'Error Connecting to database';
    console.log(connectionStatus);
});

Se o seu código incluir createConnetion por algum motivo (no meu caso, estou usando GridFsStorage), tente adicionar o seguinte ao seu código:

    options: {
        useUnifiedTopology: true,
    }

logo após o arquivo, assim:

    const storage = new GridFsStorage({
    url: mongodbUrl,
    file: (req, file) => {
        return new Promise((resolve, reject) => {
            crypto.randomBytes(16, (err, buf) => {
                if (err) {
                    return reject(err);
                }
                const filename = buf.toString('hex') + path.extname(file.originalname);
                const fileInfo = {
                    filename: filename,
                    bucketName: 'uploads'
                };
                resolve(fileInfo);
            });
        });
    },
    options: {
        useUnifiedTopology: true,
    }
})

Se seu caso for parecido com o meu, isso certamente resolverá seu problema. Saudações

Eu também estava enfrentando o mesmo problema:

1. Certifiquei-me de estar conectado ao mongoDB executando o seguinte no terminal:

   brew services start mongodb-community@4.2
   

   E eu obtive o resultado:

   Successfully started `mongodb-community`
   

Instruções para instalar o mongodb em
https://docs.mongodb.com/manual/tutorial/install-mongodb-on-os-x/ ou https://www.youtube.com/watch?v=IGIcrMTtjoU

2. Minha configuração foi a seguinte:

   mongoose.connect(config.mongo_uri, {
       useUnifiedTopology: true,
       useNewUrlParser: true})
       .then(() => console.log("Connected to Database"))
       .catch(err => console.error("An error has occured", err));
   

O que resolveu meu problema!

   const mongo = require('mongodb').MongoClient;

   mongo.connect(process.env.DATABASE,{useUnifiedTopology: true, 
   useNewUrlParser: true}, (err, db) => {
      if(err) {
    console.log('Database error: ' + err);
   } else {
    console.log('Successful database connection');
      auth(app, db)
      routes(app, db)

   app.listen(process.env.PORT || 3000, () => {
      console.log("Listening on port " + process.env.PORT);
    });  

}});

Configurando a conexão do mangusto useUnifiedTopology: opção verdadeira

  import mongoose from 'mongoose';

        const server = '127.0.0.1:27017'; // REPLACE WITH YOUR DB SERVER
        const database = 'DBName'; // REPLACE WITH YOUR DB NAME
        class Database {
          constructor() {
            this._connect();
          }
          _connect() {
            mongoose.Promise = global.Promise;
            // * Local DB SERVER *
            mongoose
              .connect(`mongodb://${server}/${database}`, {
                useNewUrlParser: true,
                useCreateIndex: true,
                useUnifiedTopology: true
              })
              .then(
                () => console.log(`mongoose version: ${mongoose.version}`),
                console.log('Database connection successful'),
              )
              .catch(err => console.error('Database connection error', err));   
          }
        }
        module.exports = new Database();

Isso funcionou para mim

Para quem está usando, MongoClienttente isto:

MongoClient.connect(connectionurl, 
  {useUnifiedTopology: true, useNewUrlParser: true},  callback() {

Para mangusto:

mongoose.connect(connectionurl, 
         {useUnifiedTopology: true, useNewUrlParser: true}).then(()=>{

Remover outras connectionOptions

Quero acrescentar a este tópico que também pode ter a ver com outras dependências.

Por exemplo, nada que eu atualizei ou configurei para NodeJS, MongoDB ou Mongoose era o problema - no entanto - connect-mongodb-sessiontinha sido atualizado e iniciando o lançamento do mesmo erro. A solução, neste caso, foi simplesmente reverter a versão de connect-mongodb-sessionde versão 2.3.0para 2.2.0.

Eu tinha os mesmos erros aparecendo a cada vez e isso funcionou para mim

mongoose.connect("mongodb://localhost:27017/${yourDB}", {
    useNewUrlParser: true,
    useUnifiedTopology: true

}, function (err) {
    if (err) {
        console.log(err)
    } else {
        console.log("Database connection successful")
    }
});

use esta linha, funcionou para mim

mongoose.set('useUnifiedTopology', true);

Se você estiver usando um servidor MongoDB, depois de usar conectar no relógio do cluster ao conectar e encontrar a URL, a URL será algo assim

<mongodb+srv://Rohan:<password>@cluster0-3kcv6.mongodb.net/<dbname>?retryWrites=true&w=majority>

Neste caso, não se esqueça de substituir a senha pela senha do banco de dados e nome do banco de dados e, em seguida, use

const client = new MongoClient(url,{useUnifiedTopology:true});

mongoose.connect("DBURL", {useUnifiedTopology: true, useNewUrlParser: true, useCreateIndex: true },(err)=>{
    if(!err){
         console.log('MongoDB connection sucess');
        }
    else{ 
        console.log('connection not established :' + JSON.stringify(err,undefined,2));
    }
});

É simples, remova o código que você usou e use o código abaixo:

const url = 'mongodb://localhost:27017';
var dbConn = mongodb.MongoClient.connect(url, {useUnifiedTopology: true});

se você usou typescript, adicione configuração ao MongoOptions

const MongoOptions: MongoClientOptions = {
  useNewUrlParser: true,
  useUnifiedTopology: true,
};

      const client = await MongoClient.connect(url, MongoOptions);

if you not used typescript  
const MongoOptions= {
  useNewUrlParser: true,
  useUnifiedTopology: true,
};

É importante executar o comando mongod e manter o servidor em execução. Caso contrário, você ainda verá esse erro.

Eu anexo a você meu código:

const mongodb = require('mongodb')
const MongoClient = mongodb.MongoClient

const connectionURL = 'mongodb://127.0.0.1:27017'
const databaseName = 'task-manager'

MongoClient.connect(connectionURL, {useNewUrlParser: true, useUnifiedTopology: true}, (error, client) => {
    if(error) {
        return console.log('Error connecting to the server.')
    }

    console.log('Succesfully connected.')
})

Isso vai funcionar:

// Connect to Mongo
mongoose.set("useNewUrlParser", true);
mongoose.set("useUnifiedTopology", true);

mongoose
  .connect(db) // Connection String here
  .then(() => console.log("MongoDB Connected..."))
  .catch(() => console.log(err));

const url = 'mongodb://localhost:27017';
const client = new MongoClient(url);

Corte a segunda linha superior e, em seguida, basta substituir essa linha

const client = new MongoClient(url, { useUnifiedTopology: true });

Isso funciona bem para mim e sem mais erros.

mongoose
.connect(URL_of_mongodb, {
useUnifiedTopology: true,
useNewUrlParser: true,
})
.then(() => console.log('DB Connected!'))
.catch(err => {
console.log(`DB Connection Error: ${err}`);
});

código de amostra de trabalho para mongo, link de referência

var MongoClient = require('mongodb').MongoClient;
var url = "mongodb://localhost:27017/";
MongoClient.connect(url,{ useUnifiedTopology: true }, function(err, db) {
  if (err) throw err;
  var dbo = db.db("mydb");
  dbo.createCollection("customers", function(err, res) {
    if (err) throw err;
    console.log("Collection created!");
    db.close();
  });
});