Para agentes de IA: um índice de documentação está disponível em https://www.mongodb.com/pt-br/docs/llms.txt — as versões de markdown de todas as páginas estão disponíveis anexando .md a qualquer caminho de URL.
Menu Docs
Página inicial do Docs
/
Desenvolvimento
/
Métodos de mongosh
Página inicial do Docs
/
Desenvolvimento
/
Métodos de mongosh
Página inicial do Docs
/
Desenvolvimento
/
Métodos de mongosh

db.currentOp() (método mongosh)

Definição

db.currentOp()

Importante

O comando de banco de dados currentOp está obsoleto desde a versão 6.2. Use o estágio de agregação $currentOp em vez do comando currentOp e seu método assistente mongosh db.currentOp().

Retorna um documento que contém informações sobre operações em andamento para a instância do banco de dados . O método db.currentOp() envolve o comando de banco de dados currentOp.

Observação

A partir do MongoDB 5.0, o estágio de agregação $currentOp é usado ao executar o método assistente db.currentOp() com mongosh.

Diante disso, na versão 5.0 do shell e com mongosh, os conjuntos de resultados dedb.currentOp() não estão sujeitos ao limite de tamanho de retorno de documento BSON de 16MB para documentos do legado anterior mongo versões.

Compatibilidade

Esse método está disponível em implantações hospedadas nos seguintes ambientes:

  • MongoDB Atlas: o serviço totalmente gerenciado para implantações MongoDB na nuvem

Importante

Este comando não é suportado em clusters M0 e Flex. Para obter mais informações, consulte Comandos não suportados.

  • MongoDB Enterprise: a versão autogerenciada e baseada em assinatura do MongoDB

  • MongoDB Community: uma versão com código disponível, de uso gratuito e autogerenciada do MongoDB

Sintaxe

db.currentOp() tem o seguinte formato:

db.currentOp(<operations>)

db.currentOp() pode receber o seguinte argumento opcional:

Parâmetro
Tipo
Descrição

booleano ou documento

Opcional. Especifica as operações a serem relatadas. Pode passar por um booleano ou um documento:

  • Especifique true para incluir operações em conexões ociosas e operações do sistema.

  • Especifique um documento com condições de query para relatar apenas as operações que correspondem às condições. Consulte Comportamento para ver detalhes.

Comportamento

db.currentOp() pode aceitar um documento de filtro ou um parâmetro booleano.

Se você passar um documento de filtro para db.currentOp(), a saída retornará informações somente para as operações atuais que correspondem ao filtro. O documento de filtro pode conter:

Campo
Descrição

"$ownOps"

Booleano. Se definido para true, retorna informações somente sobre as operações do usuário atual.

Em instâncias do mongod, os usuários sempre podem executar o db.currentOp( { "$ownOps": true } ) para visualizar suas próprias operações.

"$all"

Booleano. Se definido para true, retorna informações sobre todas as operações, incluindo operações em conexões ociosas e operações do sistema. Para obter mais informações, veja $currentOp (estágio de agregação).

Se o documento incluir "$all": true junto com as condições dos Campos de Saída, somente o "$all":true se aplicará.

<filter>

Especifique as condições de filtro nos Campos de Saída. Veja exemplos.

Se o documento incluir "$all": true junto com as condições dos Campos de Saída, somente o "$all": true se aplicará.

Passar true para db.currentOp() equivale a passar um documento de { "$all": true }. As seguintes operações são equivalentes:

db.currentOp(true)
db.currentOp( { "$all": true } )

db.currentOp() e o profiler de banco de dados relatam as mesmas informações básicas de diagnóstico para todas as operações CRUD, incluindo o seguinte:

Essas operações também são incluídas no logging de queries lentas. Consulte slowOpThresholdMs para obter mais informações sobre registro de queries lentas.

Controle de acesso

Em sistemas executados com authorization, o usuário deve ter acesso que inclua a ação de privilégio inprog.

Os usuários podem executar db.currentOp( { "$ownOps": true } ) em instâncias mongod para visualizar suas próprias operações mesmo sem a ação de privilégio inprog.

Dica

Crie uma função para gerenciar as operações atuais

Exemplos

Os exemplos seguintes utilizam o método db.currentOp() com vários documentos de consulta para filtrar a saída.

Operações de gravação aguardando um bloqueio

O exemplo a seguir retorna informações sobre todas as operações de gravação que estão aguardando um bloqueio:

db.currentOp(
   {
     "waitingForLock" : true,
     $or: [
        { "op" : { "$in" : [ "insert", "update", "remove" ] } },
        { "command.findandmodify": { $exists: true } }
    ]
   }
)

Operações ativas sem rendimento

O exemplo a seguir retorna informações sobre todas as operações em execução ativas que nunca produziram:

db.currentOp(
   {
     "active" : true,
     "numYields" : 0,
     "waitingForLock" : false
   }
)

Operações ativas em um banco de dados específico

O exemplo a seguir retorna informações sobre todas as operações ativas do banco de dados db1 que estão em execução há mais de 3 segundos:

db.currentOp(
   {
     "active" : true,
     "secs_running" : { "$gt" : 3 },
     "ns" : /^db1\./
   }
)

Operações de indexação ativas

O exemplo a seguir retorna informações sobre operações de criação de índice:

db.getSiblingDB("admin").aggregate( [
   { $currentOp : { idleConnections: true } },
   { $match: {
         $or: [
            { "op": "command", "command.createIndexes": { $exists: true } },
            { "op": "none", "msg": /^Index Build/ }
         ]
      }
   }
] )

Observação

As operações de indexação ativas não se aplicam à construção de índice contínua.

Exemplo de saída

A seguir está um protótipo de saída db.currentOp().

O seguinte é um protótipo do resultado currentOp ao executar em um standalone:

{
  "inprog": [
       {
         "type" : <string>,
         "host" : <string>,
         "desc" : <string>,
         "connectionId" : <number>,
         "client" : <string>,
         "appName" : <string>,
         "clientMetadata" : <document>,
         "active" : <boolean>,
         "currentOpTime" : <string>,
         "effectiveUsers" : [
            {
               "user" : <string>,
               "db" : <string>
            }
         ],
         "opid" : <number>,
         "lsid" : {
            "id" : <UUID>,
            "uid" : <BinData>
         },
         "secs_running" : <Long()>,
         "microsecs_running" : <number>,
         "op" : <string>,
         "ns" : <string>,
         "command" : <document>,
         "queryFramework" : <string>,
         "planSummary": <string>,
         "cursor" : {                              // only for getMore operations
            "cursorId" : <Long()>,
            "createdDate" : <ISODate()>,
            "lastAccessDate" : <ISODate()>,
            "nDocsReturned" : <Long()>,
            "nBatchesReturned" : <Long()>,
            "noCursorTimeout" : <boolean>,
            "tailable" : <boolean>,
            "awaitData" : <boolean>,
            "originatingCommand" : <document>,
            "planSummary" : <string>,
            "operationUsingCursorId" : <Long()>
         },
         "msg": <string>,
         "progress" : {
             "done" : <number>,
             "total" : <number>
         },
         "killPending" : <boolean>,
         "numYields" : <number>,
         "dataThroughputLastSecond" : <number>,
         "dataThroughputAverage" : <number>,
         "waitingForLatch" : {
             "timestamp" : <ISODate()>,
             "captureName" : <string>
         },
         "locks" : {
             "ParallelBatchWriterMode" : <string>,
             "ReplicationStateTransition" : <string>,
             "Global" : <string>,
             "Database" : <string>,
             "Collection" : <string>,
             "Metadata" : <string>,
             "oplog" : <string>
         },
         "waitingForLock" : <boolean>,
         "lockStats" : {
             "ParallelBatchWriterMode" : {
                "acquireCount": {
                   "r": <NumberLong>,
                   "w": <NumberLong>,
                   "R": <NumberLong>,
                   "W": <NumberLong>
                },
                "acquireWaitCount": {
                   "r": <NumberLong>,
                   "w": <NumberLong>,
                   "R": <NumberLong>,
                   "W": <NumberLong>
                },
                "timeAcquiringMicros" : {
                   "r" : Long(0),
                   "w" : Long(0),
                   "R" : Long(0),
                   "W" : Long(0)
                },
                "deadlockCount" : {
                   "r" : Long(0),
                   "w" : Long(0),
                   "R" : Long(0),
                   "W" : Long(0)
                }
             },
             "ReplicationStateTransition" : {
                ...
             },
             "Global": {
                ...
             },
             "Database" : {
                ...
             },
             ...
         }
       },
       ...
   ],
   "fsyncLock": <boolean>,
   "info": <string>,
    "ok": <num>
}

Exemplos de saída específicos

Estas amostras de saída ilustram currentOp saída para operações específicas. Os campos que compõem a saída real variam dependendo do papel do servidor.

Exemplo de saída de refragmentação

{
    type: "op",
    desc: "Resharding{Donor, Recipient, Coordinator}Service <reshardingUUID>",
    op: "command",
    ns: "<database>.<collection>",
    originatingCommand: {
        reshardCollection: "<database>.<collection>",
        key: <shardkey>,
        unique: <boolean>,
        collation: {locale: "simple"},
        // Other options to the reshardCollection command are omitted
        // to decrease the likelihood the output is truncated.
   },
   {donor, coordinator, recipient}State : "<service state>",
   approxDocumentsToCopy: NumberLong(<count>),
   approxBytesToCopy: NumberLong(<count>),
   bytesCopied: NumberLong(<count>),
   countWritesToStashCollections: NumberLong(<count>),
   countWritesDuringCriticalSection : NumberLong(<count>),
   countReadsDuringCriticalSection: NumberLong(<count>),
   deletesApplied: NumberLong(<count>),
   documentsCopied: NumberLong(<count>),
   insertsApplied: NumberLong(<count>),
   oplogEntriesFetched: NumberLong(<count>),
   oplogEntriesApplied: NumberLong(<count>),
   remainingOperationTimeEstimatedSecs: NumberLong(<count>),
   allShardsLowestRemainingOperationTimeEstimatedSecs: NumberLong(<estimate>),
   allShardsHighestRemainingOperationTimeEstimatedSecs: NumberLong(<estimate>),
   totalApplyTimeElapsedSecs: NumberLong(<count>),
   totalCopyTimeElapsedSecs: NumberLong(<count>),
   totalCriticalSectionTimeElapsedSecs : NumberLong(<count>),
   totalOperationTimeElapsedSecs: NumberLong(<count>),
   updatesApplied: NumberLong(<count>),
}

Exemplo de índice global

{
    type: "op",
    desc: "GlobalIndex{Donor, Recipient, Coordinator}Service <globalIndexUUID}",
    op: "command",
    ns: "<database>.<collection>",
    originatingCommand: {
        createIndexes: "<database>.<collection>",
        key: <indexkeypattern>,
        unique: <boolean>,
        <Additional createIndexes options>
    },
   {donor, coordinator, recipient}State : "<service state>",
   approxDocumentsToScan: Long(<count>),
   approxBytesToScan: Long(<count>),
   bytesWrittenFromScan: Long(<count>),
   countWritesToStashCollections: Long(<count>),
   countWritesDuringCriticalSection : Long(<count>),
   countReadsDuringCriticalSection: Long(<count>),
   keysWrittenFromScan: Long(<count>),
   remainingOperationTimeEstimatedSecs: Long(<count>),
   allShardsLowestRemainingOperationTimeEstimatedSecs: Long(<estimate>),
   allShardsHighestRemainingOperationTimeEstimatedSecs: Long(<estimate>),
   totalCopyTimeElapsedSecs: Long(<count>),
   totalCriticalSectionTimeElapsedSecs : Long(<count>),
   totalOperationTimeElapsedSecs: Long(<count>),
}

Campos de Saída

Para uma lista completa de campos de saída do db.currentOp(), consulte currentOp.

Voltar
db.createView
Próximo
db.dropDatabase
Avalie esta página

Nesta página