serverStatus

정의

serverStatus: serverStatus 명령은 데이터베이스 상태의 개요를 제공하는 문서를 반환합니다. 모니터링 애플리케이션은 정기적으로 이 명령을 실행하여 인스턴스에 대한 통계를 수집할 수 있습니다.

호환성

이 명령은 다음 환경에서 호스팅되는 배포에서 사용할 수 있습니다.

MongoDB Atlas: 클라우드에서의 MongoDB 배포를 위한 완전 관리형 서비스

참고

이 명령은 모든 MongoDB Atlas 클러스터에서 지원됩니다. 모든 명령에 대한 Atlas 지원에 관해 자세히 알아보려면 지원되지 않는 명령을 참조하십시오.

MongoDB Enterprise: MongoDB의 구독 기반 자체 관리 버전
MongoDB Community: MongoDB의 소스 사용 가능 무료 자체 관리 버전

구문

명령은 다음과 같은 구문을 가집니다:

db.runCommand(
   {
     serverStatus: 1
   }
)

이 값(예: 1보다 높음)은 명령의 연산에 영향을 주지 않습니다. db.serverStatus() 명령은 다량의 데이터를 반환합니다. 출력에서 특정 객체 또는 필드를 반환하려면 객체 또는 필드의 이름을 명령에 추가하세요.

예를 들면 다음과 같습니다.

db.runCommand({ serverStatus: 1}).metrics
db.runCommand({ serverStatus: 1}).metrics.commands
db.runCommand({ serverStatus: 1}).metrics.commands.update

mongosh은(는) serverStatus 명령에 대한 db.serverStatus() 래퍼(wrapper)를 제공합니다.

팁

다음도 참조하세요.

serverStatus 출력의 대부분은 mongostat에 의해서도 동적으로 표시됩니다. 자세한 내용은 mongostat 명령을 참조하세요.

행동

기본적으로 serverStatus는 출력에서 다음을 제외합니다.

repl 문서의 일부 내용.
mirroredReads 문서.

기본적으로 제외되는 필드를 포함하려면 명령에서 최상위 필드를 지정하고 이 필드를 1로 설정합니다. 기본적으로 포함되는 필드를 제외하려면 필드를 지정하고 0으로 설정합니다. 최상위 필드 또는 포함되는 필드를 지정할 수 있습니다.

그 예로 다음 연산은 repl, metrics 및 locks 정보를 출력에서 제외합니다.

db.runCommand( { serverStatus: 1, repl: 0, metrics: 0, locks: 0 } )

그 예로 다음 연산은 포함된 histogram 필드를 출력에서 제외합니다.

db.runCommand( { serverStatus: 1, metrics: { query: { multiPlanner: { histograms: false } } } } )

다음 예시의 출력에는 모든 repl 정보가 포함되어 있습니다.

db.runCommand( { serverStatus: 1,  repl: 1 } )

초기화

serverStatus에서 보고된 통계는 mongod 서버가 다시 시작될 때 재설정됩니다.

이 명령은 신규 데이터베이스에서도 항상 값을 반환합니다. 관련 명령 db.serverStatus()은(는) 특정 지표의 카운터가 증가하기 시작한 경우를 제외하면 항상 값을 반환하지 않습니다.

업데이트 쿼리를 실행한 후에는 db.serverStatus() 및 db.runCommand({ serverStatus: 1}) 둘 다 동일한 값을 반환합니다.

{
   arrayFilters : Long("0"),
   failed : Long("0"),
   pipeline : Long("0"),
   total : Long("1")
}

포함 `mirroredReads`

mirroredReads 정보는 기본적으로 출력에 포함되지 않습니다. mirroredReads 정보를 반환하려면 포함 항목을 다음과 같이 명시적으로 지정해야 합니다.

db.runCommand( { serverStatus: 1, mirroredReads: 1 } )

출력

참고

출력 필드는 MongoDB 버전, 기본 운영 체제 플랫폼, 스토리지 엔진, 노드 종류(mongos, mongod 또는 복제본 세트 멤버 포함)에 따라 달라집니다.

사용 중인 MongoDB 버전에만 특정되는 serverStatus 출력에 대해서는 해당 버전의 MongoDB 매뉴얼을 참조하세요.

어설션

asserts: {
   regular: <num>,
   warning: <num>,
   msg: <num>,
   user: <num>,
   rollovers: <num>
},

asserts: MongoDB 프로세스가 시작된 이후 발생한 어설션의 수를 보고하는 문서입니다. 어설션은 데이터베이스가 작동하는 동안 발생하는 오류에 대한 내부 검사이며 MongoDB 서버 문제를 진단하는 데 도움이 될 수 있습니다. 0이 아닌 어설션 값은 어설션 오류를 나타내며 이는 일반적이지 않으며 즉각적인 우려의 원인이 아닙니다. 어설션을 생성하는 오류는 로그 파일에 기록하거나 클라이언트 애플리케이션에 직접 반환하여 자세한 정보를 확인할 수 있습니다.

asserts.regular: MongoDB 프로세스가 시작된 이후 발생한 정규 어설션의 수입니다. 자세한 내용은 MongoDB 로그에서 확인하세요.

asserts.warning: 이 필드는 항상 0 0을(를) 반환합니다.

asserts.msg: MongoDB 프로세스가 시작된 이후 발생한 메시지 어설션의 수입니다. 이 메시지에 대한 자세한 내용을 보려면 로그 파일을 검사하세요.

asserts.user: MongoDB 프로세스가 마지막으로 시작된 이후 발생한 "사용자 어설션"의 수입니다. 사용자가 생성할 수 있는 오류(예: 디스크 공간 부족 또는 키 중복)입니다. 애플리케이션 또는 배포서버 관련 문제를 수정하여 이러한 어설션을 방지할 수 있습니다. 이 메시지에 대한 자세한 내용을 보려면 로그 파일을 검사하세요.

asserts.rollovers: MongoDB 프로세스가 마지막으로 시작된 이후 어설션 카운터가 롤오버한 횟수입니다. 카운터는 어설션이 ³⁰회씩 2세트 끝난 후에 0으로 롤오버됩니다. asserts 데이터 구조의 다른 값에 컨텍스트를 제공하려면 이 값을 사용하세요.

bucketCatalog

bucketCatalog: {
    numBuckets: <num>,
    numOpenBuckets: <num>,
    numIdleBuckets: <num>,
    memoryUsage: <num>,
    numBucketInserts: <num>,
    numBucketUpdates: <num>,
    numBucketsOpenedDueToMetadata: <num>,
    numBucketsClosedDueToCount: <num>,
    numBucketsClosedDueToSchemaChange: <num>,
    numBucketsClosedDueToSize: <num>,
    numBucketsClosedDueToTimeForward: <num>,
    numBucketsClosedDueToTimeBackward: <num>,
    numBucketsClosedDueToMemoryThreshold: <num>,
    numCommits: <num>,
    numMeasurementsGroupCommitted: <num>,
    numWaits: <num>,
    numMeasurementsCommitted: <num>,
    avgNumMeasurementsPerCommit: <num>,
    numBucketsClosedDueToReopening: <num>,
    numBucketsArchivedDueToMemoryThreshold: <num>,
    numBucketsArchivedDueToTimeBackward: <num>,
    numBucketsReopened: <num>,
    numBucketsKeptOpenDueToLargeMeasurements: <num>,
    numBucketsClosedDueToCachePressure: <num>,
    numBucketsFrozen: <num>,
    numCompressedBucketsConvertedToUnsorted: <num>,
    numBucketsFetched: <num>,
    numBucketsQueried: <num>,
    numBucketFetchesFailed: <num>,
    numBucketQueriesFailed: <num>,
    numBucketReopeningsFailed: <num>,
    numDuplicateBucketsReopened: <num>,
    stateManagement: {
       bucketsManaged: <num>,
       currentEra: <num>,
       erasWithRemainingBuckets: <num>,
       trackedClearOperations: <num>
    }
 }

버전 5.0에 추가.

Time Series 컬렉션의 내부 스토리지와 관련 있는 지표를 보고하는 문서입니다.

bucketCatalog은(는) 다음 지표를 반환합니다.

메트릭	설명
`numBuckets`	추적된 버킷의 총 개수입니다. `numOpenBuckets`와 `numArchivedBuckets`의 합과 같을 것으로 예상됩니다.
`numOpenBuckets`	캐시에 저장된 전체 표현을 추적하여 새 문서를 수신할 준비가 된 버킷의 수입니다.
`numIdleBuckets`	열려 있고 현재 커밋되지 않은 문서 삽입이 보류 중이 아닌 버킷의 수입니다. numOpenBuckets의 하위 집합입니다.
`numArchivedBuckets`	새 문서를 받기 위해 효율적으로 다시 열 수 있는 캐시 내 저장된 최소한의 표현을 가진 추적된 버킷의 수입니다.
`memoryUsage`	내부 버킷팅 데이터 구조에서 사용하는 바이트의 수입니다.
`numBucketInserts`	생성된 새 버킷의 수입니다.
`numBucketUpdates`	기존 버킷이 추가 문서를 포함하도록 업데이트한 횟수입니다.
`numBucketsOpenedDueToMetadata`	현재 열려 있는 버킷과 일치하지 않는 `metaField` 값을 가진 문서가 도착하여 열린 버킷 수입니다.
`numBucketsClosedDueToCount`	문서 수 제한에 도달하여 닫힌 버킷의 수입니다.
`numBucketsClosedDueToSchemaChange`	수신 문서의 스키마가 열려있는 버킷의 문서 스키마와 호환되지 않아 닫힌 버킷 수입니다.
`numBucketsClosedDueToSize`	수신 문서로 인해 버킷이 크기 제한을 초과하게 되어 닫힌 버킷 수입니다.
`numBucketsClosedDueToTimeForward`	해당 `metaField` 값에 대해 현재 열려 있는 모든 버킷의 최대 시간이 지난 후 `timeField` 값이 있는 문서가 도착하여 종료된 버킷 수입니다.
`numBucketsClosedDueToTimeBackward`	해당 `metaField` 값에 대해 현재 열려 있는 모든 버킷의 최소 시간 이전에 `timeField` 값이 있는 문서가 도착하여 닫힌 버킷 수입니다.
`numBucketsClosedDueToMemoryThreshold`	활성 버킷 세트가 허용된 스토리지 엔진 캐시 크기에 맞지 않아서 닫힌 버킷 수입니다.
`numCommits`	Time Series 컬렉션에 대한 버킷 수준 커밋의 수입니다.
`numMeasurementsGroupCommitted`	동시 삽입 명령의 측정값이 포함된 커밋 수입니다.
`numWaits`	작업이 버킷을 다시 열거나 그룹 커밋을 완료하기 위해 다른 스레드를 기다린 횟수입니다.
`numMeasurementsCommitted`	Time Series 컬렉션에 커밋된 문서 수입니다.
`avgNumMeasurementsPerCommit`	커밋 당 평균 문서 수입니다.
`numBucketsClosedDueToReopening`	적합한 버킷을 다시 열었기 때문에 닫힌 버킷 수입니다.
`numBucketsArchivedDueToMemoryThreshold`	활성 버킷 세트가 허용된 버킷 카탈로그 캐시 크기에 맞지 않아 보관된 버킷 수입니다.
`numBucketsArchivedDueToTimeBackward`	해당 `metaField` 값에 대해 현재 열려 있는 모든 버킷의 최소 시간보다 먼저 `timeField` 값으로 문서가 도착하여 보관된 버킷의 수입니다.
`numBucketsReopened`	열려 있는 버킷과 일치하지 않지만 가득 차 있지 않은 기존 버킷과 일치하는 문서가 도착하여 다시 열린 버킷의 수입니다.
`numBucketsKeptOpenDueToLargeMeasurements`	크기 때문에 닫혔어야 했지만 적절한 압축을 달성하는 데 필요한 최소 문서 수를 포함하지 않아 열려 있는 버킷의 수입니다.
`numBucketsClosedDueToCachePressure`	사용 가능한 스토리지 엔진 캐시 크기와 `numBuckets`에서 파생된 버킷 카탈로그의 동적 버킷 크기 제한을 초과하여 닫힌 버킷의 수입니다. 이 제한은 최대 버킷 크기 제한과는 별개입니다.
`numBucketsFrozen`	동결된 버킷의 수입니다. 버킷을 압축하면 버킷의 내용이 손상될 경우 버킷이 동결됩니다.
`numCompressedBucketsConvertedToUnsorted`	해당 `timeField` 값으로 정렬되지 않은 문서를 포함하는 압축된 버킷의 수입니다.
`numBucketsFetched`	다시 여는 데 적합한지 확인하기 위해 가져온 보관된 버킷 수입니다.
`numBucketsQueried`	수신 문서를 보관할 수 있는지 확인하기 위해 쿼리된 총 버킷 수입니다.
`numBucketFetchesFailed`	다시 열기에 적합하지 않은 보관된 버킷을 가져온 개수입니다.
`numBucketQueriesFailed`	적절한 오픈 버킷에 대해 후보 가용성 부족으로 실패한 쿼리 수입니다.
`numBucketReopeningsFailed`	동시 작업과의 충돌, 잘못된 버킷 등의 이유로 실패한 버킷 다시 열기 시도 횟수입니다.
`numDuplicateBucketsReopened`	현재 열려 있는 버킷과 중복되는 다시 열린 버킷의 수입니다.
`stateManagement`	버킷 카탈로그 상태 정보를 추적하는 문서입니다.
`stateManagement.bucketsManaged`	충돌 관리를 위해 추적 중인 총 버킷 수입니다. 여기에는 버킷 카탈로그에서 열린 버킷뿐만 아니라 업데이트 및 삭제 명령을 통해 직접 기록되는 모든 버킷이 포함됩니다.
`stateManagement.currentEra`	버킷 카탈로그의 현재 시대입니다. 버킷 카탈로그는 0 시대에서 시작하여 버킷이 지워지면 증가합니다. 버킷에 삽입을 시도하면 버킷이 지워진 경우 제거되거나 현재 시대로 업데이트됩니다.
`stateManagement.erasWithRemainingBuckets`	추적된 버킷이 있는 기간의 수입니다.
`stateManagement.trackedClearOperations`	버킷 세트가 지워졌지만 해당 버킷 제거가 연기된 횟수입니다. 이는 컬렉션 삭제, 샤딩된 컬렉션의 청크 이동 또는 투표와 같은 이벤트로 인해 발생할 수 있습니다.

catalogStats

버전 5.1에 추가되었습니다.

catalogStats: {
   collections: <num>,
   capped: <num>,
   views: <num>,
   timeseries: <num>,
   internalCollections: <num>,
   internalViews: <num>
}

catalogStats: 컬렉션 개수를 통해 컬렉션 사용량에 대한 통계를 보고하는 문서입니다.

catalogStats.collections: 사용자 컬렉션의 총 개수(시스템 컬렉션 제외)입니다.

catalogStats.capped: 한도가 설정된 사용자 컬렉션의 총 개수입니다.

catalogStats.views: 사용자 총 조회수입니다.

catalogStats.timeseries: Time Series 컬렉션의 총 개수입니다.

catalogStats.internalCollections: 시스템 컬렉션(config, admin또는 local 데이터베이스의 컬렉션)의 총 개수입니다.

catalogStats.internalViews: 시스템 컬렉션(config, admin또는 local 데이터베이스의 컬렉션)의 총 조회수입니다.

changeStreamPreImages

버전 5.0에 추가.

changeStreamPreImages : {
   purgingJob : {
      totalPass : <num>,
      docsDeleted : <num>,
      bytesDeleted : <num>,
      scannedCollections : <num>,
      scannedInternalCollections : <num>,
      maxStartWallTimeMillis : <num>,
      timeElapsedMillis : <num>,
   },
   expireAfterSeconds : <num>
}

문서는 change stream 사전 이미지와 관련된 지표를 보고합니다.

changeStreamPreImages.purgingJob

버전 7.1에 새로 추가되었습니다.

change stream 사전 이미지의 퍼지 작업과 관련된 지표를 보고하는 문서입니다. 퍼지 작업은 시스템이 사전 이미지를 비동기적으로 제거하는 데 사용하는 백그라운드 프로세스입니다.

changeStreamPreImages.purgingJob 필드는 다음 지표를 반환합니다.

메트릭	설명
`totalPass`	비우기 작업에서 완료된 삭제 단계의 총 개수입니다.
`docsDeleted`	퍼지 작업으로 삭제된 전 이미지 문서 (pre-image document)의 누적 개수입니다.
`bytesDeleted`	제거 작업으로 인해 모든 사전 이미지 collection에서 삭제된 모든 문서의 누적 크기(단위: 바이트)입니다.
`scannedCollections`	퍼지 작업으로 스캔된 사전 이미지 컬렉션의 누적 개수입니다. 단일 테넌트 환경에서는 각 테넌트에 하나의 사전 이미지 컬렉션이 있으므로 이 숫자는 `totalPass` 와 동일합니다.
`scannedInternalCollections`	퍼징 작업으로 스캔한 내부 사전 이미지 collection의 누적 개수입니다. 내부 컬렉션은 `config.system.preimages` 에 저장된 사전 이미지 컬렉션 내의 컬렉션입니다.
`maxStartWallTimeMillis`	각 사전 이미지 collection의 첫 번째 문서로부터의 최대 벽 시간(밀리초)입니다.
`timeElapsedMillis`	제거 작업의 모든 삭제 시간(밀리초)이 경과합니다.

changeStreamPreImages.expireAfterSeconds: 버전 7.1에 새로 추가되었습니다.
MongoDB가 사전 이미지를 보관하는 시간(초)입니다. expireAfterSeconds 이(가) 정의되지 않은 경우, 이 지표는 serverStatus 출력에 나타나지 않습니다.

연결

connections : {
   current : <num>,
   available : <num>,
   totalCreated : <num>,
   rejected : <num>,  // Added in MongoDB 6.3
   active : <num>,
   threaded : <num>,
   exhaustIsMaster : <num>,
   exhaustHello : <num>,
   awaitingTopologyChanges : <num>,
   loadBalanced : <num>
},

connections: 연결의 상태를 보고하는 문서입니다. 서버의 현재 로드 및 용량 요건을 평가하려면 이 값을 사용하세요.

connections.current

클라이언트에서 데이터베이스 서버로 들어오는 연결의 건수입니다. 이 숫자에는 현재의 shell 세션이 포함됩니다. 이 데이텀에 더 많은 컨텍스트를 추가하려면 connections.available 값을 고려하세요.

이 값에는 셸 연결이나 다른 서버(예: 복제본 세트 멤버 또는 mongos 인스턴스)에서의 연결 등 모든 수신 연결이 포함됩니다.

connections.available: 사용 가능한 미사용 수신 연결의 수입니다. connections.current 값과 함께 이 값을 고려하여 데이터베이스의 연결 부하를 파악하고, 사용 가능한 연결의 시스템 임계값에 대한 자세한 내용은 자체 관리형 배포를 위한 UNIX ulimit 설정 문서를 참조하세요.

connections.totalCreated: 서버에 대해 생성된 모든 수신 연결의 횟수입니다. 이 숫자에는 이후에 종료된 연결이 포함됩니다.

connections.rejected: 버전 6.3에 추가.
서버가 추가 연결을 허용할 용량이 없거나 net.maxIncomingConnections 설정에 도달하여 서버가 거부한 수신 연결의 건수입니다.

connections.active: 서버에 대한 활성 클라이언트 연결의 건수입니다. 활성 클라이언트 연결은 현재 연산이 진행 중인 클라이언트 연결을 의미합니다.

connections.threaded: 클라이언트 요청을 서비스하는 스레드에 배정된 클라이언트로부터 들어오는 연결의 건수입니다.
버전 5.0에 추가.

connections.exhaustIsMaster: 마지막 요청이 exhaustAllowed이(가) 포함된 isMaster 요청이었던 연결의 건수입니다.
참고
MongoDB 5.0 이상을 실행할 경우 isMaster 명령은 사용하지 마세요. 대신 hello을(를) 사용하세요.

connections.exhaustHello: 마지막 요청이 exhaustAllowed이(가) 포함된 hello요청이었던 연결의 건수입니다.
버전 5.0에 추가.

connections.awaitingTopologyChanges: 토폴로지 변경을 위해 현재 hello 요청 또는 isMaster 요청을 대기 중인 클라이언트의 수입니다.
참고
MongoDB 5.0 이상을 실행할 경우 isMaster 명령은 사용하지 마세요. 대신 hello을(를) 사용하세요.

connections.loadBalanced: 버전 5.3에 추가.
로드 밸런서를 통해 수신되는 수신 연결의 현재 수입니다.

defaultRWConcern

defaultRWConcern 섹션은 전역 기본 읽기 또는 쓰기 고려 설정의 로컬 복사본에 대한 정보를 제공합니다. 데이터가 오래되었거나 만료된 것일 수 있습니다. 자세한 내용은 getDefaultRWConcern을(를) 참조하세요.

defaultRWConcern : {
  defaultReadConcern : {
    level : <string>
  },
  defaultWriteConcern : {
    w : <string> | <int>,
    wtimeout : <int>,
    j : <bool>
  },
  defaultWriteConcernSource: <string>,
  defaultReadConcernSource: <string>,
  updateOpTime : Timestamp,
  updateWallClockTime : Date,
  localUpdateWallClockTime : Date
}

defaultRWConcern: 마지막으로 알려진 전역 기본 읽기 또는 쓰기 고려 설정입니다.

defaultRWConcern.defaultReadConcern

마지막으로 알려진 전역 기본 읽기 고려 설정입니다.

serverStatus가 이 필드를 반환하지 않는다면 전역 기본 읽기 고려가 설정되지 않은 경우 또는 아직 인스턴스에 전파되지 않은 경우에 해당합니다.

defaultRWConcern.defaultReadConcern.level

마지막으로 알려진 전역 기본 읽기 고려 레벨 설정입니다.

serverStatus에서 이 필드를 반환하지 않는 경우 이 설정의 글로벌 기본값이 설정되지 않았거나 또는 인스턴스에 아직 전파되지 않은 것입니다.

defaultRWConcern.defaultWriteConcern

마지막으로 알려진 전역 기본 쓰기 고려 설정입니다.

serverStatus에서 이 필드를 반환하지 않는 경우 글로벌 기본 쓰기 고려(write concern)가 설정되지 않았거나 또는 아직 인스턴스에 전파되지 않은 것입니다.

defaultRWConcern.defaultWriteConcern.w

마지막으로 알려진 전역 기본 w 설정입니다.

serverStatus에서 이 필드를 반환하지 않는 경우 이 설정의 글로벌 기본값이 설정되지 않았거나 또는 인스턴스에 아직 전파되지 않은 것입니다.

defaultRWConcern.defaultWriteConcern.wtimeout

마지막으로 알려진 전역 기본 wtimeout 설정입니다.

serverStatus에서 이 필드를 반환하지 않는 경우 이 설정의 글로벌 기본값이 설정되지 않았거나 또는 인스턴스에 아직 전파되지 않은 것입니다.

defaultRWConcern.defaultWriteConcernSource: 기본 쓰기 고려의 출처입니다. 이 값은 기본적으로 "implicit"입니다. setDefaultRWConcern(으)로 기본 쓰기 고려를 설정하면 해당 값이 "global"이(가) 됩니다.
버전 5.0에 추가.

defaultRWConcern.defaultReadConcernSource: 기본 읽기 고려의 출처입니다. 이 값은 기본적으로 "implicit"입니다. setDefaultRWConcern(으)로 기본 읽기 고려를 설정하면 해당 값이 "global"이(가) 됩니다.
버전 5.0에 추가.

defaultRWConcern.updateOpTime: 인스턴스가 전역 읽기 또는 쓰기 고려 설정의 복사본을 마지막으로 업데이트했을 때의 타임스탬프입니다. defaultRWConcern.defaultReadConcern 및 defaultRWConcern.defaultWriteConcern 필드가 없는 경우 이 필드는 기본값이 마지막으로 설정 해제된 타임스탬프를 나타냅니다.

defaultRWConcern.updateWallClockTime: 인스턴스가 전역 읽기 또는 쓰기 고려 설정의 복사본을 마지막으로 업데이트했을 때의 벽시계 시간입니다. defaultRWConcern.defaultReadConcern 및 defaultRWConcern.defaultWriteConcern 필드가 없는 경우 이 필드는 기본값이 마지막으로 설정 해제된 시간을 나타냅니다.

defaultRWConcern.localUpdateWallClockTime: 인스턴스가 전역 읽기 또는 쓰기 고려 설정의 복사본을 마지막으로 업데이트했을 때의 로컬 시스템 벽시계 시간입니다. 이 필드가 defaultRWConcern의 유일한 필드라면 해당 인스턴스에 전역 기본 읽기 또는 쓰기 고려 설정에 대한 지식이 있었던 적이 없는 경우에 해당합니다.

electionMetrics

electionMetrics 섹션에서는 이 mongod 인스턴스가 프라이머리가 되기 위해 호출한 투표에 대한 정보를 제공합니다.

electionMetrics : {
   stepUpCmd : {
      called : Long("<num>"),
      successful : Long("<num>")
   },
   priorityTakeover : {
      called : Long("<num>"),
      successful : Long("<num>")
   },
   catchUpTakeover : {
      called : Long("<num>"),
      successful : Long("<num>")
   },
   electionTimeout : {
      called : Long("<num>"),
      successful : Long("<num>")
   },
   freezeTimeout : {
      called : Long("<num>"),
      successful : Long("<num>")
   },
   numStepDownsCausedByHigherTerm : Long("<num>"),
   numCatchUps : Long("<num>"),
   numCatchUpsSucceeded : Long("<num>"),
   numCatchUpsAlreadyCaughtUp : Long("<num>"),
   numCatchUpsSkipped : Long("<num>"),
   numCatchUpsTimedOut : Long("<num>"),
   numCatchUpsFailedWithError : Long("<num>"),
   numCatchUpsFailedWithNewTerm : Long("<num>"),
   numCatchUpsFailedWithReplSetAbortPrimaryCatchUpCmd : Long("<num>"),
   averageCatchUpOps : <double>
}

electionMetrics.stepUpCmd

프라이머리가 물러났을 때 mongod 인스턴스가 투표 핸드오프의 일부로 호출한 투표에 대한 지표입니다.

stepUpCmd에는 호출된 투표의 수와 성공한 투표의 수가 모두 포함됩니다.

electionMetrics.priorityTakeover

인스턴스의 priority이(가) 프라이머리보다 높기 때문에 mongod 인스턴스가 호출한 투표에 대한 지표입니다.

electionMetrics.priorityTakeover에는 호출된 투표의 수와 성공한 투표의 수가 모두 포함됩니다.

electionMetrics.catchUpTakeover

프라이머리보다 최신이기 때문에 mongod 인스턴스가 호출한 투표에 대한 지표입니다.

catchUpTakeover에는 호출된 투표의 수와 성공한 투표의 수가 모두 포함됩니다.

팁

다음도 참조하세요.

settings.catchUpTakeoverDelayMillis

electionMetrics.electionTimeout

settings.electionTimeoutMillis 이내에 프라이머리에 도달하지 못했기 때문에 mongod 인스턴스가 호출한 투표에 대한 지표입니다.

electionTimeout에는 호출된 투표의 수와 성공한 투표의 수가 모두 포함됩니다.

팁

다음도 참조하세요.

settings.electionTimeoutMillis

electionMetrics.freezeTimeout

freeze period(멤버가 투표를 신청할 수 없는 기간)이(가) 만료된 후 mongod 인스턴스가 호출한 투표에 대한 지표입니다.

electionMetrics.freezeTimeout에는 호출된 투표의 수와 성공한 투표의 수가 모두 포함됩니다.

electionMetrics.numStepDownsCausedByHigherTerm: mongod 인스턴스가 텀이 더 길다는 이유(특히 다른 멤버가 추가 투표에 참여함)로 사임한 횟수입니다.

electionMetrics.numCatchUps: 새로 선출된 프라이머리인 mongod 인스턴스가 가장 높은 알려진 oplog 항목을 따라잡아야 했던 투표의 수입니다.

electionMetrics.numCatchUpsSucceeded: 새로 선출된 프라이머리인 mongod 인스턴스가 가장 높은 알려진 oplog 항목을 따라잡는 데 성공한 횟수입니다.

electionMetrics.numCatchUpsAlreadyCaughtUp: 새로 선택된 프라이머리인 mongod 인스턴스가 선택을 받았을 때 이미 따라잡았기 때문에 캐치업 프로세스를 종료한 횟수입니다.

electionMetrics.numCatchUpsSkipped: 새로 선출된 프라이머리인 mongod 인스턴스가 캐치업 프로세스를 건너뛴 횟수입니다.

electionMetrics.numCatchUpsTimedOut: 새로 선택된 프라이머리인 mongod 인스턴스가 settings.catchUpTimeoutMillis 한도 때문에 캐치업 프로세스를 종료한 횟수입니다.

electionMetrics.numCatchUpsFailedWithError: 새로 선출된 프라이머리의 캐치업 프로세스가 오류로 실패한 횟수입니다.

electionMetrics.numCatchUpsFailedWithNewTerm: 다른 멤버의 텀이 더 길기 때문에(특히 다른 멤버가 추가 투표에 참여함) 새로 선출된 프라이머리의 캐치업 프로세스가 종료된 횟수입니다.

electionMetrics.numCatchUpsFailedWithReplSetAbortPrimaryCatchUpCmd: mongod이(가) replSetAbortPrimaryCatchUp 명령을 수신했기 때문에 새로 선출된 프라이머리의 캐치업 프로세스가 종료된 횟수입니다.

electionMetrics.averageCatchUpOps: 새로 선출된 프라이머리의 캐치업 프로세스 도중에 적용된 연산의 평균 수입니다.

extra_info

extra_info : {
   note : 'fields vary by platform',
   page_faults : <num>
},

extra_info: 기본 시스템에 대한 추가 정보를 제공하는 문서입니다.

extra_info.note: 텍스트가 포함된 문자열 'fields vary by platform'

extra_info.page_faults

페이지 오류의 총 개수입니다. extra_info.page_faults 카운터는 성능이 저조한 순간에 대폭 증가할 수 있으며, 제한된 메모리 환경 및 대규모 데이터 세트와 상관관계가 있을 수 있습니다. 제한적이고 산발적인 페이지 오류가 반드시 문제를 나타내는 것은 아닙니다.

Windows는 디스크 I/O와 관련 있는 "하드" 페이지 오류와 메모리 내 페이지 이동만을 요하는 "소프트" 페이지 오류를 서로 구분합니다. MongoDB는 이 통계에서 하드 페이지 오류와 소프트 페이지 오류를 둘 다 계산합니다.

flowControl

flowControl : {
   enabled : <boolean>,
   targetRateLimit : <int>,
   timeAcquiringMicros : Long("<num>"),
   locksPerKiloOp : <double>,
   sustainerRate : <int>,
   isLagged : <boolean>,
   isLaggedCount : <int>,
   isLaggedTimeMicros : Long("<num>")
},

flowControl: Flow Control(흐름 제어)에 대한 통계를 반환하는 문서입니다. 흐름 제어가 활성화된 상태에서 majority commit 지점 지연이 flowControlTargetLagSeconds에 가까워지면, 프라이머리에 대한 쓰기에서는 잠금을 받기 전에 티켓을 얻어야 합니다. 따라서 반환된 지표는 프라이머리에서 실행될 때 유의미합니다.

flowControl.enabled

Flow Control(흐름 제어)가 활성화(true)되었는지, 아니면 비활성화(false)되었는지 여부를 나타내는 부울입니다.

enableFlowControl도 참조하세요.

flowControl.targetRateLimit

프라이머리에서 실행할 때 1초당 획득할 수 있는 최대 티켓 수입니다.

세컨더리에서 실행될 때 반환된 숫자는 자리 표시자에 해당합니다.

flowControl.timeAcquiringMicros

프라이머리에서 실행될 때 쓰기 연산이 티켓을 획득하기 위해 대기한 총 시간입니다.

세컨더리에서 실행될 때 반환된 숫자는 자리 표시자에 해당합니다.

flowControl.locksPerKiloOp

프라이머리에서 실행될 때 연산 1,000건당 받을 수 있는 잠금의 대략적인 수입니다.

세컨더리에서 실행될 때 반환된 숫자는 자리 표시자에 해당합니다.

flowControl.sustainerRate

프라이머리에서 실행될 때 커밋 지점을 유지하고 있는 세컨더리에서 1초당 적용하는 연산의 근사치입니다.

세컨더리에서 실행될 때 반환된 숫자는 자리 표시자에 해당합니다.

flowControl.isLagged

프라이머리에서 실행될 때 흐름 제어가 적용되었는지 여부를 나타내는 부울입니다. 대부분의 커밋 지연이 구성된 flowControlTargetLagSeconds의 일정 비율보다 커지면 흐름 제어가 적용됩니다.

흐름 제어를 적용하지 않으면 복제 지연이 발생할 수 있습니다. 무응답 세컨더리는 흐름 제어를 수행할 만큼 충분한 로드를 받는 복제본 세트가 없으면 지연될 수 있어 flowControl.isLagged 값이 false (으)로 남을 수 있습니다.

자세한 내용은 Flow Control(흐름 제어)을(를) 참조하세요.

flowControl.isLaggedCount

프라이머리에서 실행될 때 마지막 재시작 이후 흐름 제어가 적용된 횟수입니다. 대부분의 커밋 지연이 구성된 flowControlTargetLagSeconds의 일정 비율보다 커지면 흐름 제어가 적용됩니다.

세컨더리에서 실행될 때 반환된 숫자는 자리 표시자에 해당합니다.

flowControl.isLaggedTimeMicros

프라이머리에서 실행될 때 마지막 재시작 이후 흐름 제어가 적용되는 데 소요된 시간의 양입니다. 대부분의 커밋 지연이 구성된 flowControlTargetLagSeconds의 일정 비율보다 커지면 흐름 제어가 적용됩니다.

세컨더리에서 실행될 때 반환된 숫자는 자리 표시자에 해당합니다.

globalLock

globalLock : {
   totalTime : Long("<num>"),
   currentQueue : {
      total : <num>,
      readers : <num>,
      writers : <num>
   },
   activeClients : {
      total : <num>,
      readers : <num>,
      writers : <num>
   }
},

globalLock

데이터베이스의 잠금 상태를 보고하는 문서입니다.

잠금 문서는 일반적으로 잠금 사용에 대해 보다 자세한 데이터를 제공합니다.

globalLock.totalTime: 데이터베이스가 마지막으로 시작되어 globalLock을 생성한 이후로 경과한 시간(단위: 마이크로초)입니다. 이 값은 총 서버 가동 시간과 거의 동일합니다.

globalLock.currentQueue: 잠금 때문에 대기열에 있는 연산의 수에 관한 정보를 제공하는 문서입니다.

globalLock.currentQueue.total

잠금을 기다리면서 대기열에 있는 총 연산 수(즉, globalLock.currentQueue.readers와 globalLock.currentQueue.writers의 합계)입니다.

일관적으로 작은 대기열, 특히 짧은 연산의 대기열은 걱정할 필요가 없습니다. globalLock.activeClients 판독기 및 기록기 정보는 이 데이터에 대한 컨텍스트를 제공합니다.

globalLock.currentQueue.readers: 현재 대기열에 있으면서 읽기 잠금(read lock)을 기다리고 있는 연산의 수입니다. 일관적으로 작은 읽기 대기열, 특히 짧은 연산의 대기열은 걱정할 필요가 없습니다.

globalLock.currentQueue.writers: 현재 대기열에 있으면서 쓰기 잠금(write lock)을 기다리고 있는 연산의 수입니다. 일관적으로 작은 쓰기 대기열, 특히 짧은 연산의 대기열은 걱정할 필요가 없습니다.

globalLock.activeClients

연결된 클라이언트 수와 해당 클라이언트가 실행한 읽기 및 쓰기 연산에 대한 정보를 제공하는 문서입니다.

globalLock.currentQueue 데이터에 대한 컨텍스트를 제공하려면 이 데이터를 사용하세요.

globalLock.activeClients.total: 데이터베이스에 대한 내부 클라이언트 연결(시스템 스레드와 대기 중인 판독기 및 기록기 포함)의 총 건수입니다. 이 지표는 시스템 스레드를 포함하기 때문에 activeClients.readers와(과) activeClients.writers의 총합보다 높습니다.

globalLock.activeClients.readers: 읽기 연산을 수행하는 활성 클라이언트 연결의 건수입니다.

globalLock.activeClients.writers: 쓰기 연산을 수행하는 활성 클라이언트 연결의 건수입니다.

hedgingMetrics

중요

MongoDB 8.0 부터 헤지된 읽기(hedged read)는 더 이상 사용되지 않습니다. 읽기 설정 nearest 을 지정하는 쿼리는 더 이상 기본적으로 헤지된 읽기(hedged read)를 사용하지 않습니다. 헤지된 읽기(hedged read)를 명시적으로 지정하면 MongoDB는 헤지된 읽기(hedged read)를 수행하고 경고를 기록합니다.

mongos 인스턴스에만 해당됩니다.

hedgingMetrics : {
   numTotalOperations : <num>,
   numTotalHedgedOperations : <num>,
   numAdvantageouslyHedgedOperations : <num>
},

hedgingMetrics

mongos 인스턴스에 대한 헤지된 읽기(hedged read)의 지표를 제공합니다.

mongos 인스턴스에만 해당됩니다.

hedgingMetrics.numTotalOperations

이 mongos 인스턴스에 대해 헤지된 읽기(hedged read) 옵션 활성화가 된 상태로 실행된 연산의 총 건수입니다.

mongos 인스턴스에만 해당됩니다.

hedgingMetrics.numTotalHedgedOperations

mongos 인스턴스가 읽기 연산 헤지를 한(즉, 쿼리된 각 샤드의 추가 멤버로 연산을 전송한) 모든 연산의 건수입니다.

mongos 인스턴스에만 해당됩니다.

hedgingMetrics.numAdvantageouslyHedgedOperations

읽기 연산 헤지를 하기 위해 전송된 추가 읽기가 클라이언트 요청을 이행한 연산의 총 건수입니다.

mongos 인스턴스에만 해당됩니다.

indexBuilds

indexBuilds : {
   total : <num>,
   killedDueToInsufficientDiskSpace : <num>,
   failedDueToDataCorruption : <num>
},

indexBuilds: 서버가 마지막으로 시작된 이후의 인덱스 빌드 에 대한 지표를 제공합니다.

indexBuilds.total: 총 인덱스 빌드 수입니다.

indexBuilds.killedDueToInsufficientDiskSpace: 디스크 공간 부족으로 인해 종료된 인덱스 빌드의 총 개수입니다. MongoDB 7.1부터는 indexBuildMinAvailableDiskSpaceMB 매개변수를 사용하여 인덱스 빌드에 필요한 최소 디스크 공간을 설정할 수 있습니다.
버전 7.1에 새로 추가되었습니다.

indexBuilds.failedDueToDataCorruption: 데이터 손상으로 인해 실패한 인덱스 빌드의 총 개수입니다.
버전 7.1에 새로 추가되었습니다.

indexBulkBuilder

indexBulkBuilder: {
   count: <long>,
   resumed: <long>,
   filesOpenedForExternalSort: <long>,
   filesClosedForExternalSort: <long>,
   spilledRanges: <long>,
   bytesSpilledUncompressed: <long>,
   bytesSpilled: <long>,
   numSorted: <long>,
   bytesSorted: <long>,
   memUsage: <long>
}

indexBulkBuilder: 인덱스 대량 빌더 연산에 대한 지표를 제공합니다. createIndexes에서 발생하는 인덱스 빌드 문제, 초기 동기화 중 컬렉션 복제, 시작 후 재개되는 인덱스 빌드, 외부 분류기의 디스크 사용량 통계를 진단하려면 이 지표를 사용하세요.

indexBuildBuilder.bytesSpilled: 버전 6.0.4의 신규 항목입니다.
외부 정렬기가 디스크에 기록한 바이트의 수입니다.

indexBuilder.bytesSpilledUncompressed: 버전 6.0.4의 신규 항목입니다.
압축 전에 외부 정렬기가 디스크에 기록해야 하는 바이트의 수입니다.

indexBulkBuilder.count: 생성된 대량 빌더의 인스턴스 수입니다.

indexBulkBuilder.filesClosedForExternalSort: 외부 정렬기가 파일 핸들을 닫아 데이터를 디스크로 유출시킨 횟수입니다. 외부 정렬기에서 사용 중인 열린 파일 핸들 수를 파악하려면 이 값을 filesOpenedForExternalSort와 결합합니다.

indexBulkBuilder.filesOpenedForExternalSort: 외부 정렬기가 파일 핸들을 열어 데이터를 디스크로 유출시킨 횟수입니다. 외부 정렬기에서 사용 중인 열린 파일 핸들 수를 파악하려면 이 값을 filesClosedForExternalSort와(과) 결합하세요.

indexBulkBuilder.resumed: 재개 가능한 인덱스 빌드에 맞게 대량 빌더가 생성된 횟수입니다.

indexBulkBuilder.spilledRanges: 버전 6.0.4의 신규 항목입니다.
외부 정렬기가 디스크로 유출된 횟수입니다.

indexBulkBuilder.numSorted: 버전 6.3에 추가.
정렬된 문서의 총 개수입니다.

indexBulkBuilder.bytesSorted: 버전 6.3에 추가.
정렬된 문서의 총 바이트 수입니다. 그 예로 총 10개의 문서가 정렬되었고 각 문서가 20바이트인 경우, 정렬된 바이트의 총 수는 200입니다.

indexBulkBuilder.memUsage: 버전 6.3에 추가.
인덱스 빌딩을 위해 할당된 메모리의 현재 바이트입니다.

indexStats

indexStats: {
   count: Long("<num>"),
   features: {
      '2d': { count: Long("<num>"), accesses: Long("<num>") },
      '2dsphere': { count: Long("<num>"), accesses: Long("<num>") },
      '2dsphere_bucket': { count: Long("<num>"), accesses: Long("<num>") },
      collation: { count: Long("<num>"), accesses: Long("<num>") },
      compound: { count: Long("<num>"), accesses: Long("<num>") },
      hashed: { count: Long("<num>"), accesses: Long("<num>") },
      id: { count: Long("<num>"), accesses: Long("<num>") },
      normal: { count: Long("<num>"), accesses: Long("<num>") },
      partial: { count: Long("<num>"), accesses: Long("<num>") },
      prepareUnique: { count: Long("<num>"), accesses: Long("<num>") }, // Added in 8.0.4 (and 7.0.14)
      single: { count: Long("<num>"), accesses: Long("<num>") },
      sparse: { count: Long("<num>"), accesses: Long("<num>") },
      text: { count: Long("<num>"), accesses: Long("<num>") },
      ttl: { count: Long("<num>"), accesses: Long("<num>") },
      unique: { count: Long("<num>"), accesses: Long("<num>") },
      wildcard: { count: Long("<num>"), accesses: Long("<num>") }
   }
}

indexStats: 데이터베이스 및 컬렉션의 모든 인덱스에 대한 통계를 보고하는 문서입니다.
버전 6.0에 추가.

indexStats.count: 총 인덱스 수입니다.
버전 6.0에 추가.

indexStats.features: 각 인덱스 유형과 각 인덱스에 대한 액세스 횟수에 대한 카운터를 제공하는 문서입니다. indexStats.features 의 각 인덱스 유형에는 해당 유형의 총 인덱스 수를 계산하는 count 필드와 해당 인덱스에 대한 액세스 수를 계산하는 accesses 필드가 있습니다.
버전 6.0에 추가.

인스턴스 정보

host : <string>,
advisoryHostFQDNs : <array>,
version : <string>,
process : <'mongod'|'mongos'>,
service : <'router'|'shard'>,
pid : Long("<num>"),
uptime : <num>,
uptimeMillis : Long("<num>"),
uptimeEstimate : Long("<num>"),
localTime : ISODate("<Date>"),

host: 시스템의 호스트 이름입니다. Unix/Linux 시스템에서 이 값은 hostname 명령의 출력과 동일해야 합니다.

advisoryHostFQDNs: 시스템 측 FQDN(fully qualified domain name, 정규화된 도메인 이름)의 배열입니다.

version: 현행 MongoDB 프로세스의 MongoDB 버전입니다.

process: 현행 MongoDB 프로세스입니다. 가능한 값은 mongos 또는 mongod입니다.

service: 현재 MongoDB 프로세스의 역할입니다. 가능한 값은 router 또는 shard입니다.
버전 8.0에 추가 되었습니다.

pid: 프로세스 ID 번호입니다.

uptime: 현행 MongoDB 프로세스가 활성화된 초의 수치입니다.

uptimeMillis: 현행 MongoDB 프로세스가 활성화된 밀리초의 수치입니다.

uptimeEstimate: MongoDB의 내부 코스별 시간 관리 시스템에서 계산된 가동 시간(단위: 초)입니다.

localTime: 현재 시간(서버에 따름)을 UTC로 나타내는 ISODate입니다.

잠금

locks : {
   <type> : {
         acquireCount : {
            <mode> : Long("<num>"),
            ...
         },
         acquireWaitCount : {
            <mode> : Long("<num>"),
            ...
         },
         timeAcquiringMicros : {
            <mode> : Long("<num>"),
            ...
         },
         deadlockCount : {
            <mode> : Long("<num>"),
            ...
         }
   },
   ...

locks

락 <type>별로 락 <modes>에 대한 데이터를 보고하는 문서입니다.

가능한 락 <types>은(는) 다음과 같습니다.

잠금 유형	설명
`ParallelBatchWriterMode`	병렬 배치 쓰기 모드의 잠금을 나타냅니다. 이전 버전에서는 PBWM 정보가 `Global` 잠금 정보의 일부로 보고되었습니다.
`ReplicationStateTransition`	레플리카 세트 멤버 상태 전환에 취한 잠금을 나타냅니다.
`Global`	글로벌 락을 나타냅니다.
`Database`	데이터베이스 락을 나타냅니다.
`Collection`	컬렉션 락을 나타냅니다.
`Mutex`	뮤텍스를 나타냅니다.
`Metadata`	메타데이터 락을 나타냅니다.
`DDLDatabase`	DDL 데이터베이스 잠금을 나타냅니다. 버전 7.1에 새로 추가되었습니다.
`DDLCollection`	DDL collection 잠금을 나타냅니다. 버전 7.1에 새로 추가되었습니다.
`oplog`	oplog 락을 나타냅니다.

가능한 <modes>은(는) 다음과 같습니다.

잠금 모드	설명
`R`	공유(S) 락을 나타냅니다.
`W`	독점(X) 락을 나타냅니다.
`r`	인텐트 공유(IS) 락을 나타냅니다.
`w`	인텐트 독점(IX) 락을 나타냅니다.

모든 값은 Long() 유형에 속합니다.

locks.<type>.acquireCount: 지정된 모드에서 잠금을 획득한 횟수입니다.

locks.<type>.acquireWaitCount: 잠금이 충돌 모드에서 유지되었기 때문에 locks.<type>.acquireCount 잠금 획득 대기가 발생한 횟수입니다.

locks.<type>.timeAcquiringMicros

잠금 획득의 누적 대기 시간(단위: 마이크로초)입니다.

locks.<type>.timeAcquiringMicros를 locks.<type>.acquireWaitCount로 나누면 특정 잠금 모드의 대략적인 평균 대기 시간을 구할 수 있습니다.

locks.<type>.deadlockCount: 잠금 획득이 교착 상태에 빠진 횟수입니다.

logicalSessionRecordCache

logicalSessionRecordCache : {
   activeSessionsCount : <num>,
   sessionsCollectionJobCount : <num>,
   lastSessionsCollectionJobDurationMillis : <num>,
   lastSessionsCollectionJobTimestamp : <Date>,
   lastSessionsCollectionJobEntriesRefreshed : <num>,
   lastSessionsCollectionJobEntriesEnded : <num>,
   lastSessionsCollectionJobCursorsClosed : <num>,
   transactionReaperJobCount : <num>,
   lastTransactionReaperJobDurationMillis : <num>,
   lastTransactionReaperJobTimestamp : <Date>,
   lastTransactionReaperJobEntriesCleanedUp : <num>,
   sessionCatalogSize : <num>
},

logicalSessionRecordCache: 서버 세션의 캐싱에 대한 지표를 제공합니다.

logicalSessionRecordCache.activeSessionsCount

마지막 새로고침 기간 이후 mongod 또는 mongos 인스턴스가 메모리에 캐싱한 모든 활성 로컬 세션의 수입니다.

팁

다음도 참조하세요.

logicalSessionRecordCache.sessionsCollectionJobCount: config.system.sessions 컬렉션에서 새로고침 프로세스가 실행된 횟수를 추적하는 숫자입니다.
팁
다음도 참조하세요.
logicalSessionRefreshMillis

logicalSessionRecordCache.lastSessionsCollectionJobDurationMillis: 마지막 새로고침의 길이(단위: 밀리초)입니다.

logicalSessionRecordCache.lastSessionsCollectionJobTimestamp: 마지막 새로고침이 발생한 시간입니다.

logicalSessionRecordCache.lastSessionsCollectionJobEntriesRefreshed: 마지막 새로고침 중에 새로 고쳐진 세션의 수입니다.

logicalSessionRecordCache.lastSessionsCollectionJobEntriesEnded: 마지막 새로고침 중에 종료된 세션의 수입니다.

logicalSessionRecordCache.lastSessionsCollectionJobCursorsClosed: 마지막 config.system.sessions 컬렉션 새로고침 중에 닫힌 커서의 수입니다.

logicalSessionRecordCache.transactionReaperJobCount: config.transactions 컬렉션에서 트랜잭션 레코드 정리 프로세스가 실행된 횟수를 추적하는 숫자입니다.

logicalSessionRecordCache.lastTransactionReaperJobDurationMillis: 마지막 트랜잭션 레코드 정리의 길이(단위: 밀리초)입니다.

logicalSessionRecordCache.lastTransactionReaperJobTimestamp: 마지막 트랜잭션 레코드 정리에 소요된 시간입니다.

logicalSessionRecordCache.lastTransactionReaperJobEntriesCleanedUp: 마지막 트랜잭션 레코드 정리 중에 삭제된 config.transactions 컬렉션의 항목 수입니다.

logicalSessionRecordCache.sessionCatalogSize

mongod 인스턴스의 경우,
config.transactions 항목의 메모리 내 캐시 크기입니다. 이 값은 localLogicalSessionTimeoutMinutes 이내에 세션이 만료되지 않은 재시도 가능 쓰기 또는 트랜잭션에 해당합니다.
mongos 인스턴스의 경우,
가장 최근의 localLogicalSessionTimeoutMinutes 간격 내에 트랜잭션이 있었던 세션의 메모리 내 캐시 수입니다.

mem

mem : {
   bits : <int>,
   resident : <int>,
   virtual : <int>,
   supported : <boolean>
},

mem: mongod의 시스템 아키텍처와 현재 메모리 사용에 대해 보고하는 문서입니다.

mem.bits: MongoDB 인스턴스가 64비트 또는 32비트 아키텍처에 맞게 컴파일되었는지 여부를 나타내는 숫자(64 또는 32)입니다.

mem.resident: mem.resident의 값은 현재 데이터베이스 프로세스에서 사용 중인 RAM의 양(단위: 메비바이트[MiB])과 거의 동일합니다. 이 값은 정상적으로 사용하는 동안 증가하는 경향이 있습니다. 이 숫자는 전용 데이터베이스 서버에서 시스템 메모리의 총량에 근접해지는 경향이 있습니다.

mem.virtual: mem.virtual은 mongod 프로세스에서 사용하는 가상 메모리의 양을 메비바이트(MiB) 단위로 표시합니다.

mem.supported: 기본 시스템이 확장 메모리 정보를 지원하는지 여부를 나타내는 부울입니다. 이 값이 false(거짓)이고 시스템이 확장 메모리 정보를 지원하지 않는 경우에는 데이터베이스 서버에서 다른 mem 값에 액세스하지 못할 수 있습니다.

mem.note

mem.supported이(가) false(거짓)이면 mem.note 필드가 나타납니다.

mem.note 필드에는 'not all mem info support on this platform' 텍스트가 포함되어 있습니다.

지표

metrics : {
   abortExpiredTransactions: {
      passes: <integer>
   },
   apiVersions: {
      <appName1>: <string>,
      <appName2>: <string>,
      <appName3>: <string>
   },
   aggStageCounters : {
      <aggregation stage> : Long("<num>")
   },
   changeStreams: {
      largeEventsFailed: Long("<num>"),
      largeEventsSplit: Long("<num>"),
      showExpandedEvents: Long("<num>")
   },
   commands: {
      <command>: {
         failed: Long("<num>"),
         validator: {
           total: Long("<num>"),
           failed: Long("<num>"),
           jsonSchema: Long("<num>")
         },
         total: Long("<num>"),
         rejected: Long("<num>")
      }
   },
   cursor : {
      moreThanOneBatch : Long("<num>"),
      timedOut : Long("<num>"),
      totalOpened : Long("<num>"),
      lifespan : {
         greaterThanOrEqual10Minutes : Long("<num>"),
         lessThan10Minutes : Long("<num>"),
         lessThan15Seconds : Long("<num>"),
         lessThan1Minute : Long("<num>"),
         lessThan1Second : Long("<num>"),
         lessThan30Seconds : Long("<num>"),
         lessThan5Seconds : Long("<num>")
      },
      open : {
         noTimeout : Long("<num>"),
         pinned : Long("<num>"),
         multiTarget : Long("<num>"),
         singleTarget : Long("<num>"),
         total : Long("<num>")
      }
   },
   document : {
      deleted : Long("<num>"),
      inserted : Long("<num>"),
      returned : Long("<num>"),
      updated : Long("<num>")
   },
   dotsAndDollarsFields : {
         inserts : Long("<num>"),
         updates : Long("<num>")
   },
   getLastError : {
      wtime : {
         num : <num>,
         totalMillis : <num>
      },
      wtimeouts : Long("<num>"),
      default : {
         unsatisfiable : Long("<num>"),
         wtimeouts : Long("<num>")
      }
   },
   mongos : {
      cursor : {
         moreThanOneBatch : Long("<num>"),
         totalOpened : Long("<num>")
      }
   },
   network : {  // Added in MongoDB 6.3
      totalEgressConnectionEstablishmentTimeMillis : Long("<num>"),
      totalIngressTLSConnections : Long("<num>"),
      totalIngressTLSHandshakeTimeMillis : Long("<num>"),
      totalTimeForEgressConnectionAcquiredToWireMicros : Long("<num>"),
      totalTimeToFirstNonAuthCommandMillis : Long("<num>")
   },
   operation : {
      killedDueToClientDisconnect : Long("<num>"),  // Added in MongoDB 7.1
      killedDueToDefaultMaxTimeMSExpired : Long("<num>"),
      killedDueToMaxTimeMSExpired : Long("<num>"),  // Added in MongoDB 7.2
      numConnectionNetworkTimeouts : Long("<num>"),  // Added in MongoDB 6.3
      scanAndOrder : Long("<num>"),
      totalTimeWaitingBeforeConnectionTimeoutMillis : Long("<num>"),  // Added in MongoDB 6.3
      unsendableCompletedResponses : Long("<num>"),  // Added in MongoDB 7.1
      writeConflicts : Long("<num>")
   },
   operatorCounters : {
      expressions : {
         <command> : Long("<num>")
      },
      match : {
         <command> : Long("<num>")
      }
   },
   query: {
      allowDiskUseFalse: Long("<num>"),
      updateOneOpStyleBroadcastWithExactIDCount: Long("<num>"),
      lookup: {
         hashLookup: Long("<num>"),
         hashLookupSpillToDisk: Long("<num>"),
         indexedLoopJoin: Long("<num>"),
         nestedLoopJoin: Long("<num>")
      },
      multiPlanner: {
         classicCount: Long("<num>"),
         classicMicros: Long("<num>"),
         classicWorks: Long("<num>"),
         sbeCount: Long("<num>"),
         sbeMicros: Long("<num>"),
         sbeNumReads: Long("<num>"),
         histograms: {
            classicMicros: [
               { lowerBound: Long("0"), count: Long("<num>") },
               { < Additional histogram groups not shown. > },
               { lowerBound: Long("1073741824"), count: Long("<num>")> }>
            ],
            classicNumPlans: [
               { lowerBound: Long("0"), count: Long("<num>") },
               { < Additional histogram groups not shown. > },
               { lowerBound: Long("32"), count: Long("<num>") }
            ],
            classicWorks: [
               { lowerBound: Long("0"), count: Long("<num>") },
               { < Additional histogram groups not shown. > },
               { lowerBound: Long("32768"), count: Long("<num>") }
            ],
            sbeMicros: [
               { lowerBound: Long("0"), count: Long("<num>") },
               { < Additional histogram groups not shown. > },
               { lowerBound: Long("1073741824"), count: Long("<num>") }
            ],
            sbeNumPlans: [
               { lowerBound: Long("0"), count: Long("<num>") },
               { < Additional histogram groups not shown. > },
               { lowerBound: Long("32"), count: Long("<num>") }
            ],
            sbeNumReads: [
               { lowerBound: Long("0"), count: Long("<num>") },
               { < Additional histogram groups not shown. > },
               { lowerBound: Long("32768"), count: Long("<num>") }
            ]
         }
      },
      planCache: {
         classic: { hits: Long("<num>"), misses: Long("<num>") },
         sbe: { hits: Long("<num>"), misses: Long("<num>") }
      },
      queryFramework: {
         aggregate: {
            classicHybrid: Long("<num>"),
            classicOnly: Long("<num>"),
            cqf: Long("<num>"),
            sbeHybrid: Long("<num>"),
            sbeOnly: Long("<num>")
         },
         find: { classic: Long("<num>"), cqf: Long("<num>"), sbe: Long("<num>") }
      }
   },
   queryExecutor: {
      scanned : Long("<num>"),
      scannedObjects : Long("<num>"),
      collectionScans : {
         nonTailable : Long("<num>"),
         total : Long("<num>")
      }
   },
   record : {
      moves : Long("<num>")
   },
   repl : {
      executor : {
         pool : {
            inProgressCount : <num>
         },
         queues : {
            networkInProgress : <num>,
            sleepers : <num>
         },
         unsignaledEvents : <num>,
         shuttingDown : <boolean>,
         networkInterface : <string>
      },
      apply : {
         attemptsToBecomeSecondary : Long("<num>"),
         batchSize: <num>,
         batches : {
            num : <num>,
            totalMillis : <num>
         },
         ops : Long("<num>")
      },
      write : {
         batchSize: <num>,
         batches : {
            num : <num>,
            totalMillis : <num>
         }
      },
      buffer : {
         write: {
            count : Long("<num>"),
            maxSizeBytes : Long("<num>"),
            sizeBytes : Long("<num>")
         },
         apply: {
            count : Long("<num>"),
            sizeBytes : Long("<num>"),
            maxSizeBytes : Long("<num>"),
            maxCount: Long("<num>")
         },
      },
      initialSync : {
         completed : Long("<num>"),
         failedAttempts : Long("<num>"),
         failures : Long("<num>")
      },
      network : {
         bytes : Long("<num>"),
         getmores : {
            num : <num>,
            totalMillis : <num>
         },
         notPrimaryLegacyUnacknowledgedWrites : Long("<num>"),
         notPrimaryUnacknowledgedWrites : Long("<num>"),
         oplogGetMoresProcessed : {
            num : <num>,
            totalMillis : <num>
         },
         ops : Long("<num>"),
         readersCreated : Long("<num>"),
         replSetUpdatePosition : {
            num : Long("<num>")
         }
      },
      reconfig : {
         numAutoReconfigsForRemovalOfNewlyAddedFields : Long("<num>")
      },
      stateTransition : {
         lastStateTransition : <string>,
         totalOperationsKilled : Long("<num>"),
         totalOperationsRunning : Long("<num>")
      },
      syncSource : {
         numSelections : Long("<num>"),
         numTimesChoseSame : Long("<num>"),
         numTimesChoseDifferent : Long("<num>"),
         numTimesCouldNotFind : Long("<num>")
      },
      waiters : {
         opTime : Long("<num>"),
         replication : Long("<num>")
      }
   },
   storage : {
      freelist : {
         search : {
            bucketExhausted : <num>,
            requests : <num>,
            scanned : <num>
         }
      }
   },
   ttl : {
      deletedDocuments : Long("<num>"),
      passes : Long("<num>"),
      subPasses : Long("<num>")
   }
}

metrics: 실행 중인 mongod 인스턴스의 현재 사용 및 상태가 반영된 다양한 통계를 반환하는 문서입니다.

metrics.abortExpiredTransactions: abortExpiredTransactions 스레드의 현재 상태에 대한 통계를 반환하는 문서입니다.

metrics.abortExpiredTransactions.passes

transactionLifetimeLimitSeconds 매개변수보다 오래된 트랜잭션을 중단한 성공적인 전달의 수를 나타냅니다.

passes 값 증가가 중지되면 abortExpiredTransactions 스레드가 멈췄을 수 있음을 나타냅니다.

metrics.aggStageCounters

집계 파이프라인 단계 사용에 대해 보고하는 문서입니다. metrics.aggStageCounters의 필드는 집계 파이프라인 단계의 이름입니다. serverStatus는 각 파이프라인 단계에 대해 해당 단계가 실행된 횟수를 보고합니다.

버전 5.2(및 5.0.6)에서 업데이트되었습니다.

metrics.apiVersions

다음 내용이 포함된 문서입니다.

각 클라이언트 애플리케이션의 이름
지난 24시간 이내에 각 애플리케이션이 구성된 Stable API 버전

metrics.apiVersions을(를) 볼 때 다음 사항을 고려하세요.

각 appname에 대해 반환 가능한 값은 다음과 같습니다.
- default: Stable API 버전이 지정되지 않은 상태에서 명령이 실행되었습니다.
- 1: Stable API 버전 1로 명령이 실행되었습니다.
참고
명령 레벨에서 Stable API 버전을 지정할 수 있으므로 appname의 두 반환 값이 모두 표시될 수 있습니다. 일부 명령이 Stable API 버전 없이 실행되었을 수 있는 반면, 다른 명령은 버전 1로 실행되었습니다.
API 버전 지표는 24시간 동안 유지됩니다. 지난 24시간 동안 애플리케이션에서 특정 API 버전으로 명령이 없는 실행되지 않은 경우, 해당 appname 및 API 버전은 지표에서 제거됩니다. 이는 default API 버전 지표에도 적용됩니다.
연결 URI에 appname을(를) 지정하여 MongoDB 인스턴스에 연결할 때 appname을(를) 설정하세요. ?appName=ZZZ은(는) appname을(를) ZZZZ(으)로 설정합니다.
Stable API에 액세스하는 드라이버는 기본 appname을(를) 설정할 수 있습니다.
appname이 구성되지 않으면 제품에 따라 기본값이 자동으로 채워집니다. 그 예로 URI에 appname이 없는 MongoDB Compass 연결에서는 'MongoDB Compass': [ 'default' ] 지표가 반환됩니다.

버전 5.0의 신규 항목입니다.

metrics.operatorCounters: 집계 파이프라인 연산자 및 표현식 사용에 대해 보고하는 문서입니다.

metrics.operatorCounters.expressions

Expression Operators(표현식 연산자)의 실행 빈도를 나타내는 숫자가 포함된 문서입니다.

보다 큰 연산자($gt) 등 특정 연산자의 지표를 가져오려면 다음과 같이 연산자를 명령에 추가하세요.

db.runCommand( { serverStatus: 1 } ).metrics.operatorCounters.expressions.$gt

버전 5.0에 추가.

metrics.operatorCounters.match

표현식 일치의 실행 빈도를 나타내는 숫자가 포함된 문서입니다.

표현식 연산자 일치은(는) 집계 파이프라인 $match 단계의 일환으로서 증가하기도 합니다. $match 단계에서 $expr 연산자를 사용할 경우 $expr의 카운터는 증가하지만, 구성 요소 카운터는 증가하지 않습니다.

다음 쿼리를 생각해 보세요.

db.matchCount.aggregate(
   [
      { $match:
         {  $expr: { $gt: [ "$_id", 0 ] } }
      }
   ]
)

쿼리가 실행되면 $expr의 카운터가 증가합니다. $gt의 카운터는 증가하지 않습니다.

metrics.changeStreams.largeEventsSplit: 작은 조각으로 분할되었으며 16MB보다 큰 변경 스트림 이벤트의 수입니다. 이벤트는 $changeStreamSplitLargeEvent 파이프라인 단계를 사용하는 경우에만 분할됩니다.
버전 7.0에 새로 추가됨 : (6.0.9 에서도 사용 가능)

metrics.changeStreams: 16MB보다 큰 변경 스트림 이벤트에 대한 정보를 보고하는 문서입니다.
버전 7.0에 추가.

metrics.changeStreams.largeEventsFailed: 이벤트가 16MB보다 커서 BSONObjectTooLarge 예외를 발생시킨 변경 스트림 이벤트의 수입니다. 예외를 방지하려면 $changeStreamSplitLargeEvent을(를) 참조하세요.
버전 7.0 의 새로운 기능: ( 6.0.9 및 5.0.19에서도 사용 가능)

metrics.changeStreams.showExpandedEvents

showExpandedEvents 옵션이 true 로 설정된 change stream 커서의 개수입니다.

다음과 같은 경우 showExpandedEvents 의 카운터가 증가합니다.

change stream 커서를 엽니다.
change stream 커서에서 explain 명령을 실행합니다.

버전 7.1에 새로 추가되었습니다.

metrics.commands

데이터베이스 명령 사용에 대해 보고하는 문서입니다. metrics.commands의 필드는 데이터베이스 명령의 이름입니다. serverStatus은(는) 각 명령에 대해 총 실행 수와 실패한 실행 수를 보고합니다.

metrics.commands에는 replSetStepDownWithForce(예: replSetStepDown이 포함된 force: true 명령)는 물론 전체 replSetStepDown도 포함됩니다. 이전 버전에서는 이 명령이 전체 replSetStepDown 지표만 보고했습니다.

metrics.commands.<command>.failed: 이 mongod에서 <command>이(가) 실패한 횟수입니다.

metrics.commands.<create or collMod>.validator: create 및 collMod 명령의 경우, 컬렉션의 유효성 검사 규칙 또는 표현식을 지정하기 위해 명령에 전달된 비어 있지 않은 validator 객체에 대해 보고하는 문서입니다.

metrics.commands.<create or collMod>.validator.total: 이 mongod에서 비어 있지 않은 validator 객체가 명령에 옵션으로 전달된 횟수입니다.

metrics.commands.<create or collMod>.validator.failed: 스키마 유효성 검사로 인해 비어 있지 않은 validator 객체에서 이 mongod 명령 호출이 실패한 횟수입니다.

metrics.commands.<create or collMod>.validator.jsonSchema: $jsonSchema가 포함된 validator 객체가 이 mongod의 명령에 옵션으로 전달된 횟수입니다.

metrics.commands.<command>.total: 이 mongod에서 <command>이(가) 실행된 횟수입니다.

metrics.commands.<command>.rejected

명령이나 작업에 reject 필드가 true인 관련 쿼리 설정이 있기 때문에 이 mongod에서 <command>가 거부된 횟수입니다.

reject 필드를 설정하려면 setQuerySettings를 사용하세요.

버전 8.0에 추가 되었습니다.

metrics.commands.update.pipeline

이 mongod에서 문서 업데이트에 집계 파이프라인이 사용된 횟수입니다. 총 업데이트 수에서 이 값을 빼면 문서 구문으로 수행한 업데이트의 수를 구할 수 있습니다.

pipeline 카운터는 update 및 findAndModify 작업에서만 사용할 수 있습니다.

metrics.commands.findAndModify.pipeline

이 mongod에서 문서 업데이트를 위한 집계 파이프라인에 findAndModify()이(가) 사용된 횟수입니다.

pipeline 카운터는 update 및 findAndModify 작업에서만 사용할 수 있습니다.

metrics.commands.update.arrayFilters

이 mongod에서 문서 업데이트에 arrayFilter이(가) 사용된 횟수입니다.

arrayFilters 카운터는 update 및 findAndModify 작업에서만 사용할 수 있습니다.

metrics.commands.findAndModify.arrayFilters

이 mongod에서 문서 업데이트에 findAndModify()와(과) 함께 arrayFilter이(가) 사용된 횟수입니다.

arrayFilters 카운터는 update 및 findAndModify 작업에서만 사용할 수 있습니다.

metrics.document: 문서 액세스 권한 및 수정 패턴을 반영하는 문서입니다. 이 값을 총 연산 수를 추적하는 opcounters 문서의 데이터와 비교하세요.

metrics.document.deleted: 삭제된 문서의 총 개수입니다.

metrics.document.inserted: 삽입된 문서의 총 개수입니다.

metrics.document.returned: 쿼리로 반환된 문서의 총 개수입니다.

metrics.document.updated: 업데이트 작업과 일치한 문서의 총 개수입니다. 이 값은 업데이트로 수정된 문서의 수와 반드시 동일하지는 않습니다.

metrics.dotsAndDollarsFields

이름 앞에 붙은 달러($) 기호를 이용한 삽입 또는 업데이트 작업의 실행 빈도를 나타내는 숫자가 포함된 문서입니다. 이 값은 정확한 작업 수를 보고하지 않습니다.

업서트 작업으로 새 문서가 생성될 경우 해당 문서는 update이(가) 아닌 insert(으)로 간주됩니다.

버전 5.0에 추가.

metrics.executor: 복제 실행기에 대해 다양한 통계를 보고하는 문서입니다.

metrics.getLastError: 쓰기 고려 사용에 대해 보고하는 문서입니다.

metrics.getLastError.wtime: 1보다 큰 w 인수를 사용하여 쓰기 고려 작업 수를 보고하는 문서입니다.

metrics.getLastError.wtime.num: 쓰기 고려가 지정되었으며(예: w) 복제본 세트의 1개 이상 멤버가 쓰기 작업을 승인할 때까지 기다리는(즉, w 값이 1보다 큼) 작업의 총 수입니다.

metrics.getLastError.wtime.totalMillis: mongod이(가) 쓰기 고려 한 가지로 쓰기 고려 작업을 실행하는 데 소요된 시간의 총량(단위: 밀리초)입니다. 이 쓰기 고려(예: w) 작업에서는 복제본 세트의 1개 이상 멤버가 쓰기 작업을 승인할 때까지 기다립니다(즉, w 값이 1보다 큼).

metrics.getLastError.wtimeouts: 쓰기 고려 작업이 wtimeout 임계값의 결과로 시간 초과된 횟수입니다. 이 숫자는 기본 쓰기 고려 사양 및 기본 외 쓰기 고려 사양 양쪽에서 증가합니다.

metrics.getLastError.default

기본 쓰기 고려(즉, clientSupplied 이외의 쓰기 고려)가 사용된 시기를 보고하는 문서입니다. 기본 쓰기 고려의 가능한 원인은 다음과 같습니다.

implicitDefault
customDefault
getLastErrorDefaults

가능한 각 쓰기 고려의 원인 또는 provenance에 대한 정보는 다음 표를 참조하세요.

출처	설명
`clientSupplied`	쓰기 우려 사항은 애플리케이션에서 지정되었습니다.
`customDefault`	쓰기 고려는 사용자 정의된 기본값에서 비롯된 것입니다. `setDefaultRWConcern`을 참조하십시오.
`getLastErrorDefaults`	쓰기 고려는 복제본 세트의 `settings.getLastErrorDefaults` 필드에서 발생했습니다.
`implicitDefault`	쓰기 고려는 다른 모든 쓰기 고려 사양이 없는 상태에서 서버에서 발생했습니다.

metrics.getLastError.default.unsatisfiable: clientSupplied 이외의 쓰기 고려가 UnsatisfiableWriteConcern 오류 코드를 반환한 횟수입니다.

metrics.getLastError.default.wtimeouts: clientSupplied 이외의 쓰기 고려가 시간 초과된 횟수입니다.

metrics.mongos: mongos 관련 지표가 포함된 문서입니다.

metrics.mongos.cursor: mongos에서 사용하는 커서의 지표가 포함된 문서입니다.

metrics.mongos.cursor.moreThanOneBatch: mongos이(가) 시작된 이후 2개 이상의 배치를 반환한 커서의 총 개수입니다. getMore 명령을 사용하여 추가 배치를 검색할 수 있습니다.
버전 5.0에 추가.

metrics.mongos.cursor.totalOpened: 현재 열려 있는 커서를 포함하여 mongos이(가) 시작된 이후 열린 커서의 총 개수입니다. 현재 열려 있는 커서의 개수만 나타내는 metrics.cursor.open.total와(과)는 다릅니다.
버전 5.0에 추가.

metrics.network: 버전 6.3에 추가.
서버 네트워크 지표를 보고하는 문서입니다.

metrics.network.totalEgressConnectionEstablishmentTimeMillis: 버전 6.3에 추가.
서버 연결 설정에 소요된 총 시간(단위: 밀리초)입니다.

metrics.network.totalIngressTLSConnections: 버전 6.3에 추가.
TLS를 사용하는 서버로 유입되는 연결의 총 건수입니다. 이 숫자는 누적되며 서버가 시작된 이후의 총합입니다.

metrics.network.totalIngressTLSHandshakeTimeMillis: 버전 6.3에 추가.
서버로 유입되는 연결에서 TLS 네트워크 핸드셰이크가 완료될 때까지 대기해야 하는 총 시간(단위: 밀리초)입니다. 이 숫자는 누적되며 서버가 시작된 이후의 총합입니다.

metrics.network.totalTimeForEgressConnectionAcquiredToWireMicros: 버전 6.3에 추가.
연산에서 서버 연결을 획득하는 시점과 네트워크를 통해 서버로 전송할 바이트를 기록하는 시점 사이에 대기하는 총 시간(단위: 마이크로초)입니다. 이 숫자는 누적되며 서버가 시작된 이후의 총합입니다.

metrics.network.totalTimeToFirstNonAuthCommandMillis: 버전 6.3에 추가.
서버로 유입되는 연결을 허용하고 연결 인증 핸드셰이크의 일부가 아닌 첫 번째 연산을 수신하는 데 소요된 총 시간(단위: 밀리초)입니다. 이 숫자는 누적되며 서버가 시작된 이후의 총합입니다.

metrics.operation: MongoDB가 특수 작업 유형을 사용하여 처리하는 여러 유형의 업데이트 및 쿼리 작업에 대한 카운터를 보유한 문서입니다.

metrics.operation.killedDueToClientDisconnect: 버전 7.1에 새로 추가되었습니다.
클라이언트 연결이 끊겨 완료되기 전에 취소된 작업의 총 개수입니다.

metrics.operation.killedDueToDefaultMaxTimeMSExpired: 버전 8.0에 추가 되었습니다.
클러스터 수준 기본 시간 초과 defaultMaxTimeMS로 인해 시간 초과된 총 작업 수입니다.

metrics.operation.killedDueToMaxTimeMSExpired: 버전 7.2에 새로 추가되었습니다.
작업 수준 시간 초과 cursor.maxTimeMS()로 인해 시간 초과된 작업의 총 수입니다.

metrics.operation.numConnectionNetworkTimeouts: 버전 6.3에 추가.
서버 연결 획득 시간 초과 오류로 인해 실패한 작업의 총 개수입니다.

metrics.operation.scanAndOrder: 인덱스를 사용하여 정렬 작업을 실행할 수 없는 정렬된 숫자를 반환하는 쿼리의 총 개수입니다.

metrics.operation.totalTimeWaitingBeforeConnectionTimeoutMillis: 버전 6.3에 추가.
서버 연결 획득 시간 초과 오류로 인해 실패하기 전에 작업에서 대기한 총 시간(단위: 밀리초)입니다.

metrics.operation.unsendableCompletedResponses: 버전 7.1에 새로 추가되었습니다.
서버 측에서 완료했지만 클라이언트와 서버 간의 연결이 실패하거나 연결 해제되어 클라이언트에 응답을 보내지 않은 작업의 총 건수입니다.

metrics.operation.writeConflicts: 쓰기 충돌이 발생한 쿼리의 총 개수입니다.

metrics.query.lookup

슬롯 기반 쿼리 실행 엔진에서의 $lookup 단계 사용에 대해 자세한 데이터를 제공하는 문서입니다. 자세한 내용은 $lookup Optimization($lookup 최적화)을(를) 참조하세요.

이 지표는 주로 MongoDB 내부에서 사용하기 위한 것입니다.

버전 6.1의 새로운 기능

metrics.query.multiPlanner

슬롯 기반 쿼리 실행 엔진과 클래식 쿼리 엔진에 대해 자세한 쿼리 계획 데이터를 제공합니다. 슬롯 기반 쿼리 실행 엔진에 대한 자세한 내용은 Slot-Based Query Execution Engine Pipeline Optimizations(슬롯 기반 쿼리 실행 엔진 파이프라인 최적화)을(를) 참조하세요.

이 지표는 주로 MongoDB 내부에서 사용하기 위한 것입니다.

버전 6.0.0 및 5.0.9의 새로운 기능

metrics.query.sort: 정렬 단계와 관련 있는 카운터를 보유한 문서입니다.
버전 6.2에 추가되었습니다.

metrics.query.sort.spillToDisk: 정렬 단계로 인해 발생한 디스크에 대한 총 쓰기 횟수입니다.
버전 6.2에 추가되었습니다.

metrics.query.sort.totalBytesSorted: 정렬된 데이터의 총량(단위: 바이트)입니다.
버전 6.2에 추가되었습니다.

metrics.query.sort.totalKeysSorted: 정렬에 사용된 키의 총 개수입니다.
버전 6.2에 추가되었습니다.

query.multiPlanner.classicMicros: 클래식 멀티플래너에서 소요된 총 마이크로초 수를 집계합니다.

query.multiPlanner.classicWorks: 클래식 멀티플래너에서 수행된 "작업"의 총 개수를 집계합니다.

query.multiPlanner.classicCount: 클래식 멀티플래너의 총 호출 수를 집계합니다.

query.multiPlanner.sbeMicros: 슬롯 기반 실행 엔진 멀티플래너에서 소요된 총 마이크로초 수를 집계합니다.

query.multiPlanner.sbeNumReads: 슬롯 기반 실행 엔진 멀티플래너에서 수행된 총 읽기 수를 집계합니다.

query.multiPlanner.sbeCount: 슬롯 기반 실행 엔진 멀티플래너의 총 호출 수를 집계합니다.

query.multiPlanner.histograms.classicMicros: 클래식 멀티플래너 호출에 소요된 마이크로초 수를 측정하는 히스토그램입니다.

query.multiPlanner.histograms.classicWorks: 클래식 멀티플래너를 호출하는 동안 수행된 "작업"의 수를 측정하는 히스토그램입니다.

query.multiPlanner.histograms.classicNumPlans: 클래식 멀티플래너를 호출하는 동안 후보 세트에 대해 세워진 계획의 수를 측정하는 히스토그램입니다.

query.multiPlanner.histograms.sbeMicros: 슬롯 기반 실행 엔진 멀티플래너 호출에 소요된 마이크로초 수를 측정하는 히스토그램입니다.

query.multiPlanner.histograms.sbeNumReads: 슬롯 기반 실행 엔진 멀티플래너를 호출하는 동안 발생한 읽기의 수를 측정하는 히스토그램입니다.

query.multiPlanner.histograms.sbeNumPlans: 슬롯 기반 실행 엔진 멀티플래너를 호출하는 동안 후보 세트에 대해 세워진 계획의 수를 측정하는 히스토그램입니다.

query.queryFramework.aggregate: 각 쿼리 프레임워크에서 실행되는 집계 작업의 수를 보고하는 문서입니다. query.queryFramework.aggregate의 하위 필드는 각 프레임워크가 집계 작업 실행에 사용된 횟수를 나타냅니다.

query.queryFramework.find: 각 쿼리 프레임워크에서 실행되는 찾기 작업의 수를 보고하는 문서입니다. query.queryFramework.find의 하위 필드는 각 프레임워크가 찾기 작업 실행에 사용된 횟수를 나타냅니다.

metrics.queryExecutor: 쿼리 실행 시스템의 데이터를 보고하는 문서입니다.

metrics.queryExecutor.scanned: 쿼리 및 쿼리 계획 평가 중에 스캔된 인덱스 항목의 총 개수입니다. 이 카운터는 explain() 출력의 totalKeysExamined와(과) 동일합니다.

metrics.queryExecutor.scannedObjects: 쿼리 및 쿼리 계획 평가 중에 스캔된 문서의 총 개수입니다. 이 카운터는 explain() 출력의 totalDocsExamined와(과) 동일합니다.

metrics.queryExecutor.collectionScans: 컬렉션 스캔을 수행한 쿼리의 개수를 보고하는 문서입니다.

metrics.queryExecutor.collectionScans.nonTailable: 테일 커서(tailable cursor)를 사용하지 않는 컬렉션 스캔을 수행한 쿼리의 개수입니다.

metrics.queryExecutor.collectionScans.total: 컬렉션 스캔을 수행한 쿼리의 총 개수입니다. 이 총합은 테일 커서(tailable cursor)를 사용한 쿼리와 사용하지 않은 쿼리로 이루어집니다.

metrics.record: 온디스크 메모리 파일 내 레코드 할당과 관련 있는 데이터를 보고하는 문서입니다.

metrics.repl: 복제 프로세스와 관련 있는 지표를 보고하는 문서입니다. metrics.repl 문서는 모든 mongod 인스턴스, 심지어 복제본 세트의 멤버가 아닌 인스턴스에서도 나타납니다.

metrics.repl.apply: 복제 oplog의 연산 적용에 대해 보고하는 문서입니다.

metrics.repl.apply.batchSize

적용된 oplog 연산의 총 개수입니다. metrics.repl.apply.batchSize는 각 연산이 끝난 후 1씩 증가하지 않고 배치 경계에서 배치 내 연산의 수에 따라 증가합니다.

보다 세부적인 사항은 metrics.repl.apply.ops를 참조하세요.

metrics.repl.apply.batches: metrics.repl.apply.batches는 복제본 세트의 세컨더리 멤버를 대상으로 하는 oplog 애플리케이션 프로세스를 보고합니다. oplog 애플리케이션 프로세스에 대한 자세한 내용은 Multithreaded Replication(멀티스레드 복제)을 참조하세요.

metrics.repl.apply.batches.num: 모든 데이터베이스에 적용된 배치의 총 개수입니다.

metrics.repl.apply.batches.totalMillis: mongod이(가) oplog에서 연산을 적용하는 데 소요된 시간(단위: 밀리초)의 총량입니다.

metrics.repl.apply.ops: 적용된 oplog 연산의 총 개수입니다. metrics.repl.apply.ops는 각 작업 후에 증가합니다.
팁
다음도 참조하세요.
metrics.repl.apply.batchSize

metrics.repl.write: oplog에 기록된 항목에 대해 보고하는 문서입니다.
버전 8.0에 추가 되었습니다.

metrics.repl.write.batchSize: oplog에 기록된 총 항목 수입니다. 이 지표는 멤버가 oplog에 배치 쓰기를 완료하면 각 배치의 항목 수로 업데이트됩니다.
버전 8.0에 추가 되었습니다.

metrics.repl.write.batches: 세컨더리 멤버를 위한 oplog 쓰기 프로세스를 보고하는 문서입니다.
버전 8.0에 추가 되었습니다.

metrics.repl.write.batches.num: 모든 데이터베이스에서 기록된 총 배치 수입니다.
버전 8.0에 추가 되었습니다.

metrics.repl.write.batches.totalMillis: 멤버가 oplog에 항목을 작성하는 데 소요한 총 시간(밀리초)입니다.
버전 8.0에 추가 되었습니다.

metrics.repl.buffer

MongoDB는 여러 oplog 항목을 한 배치로 적용하기 전에 복제 동기화 소스 버퍼에서 oplog 연산을 버퍼링합니다. metrics.repl.buffer는 oplog 버퍼를 추적하는 방법을 제공합니다. oplog 적용 프로세스에 대한 자세한 내용은 멀티스레드 복제를 참조하세요.

버전 8.0에서 변경되었습니다.

MongoDB 8.0부터 보조 데이터베이스가 로컬 oplog를 업데이트하고 데이터베이스에 변경 사항을 병렬로 적용합니다. 각 oplog 항목 배치에 대해 MongoDB는 두 개의 버퍼를 사용합니다.

write 버퍼는 기본에서 새로운 oplog 항목을 수신합니다. 작성자는 이러한 항목을 로컬 oplog에 추가하고 신청자에게 보냅니다.
apply 버퍼는 작성자로부터 새로운 oplog 항목을 수신합니다. 적용자는 이러한 항목을 사용하여 로컬 데이터베이스를 업데이트합니다.

이는 이전 metrics.repl.buffer 상태 지표를 더 이상 사용하지 않도록 설정하는 호환성이 손상되는 변경입니다.

metrics.repl.buffer.apply: oplog 적용 버퍼의 상태에 대한 정보를 제공합니다.
버전 8.0에 추가 되었습니다.

metrics.repl.buffer.apply.count: oplog 적용 버퍼 내 작업의 현재 개수입니다.
버전 8.0에 추가 되었습니다.

metrics.repl.buffer.apply.maxCount: oplog 적용 버퍼의 최대 작업 수입니다. mongod는 구성할 수 없는 상수를 사용하여 이 값을 설정합니다.
버전 8.0에 추가 되었습니다.

metrics.repl.buffer.apply.maxSizeBytes: 적용 버퍼의 최대 크기입니다. mongod는 구성할 수 없는 상수를 사용하여 이 크기를 설정합니다.
버전 8.0에 추가 되었습니다.

metrics.repl.buffer.apply.sizeBytes: oplog 적용 버퍼 콘텐츠의 현재 크기입니다.
버전 8.0에 추가 되었습니다.

metrics.repl.buffer.count: 버전 8.0부터 더 이상 사용되지 않습니다.
MongoDB 8.0부터 보조 데이터베이스는 별도의 버퍼를 사용하여 oplog 항목을 쓰고 적용합니다. oplog 버퍼의 현재 작업 수는 apply.count 또는 write.count 상태 지표를 참조하세요.

metrics.repl.buffer.maxSizeBytes: 버전 8.0부터 더 이상 사용되지 않습니다.
MongoDB 8.0부터 보조 데이터베이스는 별도의 버퍼를 사용하여 oplog 항목을 쓰고 적용합니다. 버퍼의 최대 크기는 apply.maxSizeBytes 또는 write.maxSizeBytes 상태 지표를 참조하세요.

metrics.repl.buffer.sizeBytes: 버전 8.0부터 더 이상 사용되지 않습니다.
MongoDB 8.0 부터 세컨더리 데이터베이스는 별도의 버퍼를 사용하여 oplog 항목을 기록하고 적용합니다. 현재 oplog 버퍼의 크기는 apply.sizeBytes 또는 write.sizeBytes 상태 지표를 참조하세요.

metrics.repl.buffer.write: Oplog 쓰기 버퍼의 상태에 대한 정보를 제공합니다.
버전 8.0에 추가 되었습니다.

metrics.repl.buffer.write.count: oplog 쓰기 버퍼 내 연산의 현재 개수입니다.
버전 8.0에 추가 되었습니다.

metrics.repl.buffer.write.maxSizeBytes: 쓰기 버퍼의 최대 크기입니다. mongod는 구성할 수 없는 상수를 사용하여 이 값을 설정합니다.
버전 8.0에 추가 되었습니다.

metrics.repl.buffer.write.sizeBytes: oplog 쓰기 버퍼 콘텐츠의 현재 크기입니다.
버전 8.0에 추가 되었습니다.

metrics.repl.network: metrics.repl.network 복제 프로세스의 네트워크 사용을 보고합니다.

metrics.repl.network.bytes: metrics.repl.network.bytes 복제 동기화 소스에서 읽은 데이터의 총량을 보고합니다.

metrics.repl.network.getmores: metrics.repl.network.getmores는 oplog 복제 프로세스의 일환으로 oplog 커서에서의 추가 결과를 요청하는 getmore 연산에 대해 보고합니다.

metrics.repl.network.getmores.num: metrics.repl.network.getmores.num은(는) 복제 동기화 소스의 추가 연산 세트를 요청하는 연산인 getmore 연산의 총 개수를 보고합니다.

metrics.repl.network.getmores.totalMillis: metrics.repl.network.getmores.totalMillis는 getmore 연산의 데이터를 수집하는 데 필요한 시간의 총량을 보고합니다.
참고
이 숫자는 getmore 연산이 초기에 데이터를 반환하지 않더라도 MongoDB가 더 많은 데이터를 기다리기 때문에 매우 클 수 있습니다.

metrics.repl.network.getmores.numEmptyBatches

세컨더리가 동기화 소스로부터 수신하는 빈 oplog 배치의 개수입니다. 세컨더리는 소스와 완전히 동기화된 경우 빈 배치를 수신하고, 그렇지 않은 경우에는 다음과 같은 결과를 얻습니다.

더 많은 데이터를 기다리는 동안 getmore의 시간이 초과되었거나,
이 세컨더리에 마지막 배치가 전송된 이후로 동기화 소스의 과반수 커밋 포인트가 더욱 커졌습니다.

프라이머리의 경우 해당 인스턴스가 이전에 세컨더리였다면, 이 숫자가 세컨더리 인스턴스였을 때 수신한 빈 배치에 대해 보고합니다. 그렇지 않으면 프라이머리의 경우 이 숫자가 0이(가) 됩니다.

metrics.repl.network.notPrimaryLegacyUnacknowledgedWrites: 현재의 mongod이(가) PRIMARY 상태가 아니기 때문에 실패한 비승인(w: 0) 레거시 쓰기 작업(Opcodes 참조)의 수입니다.

metrics.repl.network.notPrimaryUnacknowledgedWrites: 현재의 mongod이(가) PRIMARY 상태가 아니기 때문에 실패한 비승인(w: 0) 쓰기 작업의 수입니다.

metrics.repl.network.oplogGetMoresProcessed: 노드가 동기화 소스로 처리한 oplog를 가져오기 위해 실행된 getMore 명령의 수를 보고하는 문서입니다.

metrics.repl.network.oplogGetMoresProcessed.num: 노드가 동기화 소스로 처리한 oplog를 가져오기 위해 실행된 getMore 명령의 수입니다.

metrics.repl.network.oplogGetMoresProcessed.totalMillis: 노드가 metrics.repl.network.oplogGetMoresProcessed.num으로 계산된 getMore 명령을 처리하는 데 소요된 시간(단위: 밀리초)입니다.

metrics.repl.network.ops: 복제 소스에서 읽은 연산의 총 개수입니다.

metrics.repl.network.readersCreated: 생성된 oplog 쿼리 프로세스의 총 개수입니다. MongoDB는 연결 시(제한 시간 포함) 또는 네트워크 작업 중에 오류가 발생할 때마다 새 oplog 쿼리를 생성합니다. 게다가 MongoDB가 새 복제용 소스를 선택할 때마다 metrics.repl.network.readersCreated가 증가합니다.

metrics.repl.network.replSetUpdatePosition: 노드가 동기화 소스로 전송한 replSetUpdatePosition 명령의 수를 보고하는 문서입니다.

metrics.repl.network.replSetUpdatePosition.num: 노드가 동기화 소스로 전송한 replSetUpdatePosition 명령의 수입니다. replSetUpdatePosition 명령은 복제 진행 상황을 노드에서 동기화 소스로 전달하는 내부 복제 명령입니다.
참고
STARTUP2 상태의 복제본 세트 멤버는 replSetUpdatePosition 명령을 동기화 소스로 전송하지 않습니다.

metrics.repl.reconfig: 멤버 newlyAdded 필드가 프라이머리에 의해 자동으로 제거된 횟수가 포함된 문서입니다. 멤버가 복제본 세트에 처음으로 추가되면 해당 멤버의 newlyAdded 필드가 true(으)로 설정됩니다.
버전 5.0에 추가.

metrics.repl.reconfig.numAutoReconfigsForRemovalOfNewlyAddedFields: newlyAdded 멤버 필드가 프라이머리에 의해 자동으로 제거된 횟수입니다. 멤버가 복제본 세트에 처음으로 추가되면 해당 멤버의 newlyAdded 필드가 true(으)로 설정됩니다. 프라이머리가 멤버 상태가 SECONDARY, RECOVERING 또는 ROLLBACK임을 나타내는 멤버의 하트비트 응답을 수신한 후에, 프라이머리는 이 멤버의 newlyAdded 필드를 자동으로 제거합니다. newlyAdded 필드는 local.system.replset 컬렉션에 저장됩니다.
버전 5.0에 추가.

metrics.repl.stateTransition

멤버가 사용자 연산을 중단시킬 수 있는 다음 전환 중 한 가지를 겪을 때의 사용자 연산에 대한 정보:

멤버가 프라이머리로 승격됩니다.
멤버가 세컨더리로 물러납니다.
멤버가 롤백을 실행 중입니다.

metrics.repl.stateTransition.lastStateTransition

보고 중인 전환:

상태 변경	설명
`"stepUp"`	멤버가 프라이머리로 승격됩니다.
`"stepDown"`	멤버가 세컨더리로 물러납니다.
`"rollback"`	멤버가 롤백을 실행 중입니다.
`""`	멤버의 상태가 변경되지 않았습니다.

metrics.repl.stateTransition.totalOperationsKilled: mongod 인스턴스의 상태 변경 중에 중지된 작업의 총 개수입니다.
버전 7.3의 새로운 기능: totalOperationsKilled 가 userOperationsKilled를 대체합니다.

metrics.repl.stateTransition.totalOperationsRunning: mongod 인스턴스의 상태 변경 중에도 계속 실행된 작업의 총 개수입니다.
버전 7.3의 새로운 기능: totalOperationsRunning 가 userOperationsRunning를 대체합니다.

metrics.repl.stateTransition.userOperationsKilled: 버전 7.3이후 폐지: totalOperationsKilled 가 userOperationsKilled 을(를) 대체합니다.

metrics.repl.stateTransition.userOperationsRunning: 버전 7.3이후 폐지: totalOperationsRunning 가 userOperationsRunning 을(를) 대체합니다.

metrics.repl.syncSource: 복제본 세트 노드의 동기화 소스 선택 프로세스에 대한 정보입니다.

metrics.repl.syncSource.numSelections: 노드가 사용 가능한 동기화 소스 옵션 중에서 동기화할 노드를 선택하려고 시도한 횟수입니다. 그 예로 동기화 소스가 재평가되었거나 노드가 현재 동기화 소스로부터 오류를 수신한 경우, 노드는 동기화할 노드를 선택하려고 시도합니다.

metrics.repl.syncSource.numTimesChoseSame: 현재의 동기화 소스가 최적의 상태인지 재평가한 후에 노드가 원래의 동기화 소스를 유지한 횟수입니다.

metrics.repl.syncSource.numTimesChoseDifferent: 현재의 동기화 소스가 최적의 상태인지 재평가한 후에 노드가 새로운 동기화 소스를 선택한 횟수입니다.

metrics.repl.syncSource.numTimesCouldNotFind: 동기화할 노드를 선택하려고 시도했을 때 노드가 사용 가능한 동기화 소스를 찾지 못한 횟수입니다.

metrics.repl.waiters.replication: 복제되거나 저널된 쓰기 고려 승인을 기다리는 스레드 수입니다.
버전 7.3에 추가 되었습니다.

metrics.repl.waiters.opTime: 로컬 복제 optime 할당을 위해 대기열에 있는 스레드 수입니다.
버전 7.3에 추가 되었습니다.

metrics.storage.freelist.search.bucketExhausted: mongod이(가) 대규모 레코드 할당을 찾지 못한 채 무료 목록을 검사한 횟수입니다.

metrics.storage.freelist.search.requests: mongod이(가) 사용 가능한 레코드 할당을 검색한 횟수입니다.

metrics.storage.freelist.search.scanned: mongod이(가) 검색한 사용 가능한 레코드 할당의 수입니다.

metrics.ttl: ttl 인덱스 프로세스의 리소스 사용 연산을 보고하는 문서입니다.

metrics.ttl.deletedDocuments: ttl 인덱스가 있는 컬렉션에서 삭제된 문서의 총 개수입니다.

metrics.ttl.passes: 만료된 문서를 확인하기 위해 TTL 백그라운드 프로세스에서 수행한 패스의 수입니다. TTL 모니터가 모든 TTL 인덱스에서 찾을 수 있는 만큼의 후보 문서를 삭제하면 통과가 완료된 것입니다. TTL 인덱스 삭제 프로세스에 대한 자세한 내용은 삭제 프로세스를 참조하세요.

metrics.ttl.subPasses: 만료된 문서를 확인하기 위해 TTL 백그라운드 프로세스에서 수행한 하위 패스의 수입니다. TTL 인덱스 삭제 프로세스에 대한 자세한 내용은 삭제 프로세스를 참조하세요.

metrics.cursor: 커서 상태 및 사용에 관한 데이터가 포함된 문서입니다.

metrics.cursor.moreThanOneBatch: 서버 프로세스가 시작된 이후 2개 이상의 배치를 반환한 커서의 총 개수입니다. getMore 명령을 사용하여 추가 배치를 검색할 수 있습니다.
버전 5.0에 추가.

metrics.cursor.timedOut: 서버 프로세스가 시작된 이후 시간이 초과된 커서의 총 개수입니다. 이 숫자가 크거나 일반적인 속도로 증가할 경우, 이는 애플리케이션 오류를 의미할 수 있습니다.

metrics.cursor.totalOpened: 현재 열려 있는 커서를 포함하여 서버 프로세스가 시작된 이후 열린 커서의 총 개수입니다. 현재 열려 있는 커서의 개수만 나타내는 metrics.cursor.open.total과는 다릅니다.
버전 5.0에 추가.

metrics.cursor.lifespan

지정된 기간 내에 수명을 갖는 커서의 개수를 보고하는 문서입니다. 커서 수명은 커서가 생성된 시점부터 killCursors 명령을 사용해서 커서를 죽이거나 커서의 배치에 남은 객체가 없어지는 시점까지의 기간입니다.

수명 기간은 다음과 같습니다.

< 1초
>= 1초 ~ < 5초
>= 5초 ~ < 15초
>= 15초 ~ < 30초
>= 30초 ~ < 1분
>= 1분 ~ < 10분
>= 10분

버전 5.0에 추가.

metrics.cursor.lifespan.greaterThanOrEqual10Minutes: 수명이 >= 10분인 커서의 개수입니다.
버전 5.0에 추가.

metrics.cursor.lifespan.lessThan10Minutes: 수명이 >= 1분 ~ < 10분인 커서의 개수입니다.
버전 5.0에 추가.

metrics.cursor.lifespan.lessThan15Seconds: 수명이 >= 5초 ~ < 15초인 커서의 개수입니다.
버전 5.0에 추가.

metrics.cursor.lifespan.lessThan1Minute: 수명이 >= 30초 ~ < 1분인 커서의 개수입니다.
버전 5.0에 추가.

metrics.cursor.lifespan.lessThan1Second: 수명이 < 1초인 커서의 개수입니다.
버전 5.0에 추가.

metrics.cursor.lifespan.lessThan30Seconds: 수명이 >= 15초 ~ < 30초인 커서의 개수입니다.
버전 5.0에 추가.

metrics.cursor.lifespan.lessThan5Seconds: 수명이 >= 1초 ~ < 5초인 커서의 개수입니다.
버전 5.0에 추가.

metrics.cursor.open: 열린 커서에 관한 데이터가 포함된 문서입니다.

metrics.cursor.open.noTimeout: 일정 시간 동안의 비활성 이후 타임아웃을 방지하도록 DBQuery.Option.noTimeout 옵션이 설정된 상태로 열린 커서의 개수입니다.

metrics.cursor.open.pinned: "고정된" 열린 커서의 개수입니다.

metrics.cursor.open.total: MongoDB가 클라이언트를 위해 유지 관리 중인 커서의 개수입니다. MongoDB는 미사용 커서를 모두 소진시킵니다. 따라서 이 값은 대개 작거나 0입니다. 다만 대기열이 있는 경우, 혹은 테일 커서가 오래되었거나 연산 수가 많은 경우에는 이 값이 증가할 수 있습니다.

metrics.cursor.open.singleTarget: 1개 샤드만을 대상으로 하는 커서의 총 개수입니다. mongos 인스턴스만이 metrics.cursor.open.singleTarget 값을 보고합니다.

metrics.cursor.open.multiTarget: 2개 이상의 샤드만을 대상으로 하는 커서의 총 개수입니다. mongos 인스턴스만이 metrics.cursor.open.multiTarget 값을 보고합니다.

mirroredReads

mongod에서만 사용할 수 있습니다.

"mirroredReads" : {
      "seen" : <num>,
      "sent" : <num>
},

mirroredReads

mongod에서만 사용할 수 있습니다.

미러링된 읽기에 대해 보고하는 문서입니다. mirroredReads 정보를 반환하려면 포함 항목을 명시적으로 지정해야 합니다.

db.runCommand( { serverStatus: 1, mirroredReads: 1 } )

mirroredReads.processedAsSecondary: 버전 6.2에 추가되었습니다.
이 멤버가 세컨더리 상태인 동안 처리한 미러링된 읽기의 수입니다.
팁
다음도 참조하세요.
mirrorReads Parameter

mirroredReads.seen: 이 멤버가 수신한 미러링을 지원하는 연산의 수입니다.
팁
다음도 참조하세요.
mirrorReads Parameter

mirroredReads.sent: 이 멤버가 프라이머리 상태일 때 전송한 미러링된 읽기의 수입니다. 그 예로 읽기가 미러링되어 두 개의 세컨더리로 전송되는 경우, 미러링된 읽기 수는 2입니다.
팁
다음도 참조하세요.
mirrorReads Parameter

네트워크

network : {
   bytesIn : Long("<num>"),
   bytesOut : Long("<num>"),
   physicalBytesIn : Long("<num>"),
   physicalBytesOut : Long("<num>"),
   numSlowDNSOperations : Long("<num>"),
   numSlowSSLOperations : Long("<num>"),
   numRequests : Long("<num>"),
   tcpFastOpen : {
      kernelSetting : Long("<num>"),
      serverSupported : <bool>,
      clientSupported : <bool>,
      accepted : Long("<num>")
   },
   compression : {
      snappy : {
         compressor : { bytesIn : Long("<num>"), bytesOut : Long("<num>") },
         decompressor : { bytesIn : Long("<num>"), bytesOut : Long("<num>") }
      },
      zstd : {
         compressor : { bytesIn : Long("<num>"), bytesOut : Long("<num>") },
         decompressor : { bytesIn : Long("<num>"), bytesOut : Long("<num>") }
      },
      zlib : {
         compressor : { bytesIn : Long("<num>"), bytesOut : Long("<num>") },
         decompressor : { bytesIn : Long("<num>"), bytesOut : Long("<num>") }
      }
   },
   serviceExecutors : {
      passthrough : {
         threadsRunning : <num>,
         clientsInTotal : <num>,
         clientsRunning : <num>,
         clientsWaitingForData : <num>
      },
      fixed : {
         threadsRunning : <num>,
         clientsInTotal : <num>,
         clientsRunning : <num>,
         clientsWaitingForData : <num>
      }
   },
   listenerProcessingTime : { durationMicros : <num> }  // Added in MongoDB 6.3
}

network: MongoDB의 네트워크 사용에 대한 데이터를 보고하는 문서입니다. 이 통계는 클라이언트 또는 기타 mongod 인스턴스 또는 mongos 인스턴스에서 시작된 네트워크 연결을 통한 수신 연결(특히 mongod 또는 mongos에서 확인된 트래픽)만을 측정합니다. 이 mongod 인스턴스 또는 mongos 인스턴스에서 시작된 네트워크 연결(특히 발신 연결)의 트래픽은 이 통계에서 측정되지 않습니다.

network.bytesIn: 클라이언트나 기타 mongod 또는 mongos 인스턴스에서 시작한 네트워크 연결을 통해 서버가 수신한 총 논리적 바이트 수입니다. 논리적 바이트는 지정된 파일에 포함된 정확한 바이트 수입니다.

network.bytesOut: 클라이언트나 기타 mongod 또는 mongos 인스턴스에서 시작한 네트워크 연결을 통해 서버가 전송한 총 논리적 바이트 수입니다. 논리적 바이트는 지정된 파일에 포함된 바이트 수에 해당합니다.

network.physicalBytesIn: 클라이언트나 기타 mongod 또는 mongos 인스턴스에서 시작한 네트워크 연결을 통해 서버가 수신한 총 물리적 바이트 수입니다. 물리적 바이트는 디스크에 실제로 존재하는 바이트 수입니다.

network.physicalBytesOut: 클라이언트나 기타 mongod 또는 mongos 인스턴스에서 시작한 네트워크 연결을 통해 서버가 전송한 총 물리적 바이트 수입니다. 물리적 바이트는 디스크에 실제로 존재하는 바이트 수입니다.

network.numSlowDNSOperations: 소요 시간이 1초를 초과하는 DNS 확인 작업의 총 개수입니다.

network.numSlowSSLOperations: 소요 시간이 1초를 초과하는 SSL 핸드셰이크 작업의 총 개수입니다.

network.numRequests: 서버가 수신한 고유 요청의 총 건수입니다. network.bytesIn 값 및 network.bytesOut 값에 대한 컨텍스트를 제공하여 MongoDB의 네트워크 사용률이 예상치 및 애플리케이션 사용률과 일치하는지 확인하려면 이 값을 사용하세요.

network.tcpFastOpen: MongoDB의 TFO(TCP Fast Open) 연결 지원 및 사용에 대한 데이터를 보고하는 문서입니다.

network.tcpFastOpen.kernelSetting

Linux 한정

/proc/sys/net/ipv4/tcp_fastopen 값을 반환합니다.

0 - 시스템에서 TCP Fast Open이 비활성화됩니다.
1 - 발신 연결을 위해 TCP Fast Open이 활성화됩니다.
2 - 수신 연결을 위해 TCP Fast Open이 활성화됩니다.
3 - 수신 연결 및 발신 연결을 위해 TCP Fast Open이 활성화됩니다.

network.tcpFastOpen.serverSupported

호스트 운영 체제가 인바운드 TFO(TCP Fast Open) 연결을 지원할 경우 true을(를) 반환합니다.
호스트 운영 체제가 인바운드 TFO(TCP Fast Open) 연결을 지원하지 않을 경우 false을(를) 반환합니다.

network.tcpFastOpen.clientSupported

호스트 운영 체제가 아웃바운드 TFO(TCP Fast Open) 연결을 지원할 경우 true을(를) 반환합니다.
호스트 운영 체제가 아웃바운드 TFO(TCP Fast Open) 연결을 지원하지 않을 경우 false을(를) 반환합니다.

network.tcpFastOpen.accepted: mongod 또는 mongos이(가) 마지막으로 시작된 이후 mongod 또는 mongos에 대해 허용된 수신 TCP TFO(TCP Fast Open) 연결의 총 건수입니다.

network.compression: 각 네트워크 압축기 라이브러리에서 압축된/압축 해제된 데이터의 양을 보고하는 문서입니다.

network.compression.snappy: 스내피 라이브러리로 압축된/압축 해제된 바이트의 수에 대한 통계를 반환하는 문서입니다.

network.compression.zstd: zstd 라이브러리로 압축된/압축 해제된 바이트의 수에 대한 통계를 반환하는 문서입니다.

network.compression.zlib: zlib 라이브러리로 압축된/압축 해제된 바이트의 수에 대한 통계를 반환하는 문서입니다.

network.serviceExecutors: 버전 5.0에 추가.
클라이언트 요청에 맞게 연산을 실행하는 서비스 실행기에 대한 데이터를 보고하는 문서입니다.

network.serviceExecutors.passthrough: 버전 5.0에 추가.
passthrough 서비스 실행기의 스레드 및 클라이언트에 대한 데이터를 보고하는 문서입니다. passthrough 서비스 실행기는 각 클라이언트에 대해 새 스레드를 생성하고, 클라이언트가 종료된 후 해당 스레드를 폐기합니다.

network.serviceExecutors.passthrough.threadsRunning: 버전 5.0에 추가.
passthrough 서비스 실행기에서 실행 중인 스레드의 개수입니다.

network.serviceExecutors.passthrough.clientsInTotal: 버전 5.0에 추가.
passthrough 서비스 실행기에 할당된 클라이언트의 총 수입니다. 클라이언트는 passthrough 서비스 실행기에 할당될 수 있으며 현재는 요청을 실행할 수 없습니다.

network.serviceExecutors.passthrough.clientsRunning: 버전 5.0에 추가.
현재 passthrough 서비스 실행기를 사용하여 요청을 실행 중인 클라이언트의 수입니다.

network.serviceExecutors.passthrough.clientsWaitingForData: 버전 5.0에 추가.
네트워크에서 유입되는 데이터를 대기 중인 passthrough 서비스 실행기를 사용하는 클라이언트의 수입니다.

network.serviceExecutors.fixed: 버전 5.0에 추가.
fixed 서비스 실행기의 스레드 및 클라이언트에 대한 데이터를 보고하는 문서입니다. fixed 서비스 실행기의 스레드 개수는 고정되어 있습니다. 스레드는 클라이언트에 일시적으로 할당되며, 클라이언트가 종료된 후에도 이 스레드는 유지됩니다.

network.serviceExecutors.fixed.threadsRunning: 버전 5.0에 추가.
fixed 서비스 실행기에서 실행 중인 스레드의 개수입니다.

network.serviceExecutors.fixed.clientsInTotal: 버전 5.0에 추가.
fixed 서비스 실행기에 할당된 클라이언트의 총 수입니다. 클라이언트는 fixed 서비스 실행기에 할당될 수 있으며 현재는 요청을 실행할 수 없습니다.

network.serviceExecutors.fixed.clientsRunning: 버전 5.0에 추가.
현재 fixed 서비스 실행기를 사용하여 요청을 실행 중인 클라이언트의 수입니다.

network.serviceExecutors.fixed.clientsWaitingForData: 버전 5.0에 추가.
네트워크에서 유입되는 데이터를 대기 중인 fixed 서비스 실행기를 사용하는 클라이언트의 수입니다.

network.listenerProcessingTime: 버전 6.3에 추가.
데이터베이스 리스너가 수신 데이터베이스 연결 요청을 전용 스레드에 할당하는 데 소요된 총 시간을 보고하는 문서입니다.

network.listenerProcessingTime.durationMicros: 버전 6.3에 추가.
데이터베이스 리스너가 수신 데이터베이스 연결 요청을 데이터베이스 연산을 실행하는 전용 스레드에 할당하는 데 소요된 총 시간(단위: 마이크로초)입니다.

opLatencies

opLatencies : {
   reads : <document>,
   writes : <document>,
   commands : <document>,
   transactions : <document>
},

opLatencies

인스턴스 전체의 작업 지연 시간이 포함된 문서입니다. 이 문서에 대한 설명은 latencyStats 문서를 참조하세요.

MongoDB 6.2부터는 opLatencies 지표가 mongod 인스턴스와 mongos 인스턴스 모두에 대해 보고합니다. mongos에 의해 보고되는 지연 시간에는 mongod 인스턴스와 mongos 인스턴스 간의 연산 지연 시간과 통신 시간이 포함됩니다.

opLatencies 출력에 히스토그램을 포함하려면 다음 명령을 실행합니다.

db.runCommand( { serverStatus: 1, opLatencies: { histograms: true } } ).opLatencies

opLatencies.reads: 읽기 요청에 대한 지연 시간 통계입니다.

opLatencies.writes: 쓰기 연산에 대한 지연 시간 통계입니다.

opLatencies.commands: 데이터베이스 명령에 대한 지연 시간 통계입니다.

opLatencies.transactions: 데이터베이스 트랜잭션에 대한 지연 시간 통계입니다.

opWorkingTime

opWorkingTime : {
   commands : <document>,
   reads : <document>,
   writes : <document>,
   transactions : <document>
}

opWorkingTime

인스턴스 의 작업 실행에 대한 정보가 포함된 문서입니다. 이 문서 에 대한 latencyStats 설명은 문서를 참조하세요.

opWorkingTime 아래의 필드는 MongoDB가 해당 작업에 소비하는 시간인 workingMillis 단위로 측정됩니다. 이는 잠금 대기 및 흐름 제어와 같은 요소가 opWorkingTime에 영향을 미치지 않는다는 뜻입니다.

opWorkingTime 출력에 히스토그램을 포함하려면 다음 명령을 실행합니다.

db.runCommand( { serverStatus: 1, opWorkingTime: { histogram: true } } ).opWorkingTime

버전 8.0에 추가 되었습니다.

opWorkingTime.commands: 데이터베이스 명령에 대한 실행 통계를 보고하는 문서입니다.
버전 8.0에 추가 되었습니다.

opWorkingTime.reads: 읽기 작업에 대한 실행 통계를 보고하는 문서입니다.
버전 8.0에 추가 되었습니다.

opWorkingTime.writes: 쓰기 작업에 대한 실행 통계를 보고하는 문서입니다.
버전 8.0에 추가 되었습니다.

opWorkingTime.transactions: 트랜잭션에 대한 실행 통계를 보고하는 문서입니다.
버전 8.0에 추가 되었습니다.

opReadConcernCounters

경고

제거됨

버전 5.0부터는 opReadConcernCounters이(가) readConcernCounters(으)로 바뀝니다.

mongod 인스턴스만 해당

opReadConcernCounters : {
   available : Long("<num>"),
   linearizable : Long("<num>"),
   local : Long("<num>"),
   majority : Long("<num>"),
   snapshot : Long("<num>"),
   none : Long("<num>")
}

opReadConcernCounters

버전 5.0에서 제거되었습니다.. readConcernCounters로 대체되었습니다.

마지막으로 시작된 이후 mongod 인스턴스에 대한 쿼리 연산에서 지정된 읽기 고려 레벨을 보고하는 문서입니다.

지정됨 `w`	설명
`"available"`	읽기 고려 레벨을 `"available"`(으)로 지정한 쿼리 연산의 수입니다.
`"linearizable"`	읽기 고려 레벨을 `"linearizable"`(으)로 지정한 쿼리 연산의 수입니다.
`"local"`	읽기 고려 레벨을 `"local"`(으)로 지정한 쿼리 연산의 수입니다.
`"majority"`	읽기 고려 레벨을 `"majority"`(으)로 지정한 쿼리 연산의 수입니다.
`"snapshot"`	읽기 고려 레벨을 `"snapshot"`(으)로 지정한 쿼리 연산의 수입니다.
`"none"`	읽기 고려 레벨을 지정하지 않은 대신 기본 읽기 고려 레벨을 사용한 쿼리 연산의 수입니다.

opReadConcernCounters의 합계는 opcounters.query입니다.

opWriteConcernCounters

mongod 인스턴스만 해당

opWriteConcernCounters : {
   insert : {
      wmajority : Long("<num>"),
      wnum : {
         <num> :  Long("<num>"),
         ...
      },
      wtag : {
         <tag1> :  Long("<num>"),
         ...
      },
      none : Long("<num>"),
      noneInfo : {
         CWWC : {
            wmajority : Long("<num>"),
            wnum : {
               <num> :  Long("<num>"),
               ...
            },
            wtag : {
               <tag1> :  Long("<num>"),
               ...
            }
         },
         implicitDefault : {
            wmajority : Long("<num>")
            wnum : {
               <num> :  Long("<num>"),
               ...
            }
         }
      }
   },
   update : {
      wmajority : Long("<num>"),
      wnum : {
         <num> :  Long("<num>"),
         ...
      },
      wtag : {
         <tag1> :  Long("<num>"),
         ...
      },
      none : Long("<num>"),
      noneInfo : {
         CWWC : {
            wmajority : Long("<num>"),
            wnum : {
               <num> :  Long("<num>"),
               ...
            }
            wtag : {
               <tag1> :  Long("<num>"),
               ...
            }
         },
         implicitDefault : {
            wmajority : Long("<num>")
            wnum : {
               <num> :  Long("<num>"),
               ...
            }
         }
      }
   },
   delete : {
      wmajority :  Long("<num>")
      wnum : {
         <num> :  Long("<num>"),
         ...
      },
      wtag : {
         <tag1> :  Long("<num>"),
         ...
      },
      none : Long("<num>"),
      noneInfo : {
         CWWC : {
            wmajority : Long("<num>"),
            wnum : {
               <num> :  Long("<num>"),
               ...
            },
            wtag : {
               <tag1> :  Long("<num>"),
               ...
            }
         },
         implicitDefault : {
            wmajority : Long("<num>")
            wnum : {
               <num> :  Long("<num>"),
               ...
            }
         }
      }
   }
}

opWriteConcernCounters

마지막으로 시작된 이후 mongod 인스턴스에 대한 쓰기 연산에서 지정된 쓰기 고려를 보고하는 문서입니다.

보다 구체적으로 말하자면, opWriteConcernCounters는 쓰기 연산에서 지정된 w: <value>에 대해 보고합니다. 쓰기 고려의 저널 플래그 옵션(j)과 시간 제한 옵션(wtimeout)은 계수에 영향을 주지 않습니다. 계수는 연산 시간이 초과되더라도 증가합니다.

참고

reportOpWriteConcernCountersInServerStatus 매개변수가 true(기본값: false)(으)로 설정된 경우에만 사용할 수 있습니다.

opWriteConcernCounters.insert

마지막으로 시작된 이후 mongod 인스턴스에 대한 삽입 연산에서 지정된 w: <value>을(를) 보고하는 문서입니다.

참고

reportOpWriteConcernCountersInServerStatus 매개변수가 true(기본값: false)(으)로 설정된 경우에만 사용할 수 있습니다.

insert : {
   wmajority : Long("<num>"),
   wnum : {
      <num> :  Long("<num>"),
      ...
   },
   wtag : {
      <tag1> :  Long("<num>"),
      ...
   },
   none : Long("<num>"),
   noneInfo : {
      CWWC : {
         wmajority : Long("<num>"),
         wnum : {},
         wtag : {}
      },
      implicitDefault : {
         wmajority : Long("<num>")
         wnum : {}
      }
   }
},

지정됨 `w`	설명
`"wmajority"`	`w: "majority"`을(를) 지정한 삽입 연산의 수입니다.
`"wnum"`	`w: <num>`을(를) 지정한 삽입 연산의 수입니다. 계수는 특정 ``<num>``(으)로 그룹화됩니다.
`"wtag"`	`w: <tag>`을(를) 지정한 삽입 연산의 수입니다. 계수는 특정 `<tag>`(으)로 그룹화됩니다.
`"none"`	`w` 값을 지정하지 않은 삽입 연산의 수입니다. 이 연산에서는 `w`의 기본값인 "majority"을(를) 사용합니다.
`"noneInfo"`	기본 쓰기 고려를 사용하는 트랜잭션 외 쿼리 연산의 수입니다. 이 지표는 `cluster wide write concern`(전역 기본 쓰기 고려)와 암시적 기본 쓰기 고려의 사용량을 추적합니다. `opWriteConcernCounters.noneInfo`에 있는 값들의 합계는 `opWriteConcernCounters.none`의 값과 같아야 합니다.

opWriteConcernCounters.insert의 합계는 opcounters.insert입니다.

opWriteConcernCounters.update

마지막으로 시작된 이후 mongod 인스턴스에 대한 업데이트 연산에서 지정된 w: <value>을(를) 보고하는 문서입니다.

참고

reportOpWriteConcernCountersInServerStatus 매개변수가 true(기본값: false)(으)로 설정된 경우에만 사용할 수 있습니다.

update : {
   wmajority : Long("<num>"),
   wnum : {
      <num> :  Long("<num>"),
      ...
   },
   wtag : {
      <tag1> :  Long("<num>"),
      ...
   },
   none : Long("<num>"),
   noneInfo : {
      CWWC : {
         wmajority : Long("<num>"),
         wnum : {},
         wtag : {}
      },
      implicitDefault : {
         wmajority : Long("<num>")
         wnum : {}
      }
   }
},

지정됨 `w`	설명
`"wmajority"`	`w: "majority"`을(를) 지정한 업데이트 연산의 수입니다.
`"wnum"`	`w: <num>`을(를) 지정한 업데이트 연산의 수입니다. 계수는 특정 `<num>`(으)로 그룹화됩니다.
`"wtag"`	`w: <tag>`을(를) 지정한 업데이트 연산의 수입니다. 계수는 특정 `<tag>`(으)로 그룹화됩니다.
`"none"`	`w` 값을 지정하지 않은 업데이트 연산의 수입니다. 이 연산에서는 `w`의 기본값인 `1`을(를) 사용합니다.
`"noneInfo"`	기본 쓰기 고려를 사용하는 트랜잭션 외 쿼리 연산의 수입니다. 이 지표는 `cluster wide write concern`(전역 기본 쓰기 고려)와 암시적 기본 쓰기 고려의 사용량을 추적합니다. `opWriteConcernCounters.noneInfo`에 있는 값들의 합계는 `opWriteConcernCounters.none`의 값과 같아야 합니다.

opWriteConcernCounters.update의 합계는 opcounters.update입니다.

opWriteConcernCounters.delete

마지막으로 시작된 이후 mongod 인스턴스에 대한 삭제 연산에서 지정된 w: <value>을(를) 보고하는 문서입니다.

참고

reportOpWriteConcernCountersInServerStatus 매개변수가 true(기본값: false)(으)로 설정된 경우에만 사용할 수 있습니다.

delete : {
   wmajority :  Long("<num>"),
   wnum : {
      <num> :  Long("<num>"),
      ...
   },
   wtag : {
      <tag1> :  Long("<num>"),
      ...
   },
   none : Long("<num>"),
   noneInfo : {
      CWWC : {
         wmajority : Long("<num>"),
         wnum : {},
         wtag : {}
      },
      implicitDefault : {
         wmajority : Long("<num>")
         wnum : {}
      }
   }
}

지정됨 `w`	설명
`"wmajority"`	`w: "majority"`을(를) 지정한 삭제 연산의 수입니다.
`"wnum"`	`w: <num>`을(를) 지정한 삭제 연산의 수입니다. 계수는 특정 `<num>`(으)로 그룹화됩니다.
`"wtag"`	`w: <tag>`을(를) 지정한 삭제 연산의 수입니다. 계수는 특정 `<tag>`(으)로 그룹화됩니다.
`"none"`	`w` 값을 지정하지 않은 삭제 연산의 수입니다. 이 연산에서는 `w`의 기본값인 `1`을(를) 사용합니다.
`"noneInfo"`	기본 쓰기 고려를 사용하는 트랜잭션 외 쿼리 연산의 수입니다. 이 지표는 `cluster wide write concern`(전역 기본 쓰기 고려)와 암시적 기본 쓰기 고려의 사용량을 추적합니다. `opWriteConcernCounters.noneInfo`에 있는 값들의 합계는 `opWriteConcernCounters.none`의 값과 같아야 합니다.

opWriteConcernCounters.delete의 합계는 opcounters.delete입니다.

opcounters

opcounters : {
   insert : Long("<num>"),
   query : Long("<num>"),
   update : Long("<num>"),
   delete : Long("<num>"),
   getmore : Long("<num>"),
   command : Long("<num>"),
},

opcounters

mongod 인스턴스가 마지막으로 시작된 이후의 유형별 데이터베이스 연산을 보고하는 문서입니다.

이 숫자는 다음에 다시 시작할 때까지 시간이 지날수록 증가합니다. 시간 경과에 따른 이 값을 분석하여 데이터베이스 사용률을 추적하세요.

참고

opcounters의 데이터는 여러 문서에 영향을 주는 연산(예: 대량 삽입 연산 또는 다중 업데이트 연산)을 단일 연산으로 처리합니다. 문서 수준의 연산 추적에 관한 자세한 내용은 metrics.document를 참조하세요.

게다가 이 값은 수신된 연산을 반영하며, 연산이 성공하지 못한 경우에도 증가합니다.

opcounters.insert: mongod 인스턴스가 마지막으로 시작된 이후에 수신된 삽입 연산의 총 개수입니다.

opcounters.query: mongod 인스턴스가 마지막으로 시작된 이후에 수신된 쿼리의 총 개수입니다. MongoDB 7.1부터는 집계가 쿼리 연산으로 계산되어 이 값이 증가합니다.

opcounters.update: mongod 인스턴스가 마지막으로 시작된 이후에 수신된 업데이트 연산의 총 개수입니다.

opcounters.delete: mongod 인스턴스가 마지막으로 시작된 이후의 삭제 연산의 총 개수입니다.

opcounters.getmore: mongod인스턴스가 마지막으로 시작된 이후의 getMore 연산의 총 개수입니다. 이 카운터는 쿼리 수가 적은 경우에도 높을 수 있습니다. 세컨더리 노드는 복제 프로세스의 일환으로 getMore 연산을 전송합니다.

opcounters.command

mongod 인스턴스가 마지막으로 시작된 이후 데이터베이스에 대해 실행된 명령의 총 개수입니다.

opcounters.command은(는) 다음을 제외한 모든 명령을 계산합니다.

opcounters.deprecated

opQuery MongoDB 5.0에서 더 이상 사용되지 않지만 일시적으로 지원되는 opcode에 대한 요청의 수를 계산합니다. 이 섹션은 더 이상 사용되지 않는 opcode가 사용된 경우에만 db.serverStatus() 출력에 나타납니다.

mongod이(가) 시작되면 카운터가 초기화됩니다.

deprecated: {
   opQuery: Long("<num>"),
}

opcountersRepl

반환된 opcountersRepl.* 값이 NumberLong 유형에 속합니다.

opcountersRepl : {
   insert : Long("<num>"),
   query : Long("<num>"),
   update : Long("<num>"),
   delete : Long("<num>"),
   getmore : Long("<num>"),
   command : Long("<num>"),
},

opcountersRepl

mongod 인스턴스가 마지막으로 시작된 이후의 유형별 데이터베이스 복제 연산을 보고하는 문서입니다.

이 값은 현재의 호스트가 복제본 세트의 멤버인 경우에만 표시됩니다.

이 값은 MongoDB가 복제 도중에 연산을 직렬화하는 방식 때문에 opcounters 값과 다를 수 있습니다. 복제에 대한 자세한 내용은 Replication(복제)을(를) 참조하세요.

이 숫자는 다음에 다시 시작할 때까지 데이터베이스에 반응하여 시간이 지날수록 증가합니다. 시간 경과에 따른 이 값을 분석하여 데이터베이스 사용률을 추적하세요.

반환된 opcountersRepl.* 값이 NumberLong 유형에 속합니다.

opcountersRepl.insert

mongod 인스턴스가 마지막으로 시작된 이후에 복제된 삽입 연산의 총 개수입니다.

반환된 opcountersRepl.* 값이 NumberLong 유형에 속합니다.

opcountersRepl.query

mongod 인스턴스가 마지막으로 시작된 이후에 복제된 쿼리의 총 개수입니다.

반환된 opcountersRepl.* 값이 NumberLong 유형에 속합니다.

opcountersRepl.update

mongod 인스턴스가 마지막으로 시작된 이후에 복제된 업데이트 연산의 총 개수입니다.

반환된 opcountersRepl.* 값이 NumberLong 유형에 속합니다.

opcountersRepl.delete

mongod 인스턴스가 마지막으로 시작된 이후에 복제된 삭제 연산의 총 개수입니다.

반환된 opcountersRepl.* 값이 NumberLong 유형에 속합니다.

opcountersRepl.getmore

mongod인스턴스가 마지막으로 시작된 이후의 getMore 연산의 총 개수입니다. 이 카운터는 쿼리 수가 적은 경우에도 높을 수 있습니다. 세컨더리 노드는 복제 프로세스의 일환으로 getMore 연산을 전송합니다.

반환된 opcountersRepl.* 값이 NumberLong 유형에 속합니다.

opcountersRepl.command

mongod 인스턴스가 마지막으로 시작된 이후 데이터베이스에 대해 실행된 복제된 명령의 총 개수입니다.

반환된 opcountersRepl.* 값이 NumberLong 유형에 속합니다.

oplogTruncation

oplogTruncation : {
   totalTimeProcessingMicros : Long("<num>"),
   processingMethod : <string>,
   oplogMinRetentionHours : <double>
   totalTimeTruncatingMicros : Long("<num>"),
   truncateCount : Long("<num>")
},

oplogTruncation

oplog 잘라내기에 대해 보고하는 문서입니다.

해당 필드는 현재 인스턴스가 복제 세트의 멤버이고 WiredTiger 스토리지 엔진 또는 자체 관리 배포용 인메모리 스토리지 엔진을 사용하는 경우에만 나타납니다.

WiredTiger Storage Engine(WiredTiger 스토리지 엔진)에서 사용할 수 있습니다.

oplogTruncation.totalTimeProcessingMicros

oplog를 스캔하거나 샘플링하여 oplog 잘라내기 지점을 정하는 데 소요된 총 시간(단위: 마이크로초)입니다.

totalTimeProcessingMicros는 mongod 인스턴스가 기존 데이터 파일에서 시작된 경우에만 의미가 있습니다(즉, 자체 관리형 배포를 위한 인메모리 스토리지 엔진에는 의미가 없습니다).

~를 참조하세요. oplogTruncation.processingMethod

WiredTiger Storage Engine(WiredTiger 스토리지 엔진)에서 사용할 수 있습니다.

oplogTruncation.processingMethod

시작 시 oplog 잘라내기 지점을 정하기 위해 사용되는 메서드입니다. 이 값은 "sampling" 또는 "scanning" 중 하나일 수 있습니다.

processingMethod는 mongod 인스턴스가 기존 데이터 파일에서 시작된 경우에만 의미가 있습니다(즉, 자체 관리형 배포를 위한 인메모리 스토리지 엔진에는 의미가 없습니다).

WiredTiger Storage Engine(WiredTiger 스토리지 엔진)에서 사용할 수 있습니다.

oplogTruncation.oplogMinRetentionHours

oplog의 최소 보존 기간(단위: 시간)입니다. oplog가 oplog 크기를 초과한 경우, mongod는 구성된 보존 값보다 오래된 oplog 항목만 잘라냅니다.

mongod이(가) 복제본 세트의 멤버이면서 다음과 같은 상태인 경우에만 표시됩니다.

mongod은(는) --oplogMinRetentionHours 명령줄 옵션 또는 storage.oplogMinRetentionHours 구성 파일 옵션으로 시작되었으며,
or
replSetResizeOplog을(를) 사용하여 시작한 후에 최소 보존 기간이 구성되었습니다.

oplogTruncation.totalTimeTruncatingMicros

oplog 잘라내기를 실행하는 데 소요된 누적 시간(단위: 마이크로초)입니다.

WiredTiger Storage Engine(WiredTiger 스토리지 엔진)에서 사용할 수 있습니다.

oplogTruncation.truncateCount

oplog 잘라내기의 누적 횟수입니다.

WiredTiger Storage Engine(WiredTiger 스토리지 엔진)에서 사용할 수 있습니다.

planCache

버전 7.0에 추가.

planCache : {
   totalQueryShapes : Long("<num>"),
   totalSizeEstimateBytes : Long("<num>"),
   classic : {
      hits : Long("<num>"),
      misses : Long("<num>"),
      skipped : Long("<num>")
   },
   sbe : {
      hits : Long("<num>"),
      misses: Long("<num>"),
      skipped : Long("<num>")
   }
}

planCache: 쿼리 계획 캐시 통계를 보고하는 문서입니다.

planCache.totalQueryShapes

계획 캐시 쿼리 형태의 대략적인 수

버전 7.2 이전에는 계획 캐시 쿼리 형태 수에 대한 정보가 query.planCacheTotalQueryShapes 필드에 저장되었습니다.

버전 7.2에 새로 추가되었습니다.

planCache.totalSizeEstimateBytes

계획 캐시의 총 크기(단위: 바이트)입니다.

버전 7.2 이전에는 계획 캐시 크기에 대한 정보가 query.planCacheTotalSizeEstimateBytes 필드에 저장되었습니다.

버전 7.2에 새로 추가되었습니다.

planCache.classic.hits: 쿼리 캐시에서 발견되어 쿼리 계획 단계를 피하기 위해 재사용된 클래식 실행 엔진 쿼리 계획의 수입니다.

planCache.classic.misses: 쿼리 캐시에서 발견되지 않았으며 쿼리 계획 단계를 거친 클래식 실행 엔진 쿼리 계획의 수입니다.

planCache.classic.skipped: 쿼리가 캐싱에 적합하지 않아 쿼리 캐시에서 찾을 수 없는 클래식 실행 엔진 쿼리 계획의 수입니다.
버전 7.3에 추가 되었습니다.

planCache.sbe.hits: 쿼리 캐시에서 발견되어 쿼리 계획 단계를 피하기 위해 재사용된 슬롯 기반 실행 엔진 쿼리 계획의 수입니다.

planCache.sbe.misses: 쿼리 캐시에서 발견되지 않았으며 쿼리 계획 단계를 거친 슬롯 기반 실행 엔진 계획의 수입니다.

planCache.sbe.skipped: 쿼리가 캐싱에 적합하지 않아 쿼리 캐시에서 찾을 수 없는 슬롯 기반 실행 엔진 쿼리 계획의 수입니다.
버전 7.3에 추가 되었습니다.

queryStats

버전 7.1에 새로 추가되었습니다.

queryStats: {
   numEvicted: Long("<num>"),
   numRateLimitedRequests: Long("<num>"),
   queryStatsStoreSizeEstimateBytes: Long("<num>"),
   numQueryStatsStoreWriteErrors: Long("<num>"),
   numHmacApplicationErrors: Long("<num>")
},

queryStats: $queryStats 애그리게이션 단계에 대한 지표가 포함된 문서입니다.

queryStats.numEvicted: 공간 제약으로 인해 $queryStats 가상 컬렉션이 제거한 쿼리의 수입니다.

queryStats.numRateLimitedRequests: 속도 제한으로 인해 쿼리에 대한 쿼리 통계가 기록되지 않은 횟수입니다.

queryStats.queryStatsStoreSizeEstimateBytes: $queryStats 가상 collection에 있는 객체의 현재 예상 크기입니다.

queryStats.numQueryStatsStoreWriteErrors: 이 MongoDB 프로세스가 새 쿼리 통계 키를 저장하지 못한 횟수입니다. 일반적으로 이러한 오류는 $queryStats 가상 collection 공간이 부족할 때 발생합니다.

queryStats.numHmacApplicationErrors: transformIdentifiers 옵션으로 $queryStats 가 호출되었을 때 이 MongoDB 프로세스가 토큰화된 단방향 쿼리 통계 키를 계산하지 못한 횟수입니다.

queryAnalyzers

버전 7.0에 추가.

queryAnalyzers: {
  activeCollections: <integer>,
  totalCollections: <integer>,
  totalSampledReadsCount: <integer>,
  totalSampledWritesCount: <integer>,
  totalSampledReadsBytes: <integer>,
  totalSampledWritesBytes: <integer>
}

queryAnalyzers.activeCollections: 쿼리 분석기가 적극적으로 샘플링하는 컬렉션의 개수입니다.

queryAnalyzers.totalCollections: 샘플링된 컬렉션의 총 개수입니다.

queryAnalyzers.totalSampledReadsCount: 샘플링된 읽기 쿼리의 총 개수입니다.

queryAnalyzers.totalSampledWritesCount: 샘플링된 쓰기 쿼리의 총 개수입니다.

queryAnalyzers.totalSampledReadsBytes: 샘플링된 읽기 쿼리의 총 크기(단위: 바이트)입니다. 이 지표는 mongod에서 serverStatus을(를) 실행하는 경우에만 사용할 수 있습니다.

queryAnalyzers.totalSampledWritesBytes: 샘플링된 쓰기 쿼리의 총 크기(단위: 바이트)입니다. 이 지표는 mongod에서 serverStatus을(를) 실행하는 경우에만 사용할 수 있습니다.

queues

작업이 단계를 진행하면서 현재 단계의 동시 작업 수가 최대 임계값을 초과하면 대기열에 들어갈 수 있습니다. 이렇게 하면 과도한 리소스 경합을 방지하고 데이터베이스 상태에 대한 관찰 가능성을 제공합니다.

버전 8.0에 추가 되었습니다.

queues: {
   execution: {
      write: {
         out: Long("<num>"),
         available: Long("<num>"),
         totalTickets: Long("<num>"),
         exempt: {
            addedToQueue: Long("<num>"),
            removedFromQueue: Long("<num>"),
            queueLength: Long("<num>"),
            startedProcessing: Long("<num>"),
            processing: Long("<num>"),
            finishedProcessing: Long("<num>"),
            totalTimeProcessingMicros: Long("<num>"),
            canceled: Long("<num>"),
            newAdmissions: Long("<num>"),
            totalTimeQueuedMicros: Long("<num>")
         },
         normalPriority: {
            addedToQueue: Long("<num>"),
            removedFromQueue: Long("<num>"),
            queueLength: Long("<num>"),
            startedProcessing: Long("<num>"),
            processing: Long("<num>"),
            finishedProcessing: Long("<num>"),
            totalTimeProcessingMicros: Long("<num>"),
            canceled: Long("<num>"),
            newAdmissions: Long("<num>"),
            totalTimeQueuedMicros: Long("<num>")
         }
      },
      read: {
         out: Long("<num>"),
         available: Long("<num>"),
         totalTickets: Long("<num>"),
         exempt: {
            addedToQueue: Long("<num>"),
            removedFromQueue: Long("<num>"),
            queueLength: Long("<num>")),
            startedProcessing: Long("<num>"),
            processing: Long("<num>"),
            finishedProcessing: Long("<num>"),
            totalTimeProcessingMicros: Long("<num>"),
            canceled: Long("<num>"),
            newAdmissions: Long("<num>"),
            totalTimeQueuedMicros: Long("<num>")
         },
         normalPriority: {
            addedToQueue: Long("<num>"),
            removedFromQueue: Long("<num>"),
            queueLength: Long("<num>"),
            startedProcessing: Long("<num>"),
            processing: Long("<num>"),
            finishedProcessing: Long("<num>"),
            totalTimeProcessingMicros: Long("<num>"),
            canceled: Long("<num>"),
            newAdmissions: Long("<num>"),
            totalTimeQueuedMicros: Long("<num>")
         }
      },
      monitor: {
         timesDecreased: Long("<num>"),
         timesIncreased: Long("<num>"),
         totalAmountDecreased: Long("<num>"),
         totalAmountIncreased: Long("<num>"),
         resizeDurationMicros: Long("<num>")
      }
   },
   ingress: {
      out: Long("<num>"),
      available: Long("<num>"),
      totalTickets: Long("<num>"),
      exempt: {
         addedToQueue: Long("<num>"),
         removedFromQueue: Long("<num>"),
         queueLength: Long("<num>"),
         startedProcessing: Long("<num>"),
         processing: Long("<num>"),
         finishedProcessing: Long("<num>"),
         totalTimeProcessingMicros: Long("<num>"),
         canceled: Long("<num>"),
         newAdmissions: Long("<num>"),
         totalTimeQueuedMicros: Long("<num>")
      },
      normalPriority: {
         addedToQueue: Long("<num>"),
         removedFromQueue: Long("<num>"),
         queueLength: Long("<num>"),
         startedProcessing: Long("<num>"),
         processing: Long("<num>"),
         finishedProcessing: Long("<num>"),
         totalTimeProcessingMicros: Long("<num>"),
         canceled: Long("<num>"),
         newAdmissions: Long("<num>"),
         totalTimeQueuedMicros: Long("<num>")
      }
   }
}

queues.execution

버전 8.0에 추가 되었습니다.

스토리지 계층 내에서 실행 일정을 잡기 위해 대기 중인 작업(동시 트랜잭션) 에 대한 모니터링 및 대기열 정보를 반환하는 문서입니다.

이 설정은 MongoDB 전용입니다. 동시 읽기/쓰기 트랜잭션(읽기/쓰기 티켓)의 설정을 변경하려면 storageEngineConcurrentReadTransactions 및 storageEngineConcurrentWriteTransactions을(를) 참조하세요.

중요

버전 7.0부터 MongoDB는 현재 스토리지 엔진 트랜젝션(읽기 티켓과 쓰기 티켓 모두 포함)의 최대 수를 실시간으로 조정하는 데 기본 알고리즘을 사용해 오버로드 시 데이터베이스 처리량을 최적화합니다.

다음 표는 MongoDB post-7.0 이후 버전과 이전 버전에서 과부하 시나리오를 식별하는 방법을 요약한 것입니다.

버전	과부하 시나리오 진단
7.0 이상	많은 수의 작업의 대기 중인 상황이 오랫동안 지속되면 과부하가 걸렸을 가능성이 높습니다. 장시간 동안 동시 스토리지 엔진 트랜잭션(티켓) 가용성이 0이라고 해서 과부하가 발생한 것은 아닙니다.
6.0 이하	많은 수의 작업의 대기 중인 상황이 오랫동안 지속되면 과부하가 걸렸을 가능성이 높습니다. 오랜 시간 동안 현재의 스토리지 엔진 트랜잭션(티켓)의 가용성이 0인 경우에도 과부하가 걸렸을 가능성이 높습니다.

queues.execution.write: WiredTiger 스토리지 엔진에서 허용된 동시 읽기 트랜잭션(읽기 티켓)에 대한 대기열 정보를 반환하는 문서입니다.

queues.execution.read: WiredTiger 스토리지 엔진에서 허용된 동시 쓰기 트랜잭션(쓰기 티켓)에 대한 대기열 정보를 반환하는 문서입니다.

queues.execution.monitor

시스템이 동시 허용 트랜잭션(티켓) 수에 대해 수행한 조정의 모니터링 지표를 반환하는 문서입니다.

queues.execution.monitor.timesDecreased

대기열 크기가 줄어든 횟수입니다.

queues.execution.monitor.timesIncreased

대기열 크기가 증가한 횟수입니다.

queues.execution.monitor.totalAmountDecreased

대기열이 감소한 총 작업 수입니다.

queues.execution.monitor.totalAmountIncreased

대기열이 증가한 총 작업 수입니다.

queues.execution.monitor.resizeDurationMicros

시스템이 대기열 크기를 조정하는 데 소요된 누적 시간(밀리초)입니다.

queues.ingress

버전 8.0에 추가 되었습니다.

인그레스 승인 제어를 위한 대기열 정보를 반환하는 문서입니다. 이 값을 사용하여 네트워크에서 데이터베이스 입력을 기다리는 작업 개수를 제한하여 리소스 과부하를 방지하고 완화할 수 있습니다.

허용되는 최대 동시 작업 수는 ingressAdmissionControllerTicketPoolSize에 의해 제한됩니다.

대기열 정보

out: Long("<num>"),
available: Long("<num>"),
totalTickets: Long("<num>"),
exempt: {
   addedToQueue: Long("<num>"),
   removedFromQueue: Long("<num>"),
   queueLength: Long("<num>"),
   startedProcessing: Long("<num>"),
   processing: Long("<num>"),
   finishedProcessing: Long("<num>"),
   totalTimeProcessingMicros: Long("<num>"),
   canceled: Long("<num>"),
   newAdmissions: Long("<num>"),
   totalTimeQueuedMicros: Long("<num>")
},
normalPriority: {
   addedToQueue: Long("<num>"),
   removedFromQueue: Long("<num>"),
   queueLength: Long("<num>"),
   startedProcessing: Long("<num>"),
   processing: Long("<num>"),
   finishedProcessing: Long("<num>"),
   totalTimeProcessingMicros: Long("<num>"),
   canceled: Long("<num>"),
   newAdmissions: Long("<num>"),
   totalTimeQueuedMicros: Long("<num>")
}

out: 현재 보유 중인 티켓 수입니다.

available: 사용 가능한 티켓 수입니다.

totalTickets: 티켓 풀의 크기입니다.

exempt: 대기열에서 제외된 작업에 대한 지표를 반환하는 문서입니다.

exempt.startedProcessing: 입장 티켓을 획득한 총 작업 수입니다.

exempt.processing: 현재 처리 중인 총 작업 수입니다.

exempt.finishedProcessing: 입장 티켓을 릴리스한 총 작업 수입니다.

exempt.totalTimeProcessingMicros: 작업에서 입장 티켓을 보유한 총 시간입니다.

exempt.canceled: 대기열에서 시간 초과된 총 작업 수입니다.

exempt.newAdmissions: 대기열에 추가된 신규 입장의 총 건수입니다.

exempt.totalTimeQueuedMicros: 작업이 대기열에서 대기하는 데 소요한 총 시간입니다.

normalPriority: 대기열의 영향을 받는 작업에 대한 지표를 반환하는 문서입니다.

normalPriority.addedToQueue: 대기열에 추가된 총 작업 수입니다.

normalPriority.removedFromQueue: 대기열에서 제거된 총 작업 수입니다.

normalPriority.queueLength: 대기열에 있는 총 작업 수입니다.

normalPriority.startedProcessing: 입장 티켓을 획득한 총 작업 수입니다.

normalPriority.processing: 현재 처리 중인 총 작업 수입니다.

normalPriority.finishedProcessing: 입장 티켓을 릴리스한 총 작업 수입니다.

normalPriority.totalTimeProcessingMicros: 작업에서 입장 티켓을 보유한 총 시간입니다.

normalPriority.canceled: 대기열에서 시간 초과된 총 작업 수입니다.

normalPriority.newAdmissions: 대기열에 추가된 신규 입장의 총 건수입니다.

normalPriority.totalTimeQueuedMicros: 작업이 대기열에서 대기하는 데 소요한 총 시간입니다.

querySettings

버전 8.0에 추가 되었습니다.

querySettings: {
  count: <num>,
  rejectCount: <num>,
  size: <num>
}

querySettings

쿼리 설정에 대한 구성 개수 및 사용법이 포함된 문서입니다.

MongoDB 8.0 부터는 인덱스 필터 를 추가하는 대신 쿼리 설정을 사용합니다. 인덱스 필터는 MongoDB 8.0 부터 더 이상 사용되지 않습니다.

쿼리 설정에는 인덱스 필터보다 더 많은 기능이 있습니다. 또한 인덱스 필터는 영구적이지 않으며 모든 클러스터 노드에 대한 인덱스 필터를 쉽게 만들 수 없습니다. 쿼리 설정을 추가하고 예제를 탐색하려면 setQuerySettings 를 참조하세요.

querySettings.count: 쿼리 설정의 총 개수입니다.

querySettings.rejectCount: reject 필드가 true로 설정된 쿼리 설정의 총 수입니다. reject 필드를 설정하려면 setQuerySettings를 사용합니다.

querySettings.size: 쿼리 설정의 총 크기(바이트)입니다.

readConcernCounters

버전 5.0에 추가.

readConcernCounters : {
   nonTransactionOps : {
      none : Long("<num>"),
      noneInfo : {
         CWRC : {
            local : Long("<num>"),
            available : Long("<num>"),
            majority : Long("<num>")
         },
         implicitDefault : {
            local : Long("<num>"),
            available : Long("<num>")
         }
      },
      local : Long("<num>"),
      available : Long("<num>"),
      majority : Long("<num>"),
      snapshot : {
         withClusterTime : Long("<num>"),
         withoutClusterTime : Long("<num>")
      },
      linearizable : Long("<num>")
   },
   transactionOps : {
      none : Long("<num>"),
      noneInfo : {
         CWRC : {
            local : Long("<num>"),
            available : Long("<num>"),
            majority : Long("<num>")
         },
         implicitDefault : {
            local : Long("<num>"),
            available : Long("<num>")
         }
      },
      local : Long("<num>"),
      majority : Long("<num>"),
      snapshot : {
         withClusterTime : Long("<num>"),
         withoutClusterTime : Long("<num>")
      }
   }
},

readConcernCounters: 쿼리 연산에서 지정된 읽기 고려 레벨 을 보고하는 문서입니다. 이 문서에는 readConcernCounters.nonTransactionOps 및 readConcernCounters.transactionOps 문서가 포함되어 있습니다.

readConcernCounters.nonTransactionOps: 데이터베이스 서버가 마지막으로 시작된 이후에 실행된 트랜잭션 외 쿼리 연산에서 지정된 읽기 고려 레벨을 보고하는 문서입니다.

readConcernCounters.nonTransactionOps.none

읽기 고려 레벨을 지정하지 않은 대신 다음 중 한 가지를 사용한 트랜잭션 외 쿼리 연산의 수:

기본 읽기 고려 레벨 또는
setDefaultRWConcern 명령으로 설정한 경우의 전역 기본 읽기 고려 구성

readConcernCounters.nonTransactionOps.noneInfo

전역 기본 읽기 고려와 암시적 기본 읽기 고려를 사용하는 트랜잭션 외 쿼리 연산의 수입니다.

readConcernCounters.nonTransactionOps.noneInfo에 있는 값들의 합계는 readConcernCounters.nonTransactionOps.none의 값과 같아야 합니다.

readConcernCounters.nonTransactionOps.local: "local" 읽기 고려 레벨을 지정한 트랜잭션 외 쿼리 연산의 수입니다.

readConcernCounters.nonTransactionOps.available: "available" 읽기 고려 레벨을 지정한 트랜잭션 외 쿼리 연산의 수입니다.

readConcernCounters.nonTransactionOps.majority: "majority" 읽기 고려 레벨을 지정한 트랜잭션 외 쿼리 연산의 수입니다.

readConcernCounters.nonTransactionOps.snapshot: "snapshot" 읽기 고려 레벨을 지정한 트랜잭션 외 쿼리 연산이 포함된 문서입니다.

readConcernCounters.nonTransactionOps.snapshot.withClusterTime: "snapshot" 읽기 고려 레벨과 클러스터 시간(특정 시점을 지정함)을 지정한 트랜잭션 외 쿼리 연산의 수입니다.

readConcernCounters.nonTransactionOps.snapshot.withoutClusterTime: 클러스터 시간 없이 "snapshot" 읽기 고려 레벨을 지정한 트랜잭션 외 쿼리 연산의 수입니다. 다시 말해 특정 시점이 생략되었으며, 서버가 노드에 대해 사용 가능하며 가장 최근에 커밋된 스냅샷을 읽습니다.

readConcernCounters.nonTransactionOps.linearizable: "linearizable" 읽기 고려 레벨을 지정한 트랜잭션 외 쿼리 연산의 수입니다.

readConcernCounters.transactionOps: 데이터베이스 서버가 마지막으로 시작된 이후에 실행된 트랜잭션 쿼리 연산에서 지정된 읽기 고려 레벨을 보고하는 문서입니다.

readConcernCounters.transactionOps.none: 읽기 고려 레벨을 지정하지 않은 대신 setDefaultRWConcern 명령이 추가된 기본 읽기 고려 레벨 또는 전역 기본 읽기 또는 쓰기 고려 구성을 사용한 트랜잭션 쿼리 연산의 수입니다.

readConcernCounters.transactionOps.noneInfo: 트랜잭션 쿼리 연산에서 사용되는 전역 기본 읽기 고려 및 암시적 기본 읽기 고려에 대한 정보입니다.

readConcernCounters.transactionOps.local: "local" 읽기 고려 레벨을 지정한 트랜잭션 쿼리 연산의 수입니다.

readConcernCounters.transactionOps.available: "available" 읽기 고려 레벨을 지정한 트랜잭션 쿼리 연산의 수입니다.

readConcernCounters.transactionOps.majority: "majority" 읽기 고려 레벨을 지정한 트랜잭션 쿼리 연산의 수입니다.

readConcernCounters.transactionOps.snapshot: "snapshot" 읽기 고려 레벨을 지정한 트랜잭션 쿼리 연산이 포함된 문서입니다.

readConcernCounters.transactionOps.snapshot.withClusterTime: "snapshot" 읽기 고려 레벨과 클러스터 시간(특정 시점을 지정함)을 지정한 트랜잭션 쿼리 연산의 수입니다.

readConcernCounters.transactionOps.snapshot.withoutClusterTime: 클러스터 시간 없이 "snapshot" 읽기 고려 레벨을 지정한 트랜잭션 쿼리 연산의 수입니다. 다시 말해 특정 시점이 생략되었으며, 서버가 노드에 대해 사용 가능하며 가장 최근에 커밋된 스냅샷을 읽습니다.

readPreferenceCounters

MongoDB 7.2(및 7.0.3, 6.0.11).

mongod에서만 사용할 수 있습니다.

readPreferenceCounters : {
   executedOnPrimary : {
      primary : {
         internal : Long("<num>"),
         external : Long("<num>")
      },
      primaryPreferred : {
         internal : Long("<num>"),
         external : Long("<num>")
      },
      secondary : {
         internal : Long("<num>"),
         external : Long("<num>")
      },
      secondaryPreferred : {
         internal : Long("<num>"),
         external : Long("<num>")
      },
      nearest : {
         internal : Long("<num>"),
         external : Long("<num>")
      },
      tagged : {
         internal : Long("<num>"),
         external : Long("<num>")
      }
   },
   executedOnSecondary : {
      primary : {
         internal : Long("<num>"),
         external : Long("<num>")
      },
      primaryPreferred : {
         internal : Long("<num>"),
         external : Long("<num>")
      },
      secondary : {
         internal : Long("<num>"),
         external : Long("<num>")
      },
      secondaryPreferred : {
         internal : Long("<num>"),
         external : Long("<num>")
      },
      nearest : {
         internal : Long("<num>"),
         external : Long("<num>")
      },
      tagged : {
         internal : Long("<num>"),
         external : Long("<num>")
      }
   }
}

readPreferenceCounters

mongod에서만 사용할 수 있습니다.

읽기 기본 설정이 지정된 이 mongod 노드로 수신한 연산의 수를 보고하는 문서입니다.

tagged 하위 필드는 태그와 함께 전달된 읽기 기본 설정을 나타냅니다.

readPreferenceCounters.executedOnPrimary

mongod에서만 사용할 수 있습니다.

노드가 프라이머리 역할을 하는 동안 수신한 내부/외부 읽기 기본 설정 연산의 수를 계산하는 문서입니다.

readPreferenceCounters.executedOnSecondary

mongod에서만 사용할 수 있습니다.

노드가 세컨더리 역할을 하는 동안 수신한 내부/외부 읽기 기본 설정 연산의 수를 계산하는 문서입니다.

repl

repl : {
   hosts : [
         <string>,
         <string>,
         <string>
   ],
   setName : <string>,
   setVersion : <num>,
   isWritablePrimary : <boolean>,
   secondary : <boolean>,
   primary : <hostname>,
   me : <hostname>,
   electionId : ObjectId(""),
   primaryOnlyServices: {
      ReshardingRecipientService: { state: <string>, numInstances: <num> },
      RenameCollectionParticipantService: { state: <string>, numInstances: <num> },
      ShardingDDLCoordinator: { state: <string>, numInstances: <num> },
      ReshardingDonorService: { state: <string>, numInstances: <num> }
   },
   rbid : <num>,
   replicationProgress : [
         {
            rid : <ObjectId>,
            optime : { ts: <timestamp>, term: <num> },
            host : <hostname>,
            memberId : <num>
         },
        ...
   ]
}

repl: 복제본 세트 구성을 보고하는 문서입니다. repl은(는) 현재의 호스트가 복제본 세트인 경우에만 표시됩니다. 복제에 대한 자세한 내용은 Replication(복제)을(를) 참조하세요.

repl.hosts: 현재 복제본 세트 멤버의 호스트 이름 및 포트 정보("host:port")의 배열입니다.

repl.setName: 현재 복제본 세트의 이름이 포함된 문자열입니다. 이 값은 --replSet 명령줄 인수 또는 구성 파일의 replSetName 값을 반영합니다.

repl.isWritablePrimary: 현재 노드가 복제본 세트의 프라이머리인지 여부를 나타내는 부울입니다.

repl.secondary: 현재 노드가 복제본 세트의 세컨더리 멤버인지 여부를 나타내는 부울입니다.

repl.primary: 복제본 세트의 현재 프라이머리 멤버의 호스트 이름 및 포트 정보("host:port")입니다.

repl.me: 복제본 세트의 현재 멤버의 호스트 이름 및 포트 정보("host:port")입니다.

repl.primaryOnlyServices: 서버에서 활성화된 각 프라이머리 서비스의 인스턴스 개수와 상태가 포함된 문서입니다. 프라이머리 서비스는 서버가 프라이머리 서버인 경우에만 시작될 수 있지만, 서버 상태가 변경된 후에도 완료될 때까지 계속 실행될 수 있습니다.
버전 5.0에 추가.

repl.primaryOnlyServices.ReshardingRecipientService

ReshardingRecipientService의 상태와 인스턴스 개수가 포함된 문서입니다.

수신자는 새로운 샤드 키 및 구역에 따라 리샤딩 작업의 결과가 나온 후에 청크를 소유하게 되는 샤드입니다.

리샤딩 조정자는 각 기증자/수신자 샤드 프라이머리에게 임시 샤딩 컬렉션의 이름을 변경하도록 지시합니다. 이 임시 컬렉션은 새로운 리샤딩 컬렉션이 됩니다.

버전 5.0에 추가.

repl.primaryOnlyServices.RenameCollectionParticipantService

RenameCollectionParticipantService의 상태와 인스턴스 개수가 포함된 문서입니다.

RenameCollectionParticipantService을(를) 사용하면 샤드가 renameCollection 요청을 받은 후에도 시스템 장애 발생 시 해당 샤드가 로컬 이름 변경을 재개할 수 있습니다.

버전 5.0에 추가.

repl.primaryOnlyServices.ShardingDDLCoordinator

ShardingDDLCoordinator의 상태와 인스턴스 개수가 포함된 문서입니다.

ShardingDDLCoordinator 서비스는 프라이머리 데이터베이스에 대한 DDL 연산(예: 데이터베이스 생성, 데이터베이스 제거, renameCollection)을 관리합니다.

ShardingDDLCoordinator은(는) 샤딩된 클러스터 내 종류를 막론한 1개 특정 시점에 각 데이터베이스에 대한 DDL 연산 1가지가 이뤄질 수 있게 합니다.

버전 5.0에 추가.

repl.primaryOnlyServices.ReshardingDonorService

ReshardingDonorService의 상태와 인스턴스 개수가 포함된 문서입니다.

기증자는 이름 변경 작업이 완료되기 전에 샤드 컬렉션의 청크를 보유하게 되는 샤드입니다.

버전 5.0에 추가.

repl.rbid: Rollback(롤백) 식별자입니다. 이 mongod 인스턴스에 대해 롤백이 발생했는지 확인하는 데 사용됩니다.

repl.replicationProgress

복제본 세트의 각 멤버에 대한 복제 프로세스를 해당 멤버에게 보고하는 문서가 1개씩 포함된 배열입니다. 이 배열은 일반적으로 프라이머리이며, 연쇄 복제를 사용할 경우에는 세컨더리입니다.

이 출력을 포함시키려면 다음과 같이 repl 옵션을 serverStatus로 전달해야 합니다.

db.serverStatus({ "repl": 1 })
db.runCommand({ "serverStatus": 1, "repl": 1 })

repl.replicationProgress 섹션의 내용은 각 멤버의 복제 소스에 따라 달라집니다. 이 섹션은 내부 연산을 지원하며 내부용 및 진단용으로만 사용합니다.

repl.replicationProgress[n].rid: 복제본 세트 멤버의 ID로 사용되는 ObjectId입니다. 내부용으로만 사용합니다.

repl.replicationProgress[n].optime: 이 멤버가 보고한 대로, 해당 멤버가 적용한 oplog에서의 마지막 연산에 관한 정보입니다.

repl.replicationProgress[n].host: 복제본 세트 멤버에 대한 [hostname]:[port] 형식의 호스트 이름입니다.

repl.replicationProgress[n].memberID: 이 복제본 세트 멤버의 정수 식별자입니다.

보안

security : {
   authentication : {
      saslSupportedMechsReceived : <num>,
      mechanisms : {
         MONGODB-X509 : {
            speculativeAuthenticate : {
               received : Long("<num>"),
               successful : Long("<num>")
            },
            authenticate : {
               received : Long("<num>"),
               successful : Long("<num>")
            }
         },
         SCRAM-SHA-1 : {
            speculativeAuthenticate : {
               received : Long("<num>"),
               successful : Long("<num>")
            },
            authenticate : {
               received : Long("<num>"),
               successful : Long("<num>")
            }
         },
         SCRAM-SHA-256 : {
            speculativeAuthenticate : {
               received : Long("<num>"),
               successful : Long("<num>")
            },
            authenticate : {
               received : Long("<num>"),
               successful : Long("<num>")
            }
          }
       }
     },
     SSLServerSubjectName: <string>,
     SSLServerHasCertificateAuthority: <boolean>,
     SSLServerCertificateExpirationDate: <date>
},

security

다음 항목에 대해 보고하는 문서입니다.

지정된 인증 메커니즘이 mongod 또는 mongos 인스턴스를 대상으로 한 인증에 사용된 횟수입니다.
mongod/mongos 인스턴스의 TLS/SSL 인증서입니다. (TLS를 지원하는 mongod 또는 mongos 인스턴스에만 표시됨)

security.authentication.saslSupportedMechsReceived: 버전 5.0에 추가.
hello 요청에 유효한 hello.saslSupportedMechs 필드가 포함된 횟수입니다.

security.authentication.mechanisms: 지정된 인증 메커니즘이 mongod 또는 mongos 인스턴스를 대상으로 한 인증에 사용된 횟수를 보고하는 문서입니다. 이 문서에 표시된 값은 표준 인증과 추측 인증을 서로 구분합니다. [1]
참고
mechanisms 문서의 필드는 authenticationMechanisms 매개변수의 구성에 따라 달라집니다. mechanisms 문서에는 사용자의 mongod 또는 mongos 인스턴스에서 지원하는 각 인증 메커니즘에 해당하는 필드가 포함되어 있습니다.
다음 예시는 x.509 인증만 지원하는 배포서버에 대한 mechanisms 문서의 형태를 보여줍니다.

security.authentication.mechanisms.MONGODB-X509

mongod 또는 mongos 인스턴스를 대상으로 한 인증에 x.509가 사용된 횟수를 보고하는 문서입니다.

x.509 인증 시도의 총 횟수와 추측에 의한 해당 인증 시도의 하위 세트가 포함됩니다. [1]

security.authentication.mechanisms.MONGODB-X509.speculativeAuthenticate.received: x.509를 사용하여 수신한 추측 인증 시도의 횟수입니다. 성공한 추측 인증 시도와 실패한 추측 인증 시도가 모두 포함됩니다. [1]

security.authentication.mechanisms.MONGODB-X509.speculativeAuthenticate.successful: x.509를 사용하여 수신한 성공한 추측 인증 시도의 횟수입니다. [1]

security.authentication.mechanisms.MONGODB-X509.authenticate.received: x.509를 사용하여 수신한 성공한/실패한 인증 시도의 횟수입니다. 이 값에는 x.509를 사용하여 수신한 추측 인증 시도가 포함됩니다.

security.authentication.mechanisms.MONGODB-X509.authenticate.successful: x.508을 사용하여 수신한 성공한 인증 시도의 횟수입니다. 이 값에는 x.509를 사용하여 성공한 추측 인증 시도가 포함됩니다.

[1]	(1, 2, 3, 4) 추측 인증은 인증 프로세스가 진행되는 동안 네트워크 왕복 시간의 수치를 최소화하여 성능을 최적화합니다.

security.SSLServerSubjectName: mongod/mongos 인스턴스의 TLS/SSL 인증서에 연결된 객체 이름입니다.

security.SSLServerHasCertificateAuthority

다음과 같은 경우에 해당하는 부울입니다.

true mongod/mongos 인스턴스의 TLS/SSL 인증서가 인증 기관에 연결된 경우
false TLS/SSL 인증서에 자체 서명이 된 경우

security.SSLServerCertificateExpirationDate: mongod/mongos 인스턴스의 TLS/SSL 인증서의 만료 날짜 및 시간입니다.

샤딩

{
   configsvrConnectionString : 'csRS/cfg1.example.net:27019,cfg2.example.net:27019,cfg2.example.net:27019',
   lastSeenConfigServerOpTime : {
      ts : <timestamp>,
      t : Long("<num>")
   },
   maxChunkSizeInBytes : Long("<num>")
}

sharding: 샤딩된 클러스터에 관한 데이터가 포함된 문서입니다. lastSeenConfigServerOpTime은 mongos 또는 샤드 멤버에만 존재하며 config 서버에는 존재하지 않습니다.

sharding.configsvrConnectionString: config 서버의 연결 문자열입니다.

sharding.lastSeenConfigServerOpTime

mongos 또는 샤드 멤버에 표시된 CSRS 프라이머리의 최신 optime입니다. optime 문서에 포함되는 항목은 다음과 같습니다.

ts, 작업의 타임스탬프입니다.
t이 작업이 원래 프라이머리에서 생성된 term입니다.

lastSeenConfigServerOpTime은(는) 샤딩된 클러스터가 CSRS를 사용하는 경우에만 존재합니다.

sharding.maxChunkSizeInBytes: 마이그레이션할 범위의 최대 크기 한도입니다. 이 값이 config 서버에서 최근에 업데이트된 경우에는 maxChunkSizeInBytes에 최신 값이 반영되지 않을 수 있습니다.

shardingStatistics

샤드의 멤버에서 실행되는 경우.

shardingStatistics : {
   countStaleConfigErrors : Long("<num>"),
   countDonorMoveChunkStarted : Long("<num>"),
   countDonorMoveChunkCommitted : Long("<num>"),
   countDonorMoveChunkAborted : Long("<num>"),
   totalDonorMoveChunkTimeMillis : Long("<num>"),
   totalDonorChunkCloneTimeMillis : Long("<num>"),
   totalCriticalSectionCommitTimeMillis : Long("<num>"),
   totalCriticalSectionTimeMillis : Long("<num>"),
   countDocsClonedOnRecipient : Long("<num>"),
   countBytesClonedOnRecipient : Long("<num>"),
   countDocsClonedOnCatchUpOnRecipient : Long("<num>"),
   countBytesClonedOnCatchUpOnRecipient : Long("<num>"),
   countDocsClonedOnDonor : Long("<num>"),
   countRecipientMoveChunkStarted : Long("<num>"),
   countDocsDeletedByRangeDeleter : Long("<num>"),
   countDonorMoveChunkLockTimeout : Long("<num>"),
   unfinishedMigrationFromPreviousPrimary : Long("<num>"),
   chunkMigrationConcurrency : Long("<num>"),
   countTransitionToDedicatedConfigServerStarted : Long("<num>"), // Added in MongoDB 8.0
   countTransitionToDedicatedConfigServerCompleted : Long("<num>"), // Added in MongoDB 8.0
   countTransitionFromDedicatedConfigServerCompleted : Long("<num>"), // Added in MongoDB 8.0
   catalogCache : {
      numDatabaseEntries : Long("<num>"),
      numCollectionEntries : Long("<num>"),
      countStaleConfigErrors : Long("<num>"),
      totalRefreshWaitTimeMicros : Long("<num>"),
      numActiveIncrementalRefreshes : Long("<num>"),
      countIncrementalRefreshesStarted : Long("<num>"),
      numActiveFullRefreshes : Long("<num>"),
      countFullRefreshesStarted : Long("<num>"),
      countFailedRefreshes : Long("<num>")
   },
   rangeDeleterTasks : <num>,
   configServerInShardCache : <boolean>, // Added in MongoDB 8.0
   resharding : {
      countStarted : Long("1"),
       countSucceeded : Long("1"),
       countFailed : Long("0"),
       countCanceled : Long("0"),
       lastOpEndingChunkImbalance : Long("0"),
       active : {
               documentsCopied : Long("0"),
               bytesCopied : Long("0"),
               countWritesToStashCollections : Long("0"),
               countWritesDuringCriticalSection : Long("0"),
               countReadsDuringCriticalSection : Long("0"),
               oplogEntriesFetched : Long("0"),
               oplogEntriesApplied : Long("0"),
               insertsApplied : Long("0"),
               updatesApplied : Long("0"),
               deletesApplied : Long("0")
       },
       oldestActive : {
               coordinatorAllShardsHighestRemainingOperationTimeEstimatedMillis : Long("0"),
               coordinatorAllShardsLowestRemainingOperationTimeEstimatedMillis : Long("0"),
               recipientRemainingOperationTimeEstimatedMillis : Long("0")
       },
       latencies : {
               collectionCloningTotalRemoteBatchRetrievalTimeMillis : Long("0"),
               collectionCloningTotalRemoteBatchesRetrieved : Long("0"),
               collectionCloningTotalLocalInsertTimeMillis : Long("0"),
               collectionCloningTotalLocalInserts : Long("0"),
               oplogFetchingTotalRemoteBatchRetrievalTimeMillis : Long("0"),
               oplogFetchingTotalRemoteBatchesRetrieved : Long("0"),
               oplogFetchingTotalLocalInsertTimeMillis : Long("0"),
               oplogFetchingTotalLocalInserts : Long("0"),
               oplogApplyingTotalLocalBatchRetrievalTimeMillis : Long("0"),
               oplogApplyingTotalLocalBatchesRetrieved : Long("0"),
               oplogApplyingTotalLocalBatchApplyTimeMillis : Long("0"),
               oplogApplyingTotalLocalBatchesApplied : Long("0")
       },
       currentInSteps : {
               countInstancesInCoordinatorState1Initializing : Long("0"),
               countInstancesInCoordinatorState2PreparingToDonate : Long("0"),
               countInstancesInCoordinatorState3Cloning : Long("0"),
               countInstancesInCoordinatorState4Applying : Long("0"),
               countInstancesInCoordinatorState5BlockingWrites : Long("0"),
               countInstancesInCoordinatorState6Aborting : Long("0"),
               countInstancesInCoordinatorState7Committing : Long("-1"),
               countInstancesInRecipientState1AwaitingFetchTimestamp : Long("0"),
               countInstancesInRecipientState2CreatingCollection : Long("0"),
               countInstancesInRecipientState3Cloning : Long("0"),
               countInstancesInRecipientState4Applying : Long("0"),
               countInstancesInRecipientState5Error : Long("0"),
               countInstancesInRecipientState6StrictConsistency : Long("0"),
               countInstancesInRecipientState7Done : Long("0"),
               countInstancesInDonorState1PreparingToDonate : Long("0"),
               countInstancesInDonorState2DonatingInitialData : Long("0"),
               countInstancesInDonorState3DonatingOplogEntries : Long("0"),
               countInstancesInDonorState4PreparingToBlockWrites : Long("0"),
               countInstancesInDonorState5Error : Long("0"),
               countInstancesInDonorState6BlockingWrites : Long("0"),
               countInstancesInDonorState7Done : Long("0")
       }
    }
   }
},

mongos에서 실행되는 경우:

shardingStatistics : {
   numHostsTargeted: {
      find : {
         allShards: Long("<num>"),
         manyShards: Long("<num>"),
         oneShard: Long("<num>"),
         unsharded: Long("<num>")
               },
      insert: {
         allShards: Long("<num>"),
         manyShards: Long("<num>"),
         oneShard: Long("<num>"),
         unsharded: Long("<num>")
               },
      update: {
         allShards: Long("<num>"),
         manyShards: Long("<num>"),
         oneShard: Long("<num>"),
         unsharded: Long("<num>")
               },
      delete: {
         allShards: Long("<num>"),
         manyShards: Long("<num>"),
         oneShard: Long("<num>"),
         unsharded: Long("<num>")
               },
      aggregate: {
         allShards: Long("<num>"),
         manyShards: Long("<num>"),
         oneShard: Long("<num>"),
         unsharded: Long("<num>")
               }
      }
   },
   catalogCache : {
      numDatabaseEntries : Long("<num>"),
      numCollectionEntries : Long("<num>"),
      countStaleConfigErrors : Long("<num>"),
      totalRefreshWaitTimeMicros : Long("<num>"),
      numActiveIncrementalRefreshes : Long("<num>"),
      countIncrementalRefreshesStarted : Long("<num>"),
      numActiveFullRefreshes : Long("<num>"),
      countFullRefreshesStarted : Long("<num>"),
      countFailedRefreshes : Long("<num>")
   },
   configServerInShardCache : <boolean> // Added in MongoDB 8.0
}

shardingStatistics: 샤딩된 클러스터에서의 메타데이터 새로고침에 대한 지표가 포함된 문서입니다.

shardingStatistics.countStaleConfigErrors

스레드가 오래된 구성 예외에 도달한 총 횟수입니다. 이 숫자는 오래된 구성 예외가 메타데이터 새로고침을 유발하므로 메타데이터 새로고침 횟수에 대략적으로 비례합니다.

샤드에서 실행할 때만 존재합니다.

shardingStatistics.countDonorMoveChunkStarted

MongoDB가 범위 마이그레이션 절차의 일환으로 샤드의 프라이머리 노드에서 moveChunk 명령 또는 moveRange 명령을 시작하는 총 횟수입니다. 이처럼 증가하는 숫자에는 청크 마이그레이션의 성공 여부가 반영되지 않습니다.

샤드에서 실행할 때만 존재합니다.

shardingStatistics.countDonorMoveChunkCommitted

MongoDB가 샤드의 프라이머리 노드에서 커밋하는 청크 마이그레이션의 총 횟수입니다.

청크 마이그레이션은 범위 마이그레이션 절차의 moveChunk 명령 및 moveRange 명령으로 실행됩니다.

샤드에서만 사용할 수 있습니다.

MongoDB 7.1(및 7.0, 6.3.2, 6.0.6 및 5.0.18)부터 사용할 수 있습니다.

shardingStatistics.countDonorMoveChunkAborted

MongoDB가 샤드의 프라이머리 노드에서 중단하는 청크 마이그레이션의 총 횟수입니다.

청크 마이그레이션은 범위 마이그레이션 절차의 moveChunk 명령 및 moveRange 명령으로 실행됩니다.

샤드에서만 사용할 수 있습니다.

MongoDB 7.1(및 7.0, 6.3.2, 6.0.6 및 5.0.18)부터 사용할 수 있습니다.

shardingStatistics.totalDonorMoveChunkTimeMillis

현재 샤드에서 다른 샤드로 청크를 이동시킬 때의 누적 시간(단위: 밀리초)입니다. 각 청크 마이그레이션의 시간은 moveRange 또는 moveChunk 명령이 시작될 때 시작되고, 범위 마이그레이션 절차에서 청크를 다른 샤드로 이동시킬 때 종료됩니다.

샤드에서만 사용할 수 있습니다.

MongoDB 7.1(및 7.0, 6.3.2, 6.0.6 및 5.0.18)부터 사용할 수 있습니다.

shardingStatistics.totalDonorChunkCloneTimeMillis

범위 마이그레이션 절차의 복제 단계가 샤드의 프라이머리 노드에서 실행될 때의 누적 시간(단위: 밀리초)입니다. 특히 이 샤드에서의 각 마이그레이션에 대해 추적된 시간은 moveRange 명령 및 moveChunk 명령으로 시작되고, 대상 샤드가 범위 마이그레이션 절차 도중에 발생한 변경사항을 적용하기 위해 catchup 단계로 들어가기 전에 종료됩니다.

샤드에서 실행할 때만 존재합니다.

shardingStatistics.totalCriticalSectionCommitTimeMillis

범위 마이그레이션 절차의 메타데이터 업데이트 단계가 샤드의 프라이머리 노드에서 실행될 때의 누적 시간(단위: 밀리초)입니다. MongoDB는 메타데이터 업데이트 단계에서 해당 컬렉션에 대한 모든 연산을 차단합니다.

샤드에서 실행할 때만 존재합니다.

shardingStatistics.totalCriticalSectionTimeMillis

범위 마이그레이션 절차의 따라잡기 단계 및 메타데이터 업데이트 단계가 샤드의 프라이머리 노드에서 실행될 때의 누적 시간(단위: 밀리초)입니다.

따라잡기 단계의 기간을 계산하려면 totalCriticalSectionTimeMillis에서 totalCriticalSectionCommitTimeMillis을(를) 빼세요.

totalCriticalSectionTimeMillis - totalCriticalSectionCommitTimeMillis

샤드에서 실행할 때만 존재합니다.

shardingStatistics.countDocsClonedOnRecipient

MongoDB가 수신자 샤드의 프라이머리 노드에서 복제하는 문서의 상시 증가형 누적 개수입니다.

샤드에서 실행할 때만 존재합니다.

shardingStatistics.countBytesClonedOnRecipient

MongoDB가 범위 마이그레이션 절차 도중에 수신자 샤드의 프라이머리 노드에서 복제하는 바이트의 누적 수입니다.

데이터 동기화에 대한 자세한 내용은 Replica Set Data Synchronization(복제본 세트 데이터 동기화)을(를) 참조하세요.

샤드에서만 사용할 수 있습니다.

MongoDB 7.1(및 7.0, 6.3.2, 6.0.6 및 5.0.18)부터 사용할 수 있습니다.

shardingStatistics.countDocsClonedOnCatchUpOnRecipient

MongoDB가 범위 마이그레이션 절차의 따라잡기 단계 도중에 수신자 샤드의 프라이머리 노드에서 복제하는 문서의 누적 개수입니다.

데이터 동기화에 대한 자세한 내용은 Replica Set Data Synchronization(복제본 세트 데이터 동기화)을(를) 참조하세요.

샤드에서만 사용할 수 있습니다.

MongoDB 7.1(및 7.0, 6.3.2, 6.0.6 및 5.0.18)부터 사용할 수 있습니다.

shardingStatistics.countBytesClonedOnCatchUpOnRecipient

MongoDB가 범위 마이그레이션 절차의 따라잡기 단계 도중에 수신자 샤드의 프라이머리 노드에서 복제하는 바이트의 누적 수입니다.

데이터 동기화에 대한 자세한 내용은 Replica Set Data Synchronization(복제본 세트 데이터 동기화)을(를) 참조하세요.

샤드에서만 사용할 수 있습니다.

MongoDB 7.1(및 7.0, 6.3.2, 6.0.6 및 5.0.18)부터 사용할 수 있습니다.

shardingStatistics.countDocsClonedOnDonor

MongoDB가 기증자 샤드의 프라이머리 노드에서 복제하는 문서의 상시 증가형 누적 개수입니다.

샤드에서 실행할 때만 존재합니다.

shardingStatistics.countRecipientMoveChunkStarted

수신자 샤드의 프라이머리 역할을 하는 이 멤버가 수신하기 시작한 청크의 상시 증가형 누적 개수입니다(이동의 성공 여부와 무관함).

샤드에서 실행할 때만 존재합니다.

shardingStatistics.countDocsDeletedByRangeDeleter

MongoDB가 청크 마이그레이션 도중에 기증자 샤드의 프라이머리 노드에서 삭제하는 문서의 상시 증가형 누적 개수입니다.

샤드에서 실행할 때만 존재합니다.

버전 7.1의 변경사항입니다.

shardingStatistics.countDonorMoveChunkLockTimeout

잠금 획득 시간 초과로 인해 MongoDB가 기증자 샤드의 프라이머리 노드에서 중단하는 청크 마이그레이션의 상시 증가형 누적 횟수입니다.

샤드에서 실행할 때만 존재합니다.

shardingStatistics.unfinishedMigrationFromPreviousPrimary

투표 후 이전 프라이머리에서 남겨진 미완료 마이그레이션의 횟수입니다. 이 값은 새로 선출된 mongod이(가) 프라이머리로의 전환을 완료한 후에만 업데이트됩니다.

샤드에서 실행할 때만 존재합니다.

shardingStatistics.chunkMigrationConcurrency

청크 마이그레이션 연산 실행에 필요한 소스 샤드와 수신 샤드의 스레드 수입니다.

샤드에서 실행할 때만 존재합니다.

MongoDB 6.3(및 5.0.15)부터 사용할 수 있습니다.

shardingStatistics.catalogCache: 클러스터의 라우팅 정보 캐시에 대한 통계가 포함된 문서입니다.

shardingStatistics.catalogCache.numDatabaseEntries: 현재 카탈로그 캐시에 있는 데이터베이스 항목의 총 개수입니다.

shardingStatistics.catalogCache.numCollectionEntries: 현재 카탈로그 캐시에 있는 컬렉션 항목(모든 데이터베이스에 걸쳐 존재함)의 총 개수입니다.

shardingStatistics.catalogCache.countStaleConfigErrors: 스레드가 오래된 구성 예외에 도달한 총 횟수입니다. 오래된 구성 예외는 메타데이터 새로고침을 유발합니다.

shardingStatistics.catalogCache.totalRefreshWaitTimeMicros: 스레드가 메타데이터 새로고침을 대기해야 했던 누적 시간(단위: 마이크로초)입니다.

shardingStatistics.catalogCache.numActiveIncrementalRefreshes: 현재 완료되기까지 대기 중인 증분 카탈로그 캐시 새로고침의 횟수입니다.

shardingStatistics.countIncrementalRefreshesStarted: 시작된 증분 새로고침의 누적 횟수입니다.

shardingStatistics.catalogCache.numActiveFullRefreshes: 현재 완료되기까지 대기 중인 전체 카탈로그 캐시 새로고침의 횟수입니다.

shardingStatistics.catalogCache.countFullRefreshesStarted: 시작된 전체 새로고침의 누적 횟수입니다.

shardingStatistics.catalogCache.countFailedRefreshes: 실패한 전체 새로고침 또는 증분 새로고침의 누적 횟수입니다.

shardingStatistics.countTransitionToDedicatedConfigServerStarted

transitionToDedicatedConfigServer 명령이 시작된 횟수입니다.

Config 서버 노드에서 실행할 때만 존재합니다.

버전 8.0에 추가 되었습니다.

shardingStatistics.countTransitionToDedicatedConfigServerCompleted

transitionToDedicatedConfigServer 명령이 완료된 횟수입니다.

Config 서버 노드에서 실행할 때만 존재합니다.

버전 8.0에 추가 되었습니다.

shardingStatistics.countTransitionFromDedicatedConfigServerCompleted

transitionFromDedicatedConfigServer 명령이 완료된 횟수입니다.

Config 서버 노드에서 실행할 때만 존재합니다.

버전 8.0에 추가 되었습니다.

shardingStatistics.rangeDeleterTasks

범위 마이그레이션 절차의 일환으로 실행할 준비가 되었거나 실행 중인 대기 중 청크 범위 삭제 작업의 현재 총합입니다.

청크 마이그레이션 이후 샤드에서의 삭제를 대기 중인 청크 범위에 대한 정보는 config.rangeDeletions 컬렉션의 문서에서 확인하세요.

샤드 멤버에서 실행될 때만 존재합니다.

shardingStatistics.configServerInShardCache: Config 서버가 구성 샤드인지 여부를 나타내는 부울입니다. 이 값은 주기적으로 새로 고쳐지므로 configServerInShardCache 값은 정상 클러스터에서 최대 약 1분 동안 오래된 값일 수 있습니다. 노드가 Config 서버와 통신할 수 없는 경우 configServerInShardCache눈 더 오랜 기간 동안 오래된 상태로 유지될 수 있습니다.

shardingStatistics.resharding

리샤딩 연산에 대한 통계가 포함된 문서입니다.

각 샤드는 자체적인 리샤딩 연산 통계를 반환합니다. 샤드가 리샤딩 연산에 포함되지 않은 경우, 이 샤드에는 해당 리샤딩 연산에 대한 통계가 포함되지 않습니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다.

버전 5.0에 추가.

shardingStatistics.resharding.countStarted

countSucceeded, countFailed, countCanceled의 합계입니다. 이 합계는 리샤딩 연산이 시작되었으나 아직 완료되지 않은 경우 1씩 더 증가합니다. mongod가 시작되거나 재시작되면 합계가 0으로 설정됩니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다.

버전 5.0에 추가.

shardingStatistics.resharding.countSucceeded

성공한 리샤딩 연산의 개수입니다. mongod이(가) 시작되거나 재시작되면 숫자가 0으로 설정됩니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다.

버전 5.0에 추가.

shardingStatistics.resharding.countFailed

실패한 리샤딩 연산의 개수입니다. mongod이(가) 시작되거나 재시작되면 숫자가 0으로 설정됩니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다.

버전 5.0에 추가.

shardingStatistics.resharding.countCanceled

취소된 리샤딩 연산의 개수입니다. mongod이(가) 시작되거나 재시작되면 숫자가 0으로 설정됩니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다.

버전 5.0에 추가.

shardingStatistics.active.resharding.documentsCopied

현행 리샤딩 연산을 위해 기증자 샤드에서 수신자 샤드로 복사된 문서의 개수입니다. 새로운 리샤딩 연산이 시작되면 숫자가 0으로 설정됩니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다. config 서버에서 0을 반환합니다.

버전 5.0에 추가.

버전 6.1에서 업데이트

shardingStatistics.resharding.active.bytesCopied

현행 리샤딩 연산을 위해 기증자 샤드에서 수신자 샤드로 복사된 바이트의 수입니다. 새로운 리샤딩 연산이 시작되면 숫자가 0으로 설정됩니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다. config 서버에서 0을 반환합니다.

버전 5.0에 추가.

버전 6.1에서 업데이트

shardingStatistics.resharding.active.countWritesToStashCollections: 리샤딩 도중에 수신자 스태시 컬렉션에 대해 이뤄지는 쓰기의 건수입니다.
버전 6.1에 추가.

shardingStatistics.resharding.active.countWritesDuringCriticalSection

현행 리샤딩 연산의 중요 섹션에서 실행되는 쓰기의 건수입니다. 중요 섹션은 현재 리샤딩 중인 컬렉션에 새로 수신되는 쓰기를 방지합니다. 새로운 리샤딩 연산이 시작되면 숫자가 0으로 설정됩니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다. config 서버에서 0을 반환합니다.

버전 5.0에 추가.

버전 6.1에서 업데이트

shardingStatistics.resharding.active.countReadsDuringCriticalSection: 리샤딩 도중에 기증자의 중요 섹션에서 시도된 읽기의 건수입니다.
버전 6.1에 추가.

shardingStatistics.resharding.active.oplogEntriesFetched

현행 리샤딩 연산을 위해 oplog에서 가져온 항목의 개수입니다. 새로운 리샤딩 연산이 시작되면 숫자가 0으로 설정됩니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다. config 서버에서 0을 반환합니다.

버전 6.1에서 업데이트

shardingStatistics.resharding.active.oplogEntriesApplied

현행 리샤딩 연산을 위해 oplog에 적용된 항목의 개수입니다. 새로운 리샤딩 연산이 시작되면 숫자가 0으로 설정됩니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다. config 서버에서 0을 반환합니다.

버전 5.0에 추가.

버전 6.1에서 업데이트

shardingStatistics.resharding.active.insertsApplied: 리샤딩 도중에 적용된 삽입 연산의 총 개수입니다.
버전 6.1에 추가.

shardingStatistics.resharding.active.updatesApplied: 리샤딩 도중에 적용된 업데이트 연산의 총 개수입니다.
버전 6.1에 추가.

shardingStatistics.resharding.active.deletesApplied: 리샤딩 도중에 적용된 삭제 연산의 총 개수입니다.
버전 6.1에 추가.

shardingStatistics.resharding.oldestActive.coordinatorAllShardsHighestRemainingOperationTimeEstimatedMillis: 모든 샤드를 합쳐서 계산된 남은 시간(초)의 최고 추정치입니다. 시간 추정치를 계산할 수 없는 경우에는 값이 -1로 설정됩니다.
버전 6.1에 추가.

shardingStatistics.resharding.oldestActive.coordinatorAllShardsLowestRemainingOperationTimeEstimatedMillis: 모든 샤드에 합쳐서 계산된 남은 시간(초)의 최저 추정치입니다. 시간 추정치를 계산할 수 없는 경우에는 값이 -1로 설정됩니다.
버전 6.1에 추가.

shardingStatistics.resharding.oldestActive.recipientRemainingOperationTimeEstimatedMillis

현행 리샤딩 연산의 잔여 시간 추정치(단위: 밀리초)입니다. 리샤딩 이전이거나 시간을 계산할 수 없는 경우에는 값이 -1로 설정됩니다.

샤드가 여러 리샤딩 연산에 포함된 경우, 이 필드에는 해당 샤드가 수신자인 가장 오래된 리샤딩 연산의 잔여 시간 추정치가 포함됩니다.

버전 6.1에 추가.

shardingStatistics.resharding.oldestActive.totalOperationTimeElapsedMillis

현행 리샤딩 연산의 총 경과 시간(단위: 밀리초)입니다. 새로운 리샤딩 연산이 시작되면 시간이 0으로 설정됩니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다. config 서버에서 0을 반환합니다.

버전 5.0에 추가.

shardingStatistics.resharding.latencies: 리샤딩 연산의 시간 지표입니다.
버전 6.1에 추가.

shardingStatistics.resharding.latencies.collectionCloningTotalRemoteBatchRetrievalTimeMillis: 수신자가 기증자로부터의 문서 배치 검색에 소비한 총 시간(단위: 밀리초)입니다.
버전 6.1에 추가.

shardingStatistics.resharding.latencies.collectionCloningTotalRemoteBatchesRetrieved: 수신자가 기증자로부터 검색한 문서 배치의 총 개수입니다.
버전 6.1에 추가.

shardingStatistics.resharding.latencies.collectionCloningTotalLocalInsertTimeMillis: 수신자가 기증자로부터의 문서 배치 삽입에 소비한 총 시간(단위: 밀리초)입니다.
버전 6.1에 추가.

shardingStatistics.resharding.latencies.collectionCloningTotalLocalInserts: 수신자가 삽입한 기증자로부터의 문서 배치의 총 개수입니다.
버전 6.1에 추가.

shardingStatistics.resharding.latencies.oplogFetchingTotalRemoteBatchRetrievalTimeMillis: 수신자가 기증자로부터의 oplog 항목 배치 검색에 소비한 총 시간(단위: 밀리초)입니다.
버전 6.1에 추가.

shardingStatistics.resharding.latencies.oplogFetchingTotalRemoteBatchesRetrieved: 수신자가 기증자로부터 검색한 oplog 항목 배치의 총 개수입니다.
버전 6.1에 추가.

shardingStatistics.resharding.latencies.oplogFetchingTotalLocalInsertTimeMillis: 수신자가 기증자로부터의 oplog 항목 배치 삽입에 소비한 총 시간(단위: 밀리초)입니다.
버전 6.1에 추가.

shardingStatistics.resharding.latencies.oplogFetchingTotalLocalInserts: 수신자가 삽입한 기증자로부터의 oplog 항목 배치의 총 개수입니다.
버전 6.1에 추가.

shardingStatistics.resharding.latencies.oplogApplyingTotalLocalBatchRetrievalTimeMillis: 수신자가 가져오기 도중에 삽입된 oplog 항목 배치의 검색에 소비한 총 시간(단위: 밀리초)입니다.
버전 6.1에 추가.

shardingStatistics.resharding.latencies.oplogApplyingTotalLocalBatchesRetrieved: 수신자가 검색했으며 가져오기 도중에 삽입된 oplog 항목 배치의 총 개수입니다.
버전 6.1에 추가.

shardingStatistics.resharding.latencies.oplogApplyingTotalLocalBatchApplyTimeMillis: 수신자가 oplog 항목 배치 적용에 소비한 총 시간(단위: 밀리초)입니다.
버전 6.1에 추가.

shardingStatistics.resharding.latencies.oplogApplyingTotalLocalBatchesApplied: 수신자가 적용한 oplog 항목 배치의 총 개수입니다.
버전 6.1에 추가.

shardingStatistics.resharding.totalApplyTimeElapsedMillis

현행 리샤딩 연산의 적용 단계의 총 경과 시간(단위: 밀리초)입니다. 적용 단계에서 수신자 샤드는 기증자 샤드로부터 새로 수신되는 쓰기를 기반으로 데이터를 수정합니다. 새로운 리샤딩 연산이 시작되면 시간이 0으로 설정됩니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다. config 서버에서 0을 반환합니다.

버전 5.0에 추가.

shardingStatistics.resharding.totalCriticalSectionTimeElapsedMillis

현행 리샤딩 연산의 중요 섹션의 총 경과 시간(단위: 밀리초)입니다. 중요 섹션은 현재 리샤딩 중인 컬렉션에 새로 수신되는 쓰기를 방지합니다. 새로운 리샤딩 연산이 시작되면 시간이 0으로 설정됩니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다. config 서버에서 0을 반환합니다.

버전 5.0에 추가.

shardingStatistics.resharding.donorState

현행 리샤딩 연산에 필요한 기증자 샤드의 상태입니다. 새로운 리샤딩 연산이 시작되면 숫자가 0으로 설정됩니다.

숫자 반환	의미	설명
0	`unused`	이 샤드는 현행 리샤딩 연산의 기증자가 아닙니다.
1	`preparing-to-donate`	기증자 샤드가 수신자 샤드에 데이터를 기증할 준비를 하고 있습니다.
2	`donating-initial-data`	기증자 샤드가 수신자 샤드에 데이터를 기증 중입니다.
3	`donating-oplog-entries`	기증자 샤드가 수신자 샤드에 oplog 항목을 기증 중입니다.
4	`preparing-to-block-writes`	기증자 샤드가 리샤딩 중인 컬렉션에 새로 수신되는 쓰기 연산을 방지하려고 합니다.
5	`error`	리샤딩 연산 중에 오류가 발생했습니다.
6	`blocking-writes`	기증자 샤드가 새로 수신되는 쓰기 연산을 방지하고 있습니다. 또한 기증자 샤드는 새로 수신되는 쓰기를 방지한 사실을 모든 수신자 샤드에 알렸습니다.
7	`done`	기증자 샤드가 이전의 샤드 컬렉션을 제거했으며 리샤딩 연산이 완료되었습니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다. config 서버에서 0을 반환합니다.

버전 5.0에 추가.

shardingStatistics.resharding.recipientState

현행 리샤딩 연산에 필요한 수신자 샤드의 상태입니다. 새로운 리샤딩 연산이 시작되면 숫자가 0으로 설정됩니다.

숫자 반환	의미	설명
0	`unused`	이 샤드는 현행 리샤딩 연산의 수신자가 아닙니다.
1	`awaiting-fetch-timestamp`	수신자 샤드가 기증자 샤드가 데이터를 기증할 준비가 될 때까지 대기 중입니다.
2	`creating-collection`	수신자 샤드가 새 샤드 컬렉션을 생성 중입니다.
3	`cloning`	수신자 샤드가 기증자 샤드로부터 데이터를 수신 중입니다.
4	`applying`	수신자 샤드가 기증자 샤드로부터 새로 수신되는 쓰기를 기반으로 데이터 사본을 수정하기 위해 oplog 항목을 적용 중입니다.
5	`error`	리샤딩 연산 중에 오류가 발생했습니다.
6	`strict-consistency`	수신자 샤드의 임시 컬렉션에는 모든 데이터 변경사항이 저장되어 있습니다.
7	`done`	리샤딩 연산이 완료되었습니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다. config 서버에서 0을 반환합니다.

버전 5.0에 추가.

shardingStatistics.numHostsTargeted

CRUD 연산 및 집계 명령을 대상으로 하는 샤드의 개수를 나타냅니다. CRUD 연산 또는 집계 명령이 실행되면 다음 지표가 증가합니다.

이름	설명
`allShards`	모든 샤드를 대상으로 하는 명령
`manyShards`	2개 이상의 샤드를 대상으로 하는 명령
`oneShard`	1개 샤드를 대상으로 하는 명령
`unsharded`	샤딩되지 않은 컬렉션에서 명령이 실행됨

참고

mongos에서 serverStatus 명령을 실행하면 샤딩된 클러스터에서 실행되는 CRUD 연산 및 집계 연산에 대한 인사이트를 얻을 수 있습니다.

멀티 샤드 연산은 분산 수집 또는 샤드별 작업일 수 있습니다. 멀티 샤드 분산 수집 연산은 더 많은 리소스를 사용할 수 있습니다. shardingStatistics.numHostsTargeted 지표를 사용하면 샤딩된 클러스터에서 실행되는 집계 쿼리를 조정할 수 있습니다.

shardingStatistics.resharding.coordinatorState

현행 리샤딩 연산에 필요한 리샤딩 조정자의 상태입니다. 리샤딩 조정자는 config 서버 프라이머리에서 실행되는 스레드입니다. 새로운 리샤딩 연산이 시작되면 숫자가 0으로 설정됩니다.

숫자 반환	의미	설명
0	`unused`	이 샤드는 현행 리샤딩 연산의 조정자가 아닙니다.
1	`initializing`	리샤딩 조정자가 조정자 문서를 `config.reshardingOperations`에 삽입한 후 원본 컬렉션의 `config.collections` 항목에 `reshardingFields`을(를) 추가했습니다.
2	`preparing-to-donate`	리샤딩 조정자가 임시 리샤딩 컬렉션의 `config.collections` 항목을 생성했습니다. 새 샤드 키를 기준으로 한 범위의 `config.chunks`에 항목을 삽입했습니다. 새 샤드 키에 연결된 모든 구역의 `config.tags`에 항목을 삽입했습니다. 조정자는 리샤딩 연산을 시작하라고 참여자 샤드에 알립니다. 그런 다음 조정자는 모든 기증자 샤드가 `minFetchTimestamp`을(를) 선택하고 기증할 준비가 될 때까지 대기합니다.
3	`cloning`	리샤딩 조정자는 데이터를 수신자 샤드에 기증하라고 기증자 샤드에 알립니다. 조정자는 모든 수신자가 기증자로부터의 데이터 복제를 완료할 때까지 대기합니다.
4	`applying`	리샤딩 조정자는 기증자 샤드로부터 새로 수신되는 쓰기를 기반으로 데이터 사본을 수정하라고 수신자 샤드에 알립니다. 조정자는 모든 수신자가 oplog 항목 적용을 완료할 때까지 대기합니다.
5	`blocking-writes`	리샤딩 조정자는 리샤딩 중인 컬렉션에 새로 수신되는 쓰기 연산을 방지하라고 기증자 샤드에 알립니다. 그런 다음 조정자는 모든 수신자가 모든 데이터를 변경할 때까지 대기합니다.
6	`aborting`	리샤딩 연산 중에 복구 불가능한 오류가 발생했거나 `abortReshardCollection` 명령(또는 `sh.abortReshardCollection()` 메서드)이 실행되었습니다.
6	`committing`	리샤딩 조정자는 임시 리샤딩 컬렉션의 `config.collections` 항목을 제거합니다. 그런 다음 조정자는 소스 컬렉션의 항목에 `recipientFields`을(를) 추가합니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다.

버전 5.0에 추가.

shardingStatistics.resharding.opStatus

현행 리샤딩 연산의 상태입니다.

숫자 반환	설명
-1	리샤딩 연산이 진행 중 상태가 아닙니다.
0	리샤딩 연산이 성공했습니다.
1	리샤딩 연산이 실패했습니다.
2	리샤딩 연산이 취소되었습니다.

샤드 또는 config 서버에서 실행할 때만 존재합니다.

버전 5.0에 추가.

shardingStatistics.resharding.lastOpEndingChunkImbalance

이 필드에는 가장 최근의 리샤딩 연산으로 처리된 컬렉션의 모든 구역중 (maxNumChunksInShard - minNumChunksInShard)의 가장 큰 수치 차이가 포함됩니다.

Range Size(범위 크기)를 참조하세요.

config 서버에서만 업데이트됩니다.

버전 5.0에 추가.

shardedIndexConsistency

shardedIndexConsistency : {
   numShardedCollectionsWithInconsistentIndexes : Long("<num>")
},

shardedIndexConsistency

config 서버 인스턴스에서만 사용할 수 있습니다.

샤드 컬렉션에 대한 인덱스 일관성 검사 결과를 반환하는 문서입니다.

반환된 메트릭은 샤딩된 클러스터의 구성 서버 복제본 세트의 프라이머리 서버에서 실행되는 경우에만 의미가 있습니다.

팁

다음도 참조하세요.

enableShardedIndexConsistencyCheck parameter
shardedIndexConsistencyCheckIntervalMS parameter

shardedIndexConsistency.numShardedCollectionsWithInconsistentIndexes

config 서버 인스턴스에서만 사용할 수 있습니다.

모든 샤드를 통틀어 인덱스가 비일관적인 샤드 컬렉션의 개수입니다. 컬렉션의 각 샤드(해당 컬렉션에 맞는 청크가 포함됨)에 완전히 동일한 인덱스(인덱스 옵션 포함)가 없을 경우에는 샤드 컬렉션에 비일관적인 인덱스가 포함됩니다.

샤드 컬렉션에 비일관적인 인덱스가 있는지 조사하려면 Find Inconsistent Indexes Across Shards(모든 샤드에서 비일관적인 인덱스 찾기)를 참조하세요.

반환된 메트릭은 샤딩된 클러스터의 구성 서버 복제본 세트의 프라이머리 서버에서 실행되는 경우에만 의미가 있습니다.

팁

다음도 참조하세요.

enableShardedIndexConsistencyCheck parameter
shardedIndexConsistencyCheckIntervalMS parameter

storageEngine

storageEngine : {
   name : <string>,
   supportsCommittedReads : <boolean>,
   persistent : <boolean>
},

storageEngine: 현재 스토리지 엔진에 대한 데이터가 포함된 문서입니다.

storageEngine.name: 현재 스토리지 엔진의 이름입니다.

storageEngine.supportsCommittedReads: 스토리지 엔진이 "majority" 읽기 고려를 지원하는지 여부를 나타내는 부울입니다.

storageEngine.persistent: 스토리지 엔진이 데이터를 디스크에 계속 보관하는지, 보관하지 않는지 여부를 나타내는 부울입니다.

tcmalloc

참고

tcmalloc 이 페이지에서는 내부적으로만 사용되는 지표는 생략되었습니다.

tcmalloc : {
   usingPerCPUCaches : <boolean>,  // Added in MongoDB 8.0
   maxPerCPUCacheSizeBytes : <integer>, // Added in MongoDB 8.0
   generic : {
      current_allocated_bytes : <integer>,
      heap_size : <integer>,
      peak_memory_usage : <integer>  // Added in MongoDB 8.0
   },
   tcmalloc : {
      central_cache_free : <integer>,
      cpu_free : <integer>,  // Added in MongoDB 8.0
      release_rate : <integer>,
      total_bytes_held : <integer>,  // Added in MongoDB 8.0
      cpuCache : {
         0 : {
            overflows : <integer>,  // Added in MongoDB 8.0
            underflows : <integer>  // Added in MongoDB 8.0
         },
      }
   },
   tcmalloc_derived : {
      total_free_bytes : <integer>  // Added in MongoDB 8.0
   }
}

tcmalloc

참고

8.0버전부터 MongoDB는 메모리 단편화 및 관리를 개선하는 업데이트된 버전의 TCMalloc을 사용합니다. 자세한 내용은 tcmalloc 업그레이드를 참조하세요.

서버의 메모리 할당에 대한 정보가 포함된 문서입니다. 기본적으로 tcmalloc 지표는 serverStatus 출력에 포함됩니다. tcmalloc 섹션의 상세도를 변경하려면 0과 3(포함) 사이의 정수를 지정합니다.

상세도를 0으로 설정하다 하면 tcmalloc 지표 가 serverStatus 출력에 포함되지 않습니다.
상세도를 1로 설정하면 serverStatus 출력에 기본 tcmalloc 지표가 포함됩니다.
상세도를 2로 설정하면 serverStatus 출력에는 기본 tcmalloc 지표와 tcmalloc.tcmalloc.cpuCache 섹션이 포함됩니다.
상세도를 3으로 설정하면 serverStatus 출력에 모든 tcmalloc 지표가 포함됩니다.

3보다 큰 값을 지정하면 MongoDB는 verbosity를 3로 설정합니다.

예를 들어 verbosity를 2 로 설정한 상태에서 serverStatus를 호출하려면 다음 명령을 실행합니다.

db.runCommand( { serverStatus: 1, tcmalloc: 2 } )

팁

다음도 참조하세요.

TCMalloc Stats

tcmalloc.usingPerCPUCaches

TCMalloc이 CPU별 캐시로 실행 중인지 여부를 나타내는 부울입니다. tcmalloc.usingPerCPUCaches가 false인 경우 다음 사항을 확인하세요.

glibc rseq를 비활성화했습니다.
Linux 커널 버전 4.18 이상을 사용하고 있습니다.

버전 8.0에 추가 되었습니다.

tcmalloc.maxPerCPUCacheSizeBytes: 각 CPU 캐시의 최대 크기(바이트 단위)입니다.
버전 8.0에 추가 되었습니다.

tcmalloc.generic.peak_memory_usage: MongoDB가 언제든지 할당할 수 있는 최대 메모리 양(바이트)입니다.
버전 8.0에 추가 되었습니다.

tcmalloc.generic.current_allocated_bytes: 현재 메모리에 할당되어 있고 MongoDB에서 활발히 사용하는 총 바이트 수입니다.

tcmalloc.generic.heap_size: 운영 체제에서 할당된 메모리 용량(바이트 단위)입니다. 이 값에는 현재 사용 중인 메모리와 할당되었지만 사용 중이 아닌 메모리가 포함됩니다.

tcmalloc.tcmalloc.central_cache_free: 중앙 여유 목록에 보관된 메모리 용량(바이트)입니다. 중앙 여유 목록은 재사용할 수 있는 여유 메모리를 관리하는 구조입니다.

tcmalloc.tcmalloc.cpu_free: 모든 CPU 캐시에서 사용할 수 있는 여유 메모리의 양(바이트)입니다.
버전 8.0에 추가 되었습니다.

tcmalloc.tcmalloc.total_bytes_held: 현재 캐시에 보유 중인 메모리의 양(바이트 단위)입니다.
버전 8.0에 추가 되었습니다.

tcmalloc.tcmalloc.release_rate: 사용되지 않는 메모리가 운영 체제로 반환되는 속도(초당 바이트 단위)입니다. tcmallocReleaseRate 매개변수는 tcmalloc.tcmalloc.release_rate의 값을 결정합니다.

tcmalloc.tcmalloc.cpuCache

각 CPU 캐시에 대한 데이터를 제공하는 문서입니다.

cpuCache 지표는 기본 상세도 수준에서 제외됩니다. cpuCache 지표를 보려면 tcmalloc 상세도를 최소한 2로 설정해야 합니다.

버전 8.0에 추가 되었습니다.

tcmalloc.tcmalloc.cpuCache.N.overflows: CPU 캐시에서 발생한 오버플로 수입니다. 오버플로는 사용자가 메모리를 해제할 때 캐시가 가득 찬 경우 발생합니다.
버전 8.0에 추가 되었습니다.

tcmalloc.tcmalloc.cpuCache.N.underflows: CPU 캐시에서 발생한 언더플로 수입니다. 언더플로는 사용자가 메모리를 할당할 때 캐시가 비어 있는 경우 발생합니다.
버전 8.0에 추가 되었습니다.

tcmalloc.tcmalloc_derived.total_free_bytes: tcmalloc가 운영 체제로부터 더 많은 메모리를 요청하기 전까지 남은 메모리의 양입니다.
버전 8.0에 추가 되었습니다.

트랜잭션

transactions : {
   retriedCommandsCount : Long("<num>"),
   retriedStatementsCount : Long("<num>"),
   transactionsCollectionWriteCount : Long("<num>"),
   currentActive : Long("<num>"),
   currentInactive : Long("<num>"),
   currentOpen : Long("<num>"),
   totalAborted : Long("<num>"),
   totalCommitted : Long("<num>"),
   totalStarted : Long("<num>"),
   totalPrepared : Long("<num>"),
   totalPreparedThenCommitted : Long("<num>"),
   totalPreparedThenAborted :  Long("<num>"),
   currentPrepared :  Long("<num>"),
   lastCommittedTransaction : <document>
},

transactions : {
   currentOpen : Long("<num>"),
   currentActive : Long("<num>"),
   currentInactive : Long("<num>"),
   totalStarted : Long("<num>"),
   totalCommitted : Long("<num>"),
   totalAborted : Long("<num>"),
   abortCause : {
      <String1> : Long("<num>"),
      <String2> : Long("<num>"),
      ...
   },
   totalContactedParticipants : Long("<num>"),
   totalParticipantsAtCommit : Long("<num>"),
   totalRequestsTargeted : Long("<num>"),
   commitTypes : {
      noShards : {
         initiated : Long("<num>"),
         successful : Long("<num>"),
         successfulDurationMicros : Long("<num>")
      },
      singleShard : {
         initiated : Long("<num>"),
         successful : Long("<num>"),
         successfulDurationMicros : Long("<num>")
      },
      singleWriteShard : {
         initiated : Long("<num>"),
         successful : Long("<num>"),
         successfulDurationMicros : Long("<num>")
      },
      readOnly : {
         initiated : Long("<num>"),
         successful : Long("<num>"),
         successfulDurationMicros : Long("<num>")
      },
      twoPhaseCommit : {
         initiated : Long("<num>"),
         successful : Long("<num>"),
         successfulDurationMicros : Long("<num>")
      },
      recoverWithToken : {
         initiated : Long("<num>"),
         successful : Long("<num>"),
         successfulDurationMicros : Long("<num>")
      }
   }
},

transactions

mongod 에서 실행되는 경우 재시도 가능한 권한 및 트랜잭션에 대한 데이터가 포함된 문서입니다.

mongos에서 실행될 경우 해당 인스턴스에서 실행되는 트랜잭션에 대한 데이터가 포함되는 문서입니다.

transactions.retriedCommandsCount

mongod에서만 사용할 수 있습니다.

해당 재시도 가능 쓰기 명령이 이미 커밋된 후에 수신된 재시도의 총 횟수입니다. 다시 말해서, 이전에 쓰기가 성공했고 해당 트랜잭션 및 세션에 연결된 레코드가 config.transactions 컬렉션에 있는 경우(예: 클라이언트에 대한 초기 쓰기 응답이 손실된 경우)에도 재시도 가능 쓰기를 시도할 수 있습니다.

참고

MongoDB는 커밋된 쓰기를 다시 실행하지 않습니다.

총합은 모든 세션을 합친 값입니다.

총합에는 청크 마이그레이션의 일부로서 내부에서 발생할 수 있는 재시도 가능 쓰기가 포함되지 않습니다.

transactions.retriedStatementsCount

mongod에서만 사용할 수 있습니다.

transactions.retriedCommandsCount에서 재시도한 명령과 관련된 쓰기 문의 총 개수입니다.

참고

MongoDB는 커밋된 쓰기를 다시 실행하지 않습니다.

총합에는 청크 마이그레이션의 일부로서 내부에서 발생할 수 있는 재시도 가능 쓰기가 포함되지 않습니다.

transactions.transactionsCollectionWriteCount

mongod에서만 사용할 수 있습니다.

새로운 재시도 가능 쓰기 성명서가 커밋될 때 트리거되는 config.transactions 컬렉션에 대한 쓰기의 총 건수입니다.

업데이트 및 삭제 명령에서는 단일 문서 작업만 재시도가 가능하므로 쓰기가 성명서 1개당 1회입니다.

삽입 연산에서는 쓰기가 삽입된 문서 배치 1개당 1회 이루어집니다. 단, 실패로 인해 각 문서가 개별적으로 삽입되는 경우는 예외입니다.

총합에는 마이그레이션의 일부로 발생한 서버의 config.transactions 컬렉션에 대한 쓰기가 포함됩니다.

transactions.currentActive

mongod와 mongos 모두에서 사용 가능합니다.

현재 명령을 실행 중인 열린 트랜잭션의 총 개수입니다.

transactions.currentInactive

mongod와 mongos 모두에서 사용 가능합니다.

현재 명령을 실행 중이지 않은 열린 트랜잭션의 총 개수입니다.

transactions.currentOpen

mongod와 mongos 모두에서 사용 가능합니다.

열린 트랜잭션의 총 개수입니다. 트랜잭션은 첫 번째 명령이 해당 트랜잭션의 일부로 실행될 때 열리고, 해당 트랜잭션이 커밋되거나 중단될 때까지 열린 상태로 유지됩니다.

transactions.totalAborted

mongod의 마지막 시작 이후 이 인스턴스에서 중단된 트랜잭션의 총 개수입니다.

mongos의 마지막 시작 이후 이 인스턴스를 통해 중단된 트랜잭션의 총 개수입니다.

transactions.totalCommitted

mongod의 마지막 시작 이후 이 인스턴스에서 커밋된 트랜잭션의 총 개수입니다.

mongos의 마지막 시작 이후 이 인스턴스를 통해 커밋된 트랜잭션의 총 개수입니다.

transactions.totalStarted

mongod의 마지막 시작 이후 이 인스턴스에서 시작된 트랜잭션의 총 개수입니다.

mongos의 마지막 시작 이후 이 인스턴스에서 시작된 트랜잭션의 총 개수입니다.

transactions.abortCause

mongos에서만 사용할 수 있습니다.

transactions.totalAborted을 원인별로 분석합니다. 클라이언트가 abortTransaction을 명시적으로 실행할 경우 그 원인은 abort로 표시됩니다.

예를 들면 다음과 같습니다.

totalAborted : Long("5"),
abortCause : {
   abort : Long("1"),
   DuplicateKey : Long("1"),
   StaleConfig : Long("3"),
   SnapshotTooOld : Long("1")
},

transactions.totalContactedParticipants

mongos에서만 사용할 수 있습니다.

마지막 시작 이후 이 mongos을(를) 통해 시작된 모든 트랜잭션에서 접촉한 샤드의 총 개수입니다.

트랜잭션 프로세스 도중에 접촉한 샤드의 개수에는 커밋의 일부로 포함되지 않았을 수 있는 샤드가 포함될 수 있습니다.

transactions.totalParticipantsAtCommit

mongos에서만 사용할 수 있습니다.

마지막 시작 이후 이 mongos을(를) 통해 시작된 모든 트랜잭션의 커밋에 포함된 샤드의 총 개수입니다.

transactions.totalRequestsTargeted

mongos에서만 사용할 수 있습니다.

트랜잭션의 일환으로 mongos의 대상이 되는 네트워크 요청의 총 건수입니다.

transactions.commitTypes

mongos에서만 사용할 수 있습니다.

커밋을 유형별로 분석합니다. 예시:

noShards : {
   initiated : Long("0"),
   successful : Long("0"),
   successfulDurationMicros : Long("0")
},
singleShard : {
   initiated : Long("5"),
   successful : Long("5"),
   successfulDurationMicros : Long("203118")
},
singleWriteShard : {
   initiated : Long("0"),
   successful : Long("0"),
   successfulDurationMicros : Long("0")
},
readOnly : {
   initiated : Long("0"),
   successful : Long("0"),
   successfulDurationMicros : Long("0")
},
twoPhaseCommit : {
   initiated : Long("1"),
   successful : Long("1"),
   successfulDurationMicros : Long("179616")
},
recoverWithToken : {
   initiated : Long("0"),
   successful : Long("0"),
   successfulDurationMicros : Long("0")
}

커밋의 유형은 다음과 같습니다.

유형	설명
`noShards`	어떤 샤드에도 접촉하지 않은 트랜잭션의 커밋입니다.
`singleShard`	단일 샤드에 영향을 준 트랜잭션의 커밋입니다.
`singleWriteShard`	여러 샤드와 접촉했지만 그 쓰기 연산이 단일 샤드에만 영향을 미친 트랜잭션의 커밋입니다.
`readOnly`	읽기 연산만 포함된 트랜잭션의 커밋입니다.
`twoPhaseCommit`	여러 샤드에 대한 쓰기가 포함된 트랜잭션의 커밋입니다.
`recoverWithToken`	다른 인스턴스에서, 혹은 이 인스턴스가 다시 시작된 후에 트랜잭션 결과를 복구한 커밋입니다.

이 명령은 각 커밋 유형에서 다음 지표를 반환합니다.

지표	설명
`initiated`	이 유형의 커밋이 시작된 총 횟수입니다.
`successful`	이 유형의 커밋이 성공한 총 횟수입니다.
`successfulDurationMicros`	이 유형의 성공한 커밋에 소요된 총 시간(단위: 마이크로초)입니다.

transactions.totalPrepared

mongod에서만 사용할 수 있습니다.

mongod 프로세스의 마지막 시작 이후 이 서버에서 준비된 상태인 트랜잭션의 총 개수입니다.

transactions.totalPreparedThenCommitted

mongod에서만 사용할 수 있습니다.

mongod 프로세스의 마지막 시작 이후 이 서버에서 준비되고 커밋된 트랜잭션의 총 개수입니다.

transactions.totalPreparedThenAborted

mongod에서만 사용할 수 있습니다.

mongod 프로세스의 마지막 시작 이후 이 서버에서 준비되고 중단된 트랜잭션의 총 개수입니다.

transactions.currentPrepared

mongod에서만 사용할 수 있습니다.

이 서버에서 준비된 상태인 트랜잭션의 현재 개수입니다.

transactions.lastCommittedTransaction

mongod에서만 사용할 수 있습니다.

mongod이(가) 프라이머리일 때 커밋된 마지막 트랜잭션의 세부 정보입니다.

lastCommittedTransaction은(는) 세컨더리에서 반환되는 경우, 해당 세컨더리가 프라이머리였을 때 커밋된 마지막 트랜잭션의 세부 정보를 반환합니다.

lastCommittedTransaction : {
   operationCount : Long("1"),
   oplogOperationBytes : Long("211"),
   writeConcern : {
      w : "majority",
      wtimeout : 0
   }
}

지표	설명
`operationCount`	트랜잭션에 포함되는 쓰기 연산의 개수입니다.
`oplogOperationBytes`	트랜잭션에 대한 해당 oplog 항목(1개 또는 여러 개)의 크기입니다. [2]
`writeConcern`	트랜잭션에 사용되는 쓰기 고려입니다.

[2]	MongoDB는 트랜잭션의 모든 쓰기 작업을 캡슐화하기 위해 필요한 만큼의 oplog 항목을 생성합니다. 자세한 내용은 Oplog 크기 제한을 참조하세요.

transportSecurity

transportSecurity : {
   1.0 : Long("<num>"),
   1.1 : Long("<num>"),
   1.2 : Long("<num>"),
   1.3 : Long("<num>"),
   unknown : Long("<num>")
},

transportSecurity.<version>: 이 mongod 또는 mongos 인스턴스에 대해 설정된 TLS <version> 연결의 누적 횟수입니다. 이 값은 재시작 시 초기화됩니다.

watchdog

watchdog : {
   checkGeneration : Long("<num>"),
   monitorGeneration : Long("<num>"),
   monitorPeriod : <num>
}

참고

watchdog 섹션은 Storage Node Watchdog(스토리지 노드 워치독)이 활성화된 경우에만 존재합니다.

watchdog: Storage Node Watchdog(스토리지 노드 워치독)의 상태를 보고하는 문서입니다.

watchdog.checkGeneration: 시작 이후 디렉토리를 검사한 횟수입니다. 디렉토리는 monitoringPeriod마다 여러 번 검사됩니다.

watchdog.monitorGeneration: mongod에서 사용하는 모든 파일 시스템의 상태를 검사한 횟수입니다. 이 값은 monitoringPeriod마다 한 번씩 증가합니다.

watchdog.monitorPeriod: watchdogPeriodSeconds(으)로 설정된 값입니다. 이 값은 상태 검사 사이의 기간입니다.

wiredTiger

wiredTiger 이 정보는 WiredTiger 스토리지 엔진을 사용하는 경우에만 표시됩니다. 일부 통계는 서버에 대해 롤업됩니다.

{
   uri : 'statistics:',
   async : {
      current work queue length : <num>,
      maximum work queue length : <num>,
      number of allocation state races : <num>,
      number of flush calls : <num>,
      number of operation slots viewed for allocation : <num>,
      number of times operation allocation failed : <num>,
      number of times worker found no work : <num>,
      total allocations : <num>,
      total compact calls : <num>,
      total insert calls : <num>,
      total remove calls : <num>,
      total search calls : <num>,
      total update calls : <num>
   },
   block-manager : {
      blocks pre-loaded : <num>,
      blocks read : <num>,
      blocks written : <num>,
      bytes read : <num>,
      bytes written : <num>,
      bytes written for checkpoint : <num>,
      mapped blocks read : <num>,
      mapped bytes read : <num>
   },
   cache : {
      application threads page read from disk to cache count : <num>,
      application threads page read from disk to cache time (usecs) : <num>,
      application threads page write from cache to disk count : <num>,
      application threads page write from cache to disk time (usecs) : <num>,
      bytes belonging to page images in the cache : <num>,
      bytes belonging to the cache overflow table in the cache : <num>,
      bytes currently in the cache : <num>,
      bytes dirty in the cache cumulative : <num>,
      bytes not belonging to page images in the cache : <num>,
      bytes read into cache : <num>,
      bytes written from cache : <num>,
      cache overflow cursor application thread wait time (usecs) : <num>,
      cache overflow cursor internal thread wait time (usecs) : <num>,
      cache overflow score : <num>,
      cache overflow table entries : <num>,
      cache overflow table insert calls : <num>,
      cache overflow table max on-disk size : <num>,
      cache overflow table on-disk size : <num>,
      cache overflow table remove calls : <num>,
      checkpoint blocked page eviction : <num>,
      eviction calls to get a page : <num>,
      eviction calls to get a page found queue empty : <num>,
      eviction calls to get a page found queue empty after locking : <num>,
      eviction currently operating in aggressive mode : <num>,
      eviction empty score : <num>,
      eviction passes of a file : <num>,
      eviction server candidate queue empty when topping up : <num>,
      eviction server candidate queue not empty when topping up : <num>,
      eviction server evicting pages : <num>,
      eviction server slept, because we did not make progress with eviction : <num>,
      eviction server unable to reach eviction goal : <num>,
      eviction server waiting for a leaf page : <num>,
      eviction server waiting for an internal page sleep (usec) : <num>,
      eviction server waiting for an internal page yields : <num>,
      eviction state : <num>,
      eviction walk target pages histogram - 0-9 : <num>,
      eviction walk target pages histogram - 10-31 : <num>,
      eviction walk target pages histogram - 128 and higher : <num>,
      eviction walk target pages histogram - 32-63 : <num>,
      eviction walk target pages histogram - 64-128 : <num>,
      eviction walks abandoned : <num>,
      eviction walks gave up because they restarted their walk twice : <num>,
      eviction walks gave up because they saw too many pages and found no candidates : <num>,
      eviction walks gave up because they saw too many pages and found too few candidates : <num>,
      eviction walks reached end of tree : <num>,
      eviction walks started from root of tree : <num>,
      eviction walks started from saved location in tree : <num>,
      eviction worker thread active : <num>,
      eviction worker thread created : <num>,
      eviction worker thread evicting pages : <num>,
      eviction worker thread removed : <num>,
      eviction worker thread stable number : <num>,
      files with active eviction walks : <num>,
      files with new eviction walks started : <num>,
      force re-tuning of eviction workers once in a while : <num>,
      forced eviction - pages evicted that were clean count : <num>,
      forced eviction - pages evicted that were clean time (usecs) : <num>,
      forced eviction - pages evicted that were dirty count : <num>,
      forced eviction - pages evicted that were dirty time (usecs) : <num>,
      forced eviction - pages selected because of too many deleted items count : <num>,
      forced eviction - pages selected count : <num>,
      forced eviction - pages selected unable to be evicted count : <num>,
      forced eviction - pages selected unable to be evicted time : <num>,
      hazard pointer blocked page eviction : <num>,
      hazard pointer check calls : <num>,
      hazard pointer check entries walked : <num>,
      hazard pointer maximum array length : <num>,
      in-memory page passed criteria to be split : <num>,
      in-memory page splits : <num>,
      internal pages evicted : <num>,
      internal pages split during eviction : <num>,
      leaf pages split during eviction : <num>,
      maximum bytes configured : <num>,
      maximum page size at eviction : <num>,
      modified pages evicted : <num>,
      modified pages evicted by application threads : <num>,
      operations timed out waiting for space in cache : <num>,
      overflow pages read into cache : <num>,
      page split during eviction deepened the tree : <num>,
      page written requiring cache overflow records : <num>,
      pages currently held in the cache : <num>,
      pages evicted by application threads : <num>,
      pages queued for eviction : <num>,
      pages queued for eviction post lru sorting : <num>,
      pages queued for urgent eviction : <num>,
      pages queued for urgent eviction during walk : <num>,
      pages read into cache : <num>,
      pages read into cache after truncate : <num>,
      pages read into cache after truncate in prepare state : <num>,
      pages read into cache requiring cache overflow entries : <num>,
      pages read into cache requiring cache overflow for checkpoint : <num>,
      pages read into cache skipping older cache overflow entries : <num>,
      pages read into cache with skipped cache overflow entries needed later : <num>,
      pages read into cache with skipped cache overflow entries needed later by checkpoint : <num>,
      pages requested from the cache : <num>,
      pages seen by eviction walk : <num>,
      pages selected for eviction unable to be evicted : <num>,
      pages walked for eviction : <num>,
      pages written from cache : <num>,
      pages written requiring in-memory restoration : <num>,
      percentage overhead : <num>,
      tracked bytes belonging to internal pages in the cache : <num>,
      tracked bytes belonging to leaf pages in the cache : <num>,
      tracked dirty bytes in the cache : <num>,
      tracked dirty pages in the cache : <num>,
      unmodified pages evicted : <num>
   },
   capacity : {
      background fsync file handles considered : <num>,
      background fsync file handles synced : <num>,
      background fsync time (msecs) : <num>,
      bytes read : <num>,
      bytes written for checkpoint : <num>,
      bytes written for eviction : <num>,
      bytes written for log : <num>,
      bytes written total : <num>,
      threshold to call fsync : <num>,
      time waiting due to total capacity (usecs) : <num>,
      time waiting during checkpoint (usecs) : <num>,
      time waiting during eviction (usecs) : <num>,
      time waiting during logging (usecs) : <num>,
      time waiting during read (usecs) : <num>
   },
   connection : {
      auto adjusting condition resets : <num>,
      auto adjusting condition wait calls : <num>,
      detected system time went backwards : <num>,
      files currently open : <num>,
      memory allocations : <num>,
      memory frees : <num>,
      memory re-allocations : <num>,
      pthread mutex condition wait calls : <num>,
      pthread mutex shared lock read-lock calls : <num>,
      pthread mutex shared lock write-lock calls : <num>,
      total fsync I/Os : <num>,
      total read I/Os : <num>,
      total write I/Os : <num>
   },
   cursor : {
      cached cursor count : <num>,
      cursor bulk loaded cursor insert calls : <num>,
      cursor close calls that result in cache : <num>,
      cursor create calls : <num>,
      cursor insert calls : <num>,
      cursor insert key and value bytes : <num>,
      cursor modify calls : <num>,
      cursor modify key and value bytes affected : <num>,
      cursor modify value bytes modified : <num>,
      cursor next calls : <num>,
      cursor operation restarted : <num>,
      cursor prev calls : <num>,
      cursor remove calls : <num>,
      cursor remove key bytes removed : <num>,
      cursor reserve calls : <num>,
      cursor reset calls : <num>,
      cursor search calls : <num>,
      cursor search near calls : <num>,
      cursor sweep buckets : <num>,
      cursor sweep cursors closed : <num>,
      cursor sweep cursors examined : <num>,
      cursor sweeps : <num>,
      cursor truncate calls : <num>,
      cursor update calls : <num>,
      cursor update key and value bytes : <num>,
      cursor update value size change : <num>,
      cursors reused from cache : <num>,
      open cursor count : <num>
   },
   data-handle : {
      connection data handle size : <num>,
      connection data handles currently active : <num>,
      connection sweep candidate became referenced : <num>,
      connection sweep dhandles closed : <num>,
      connection sweep dhandles removed from hash list : <num>,
      connection sweep time-of-death sets : <num>,
      connection sweeps : <num>,
      session dhandles swept : <num>,
      session sweep attempts : <num>
   },
   lock : {
      checkpoint lock acquisitions : <num>,
      checkpoint lock application thread wait time (usecs) : <num>,
      checkpoint lock internal thread wait time (usecs) : <num>,
      dhandle lock application thread time waiting (usecs) : <num>,
      dhandle lock internal thread time waiting (usecs) : <num>,
      dhandle read lock acquisitions : <num>,
      dhandle write lock acquisitions : <num>,
      durable timestamp queue lock application thread time waiting (usecs) : <num>,
      durable timestamp queue lock internal thread time waiting (usecs) : <num>,
      durable timestamp queue read lock acquisitions : <num>,
      durable timestamp queue write lock acquisitions : <num>,
      metadata lock acquisitions : <num>,
      metadata lock application thread wait time (usecs) : <num>,
      metadata lock internal thread wait time (usecs) : <num>,
      read timestamp queue lock application thread time waiting (usecs) : <num>,
      read timestamp queue lock internal thread time waiting (usecs) : <num>,
      read timestamp queue read lock acquisitions : <num>,
      read timestamp queue write lock acquisitions : <num>,
      schema lock acquisitions : <num>,
      schema lock application thread wait time (usecs) : <num>,
      schema lock internal thread wait time (usecs) : <num>,
      table lock application thread time waiting for the table lock (usecs) : <num>,
      table lock internal thread time waiting for the table lock (usecs) : <num>,
      table read lock acquisitions : <num>,
      table write lock acquisitions : <num>,
      txn global lock application thread time waiting (usecs) : <num>,
      txn global lock internal thread time waiting (usecs) : <num>,
      txn global read lock acquisitions : <num>,
      txn global write lock acquisitions : <num>
   },
   log : {
      busy returns attempting to switch slots : <num>,
      force archive time sleeping (usecs) : <num>,
      log bytes of payload data : <num>,
      log bytes written : <num>,
      log files manually zero-filled : <num>,
      log flush operations : <num>,
      log force write operations : <num>,
      log force write operations skipped : <num>,
      log records compressed : <num>,
      log records not compressed : <num>,
      log records too small to compress : <num>,
      log release advances write LSN : <num>,
      log scan operations : <num>,
      log scan records requiring two reads : <num>,
      log server thread advances write LSN : <num>,
      log server thread write LSN walk skipped : <num>,
      log sync operations : <num>,
      log sync time duration (usecs) : <num>,
      log sync_dir operations : <num>,
      log sync_dir time duration (usecs) : <num>,
      log write operations : <num>,
      logging bytes consolidated : <num>,
      maximum log file size : <num>,
      number of pre-allocated log files to create : <num>,
      pre-allocated log files not ready and missed : <num>,
      pre-allocated log files prepared : <num>,
      pre-allocated log files used : <num>,
      records processed by log scan : <num>,
      slot close lost race : <num>,
      slot close unbuffered waits : <num>,
      slot closures : <num>,
      slot join atomic update races : <num>,
      slot join calls atomic updates raced : <num>,
      slot join calls did not yield : <num>,
      slot join calls found active slot closed : <num>,
      slot join calls slept : <num>,
      slot join calls yielded : <num>,
      slot join found active slot closed : <num>,
      slot joins yield time (usecs) : <num>,
      slot transitions unable to find free slot : <num>,
      slot unbuffered writes : <num>,
      total in-memory size of compressed records : <num>,
      total log buffer size : <num>,
      total size of compressed records : <num>,
      written slots coalesced : <num>,
      yields waiting for previous log file close : <num>
   },
   perf : {
      file system read latency histogram (bucket 1) - 10-49ms : <num>,
      file system read latency histogram (bucket 2) - 50-99ms : <num>,
      file system read latency histogram (bucket 3) - 100-249ms : <num>,
      file system read latency histogram (bucket 4) - 250-499ms : <num>,
      file system read latency histogram (bucket 5) - 500-999ms : <num>,
      file system read latency histogram (bucket 6) - 1000ms+ : <num>,
      file system write latency histogram (bucket 1) - 10-49ms : <num>,
      file system write latency histogram (bucket 2) - 50-99ms : <num>,
      file system write latency histogram (bucket 3) - 100-249ms : <num>,
      file system write latency histogram (bucket 4) - 250-499ms : <num>,
      file system write latency histogram (bucket 5) - 500-999ms : <num>,
      file system write latency histogram (bucket 6) - 1000ms+ : <num>,
      operation read latency histogram (bucket 1) - 100-249us : <num>,
      operation read latency histogram (bucket 2) - 250-499us : <num>,
      operation read latency histogram (bucket 3) - 500-999us : <num>,
      operation read latency histogram (bucket 4) - 1000-9999us : <num>,
      operation read latency histogram (bucket 5) - 10000us+ : <num>,
      operation write latency histogram (bucket 1) - 100-249us : <num>,
      operation write latency histogram (bucket 2) - 250-499us : <num>,
      operation write latency histogram (bucket 3) - 500-999us : <num>,
      operation write latency histogram (bucket 4) - 1000-9999us : <num>,
      operation write latency histogram (bucket 5) - 10000us+ : <num>
   },
   reconciliation : {
      fast-path pages deleted : <num>,
      page reconciliation calls : <num>,
      page reconciliation calls for eviction : <num>,
      pages deleted : <num>,
      split bytes currently awaiting free : <num>,
      split objects currently awaiting free : <num>
   },
   session : {
      open session count : <num>,
      session query timestamp calls : <num>,
      table alter failed calls : <num>,
      table alter successful calls : <num>,
      table alter unchanged and skipped : <num>,
      table compact failed calls : <num>,
      table compact successful calls : <num>,
      table create failed calls : <num>,
      table create successful calls : <num>,
      table drop failed calls : <num>,
      table drop successful calls : <num>,
      table import failed calls : <num>,
      table import successful calls : <num>,
      table rebalance failed calls : <num>,
      table rebalance successful calls : <num>,
      table rename failed calls : <num>,
      table rename successful calls : <num>,
      table salvage failed calls : <num>,
      table salvage successful calls : <num>,
      table truncate failed calls : <num>,
      table truncate successful calls : <num>,
      table verify failed calls : <num>,
      table verify successful calls : <num>
   },
   thread-state : {
      active filesystem fsync calls : <num>,
      active filesystem read calls : <num>,
      active filesystem write calls : <num>
   },
   thread-yield : {
      application thread time evicting (usecs) : <num>,
      application thread time waiting for cache (usecs) : <num>,
      connection close blocked waiting for transaction state stabilization : <num>,
      connection close yielded for lsm manager shutdown : <num>,
      data handle lock yielded : <num>,
      get reference for page index and slot time sleeping (usecs) : <num>,
      log server sync yielded for log write : <num>,
      page access yielded due to prepare state change : <num>,
      page acquire busy blocked : <num>,
      page acquire eviction blocked : <num>,
      page acquire locked blocked : <num>,
      page acquire read blocked : <num>,
      page acquire time sleeping (usecs) : <num>,
      page delete rollback time sleeping for state change (usecs) : <num>,
      page reconciliation yielded due to child modification : <num>
   },
   transaction : {
      Number of prepared updates : <num>,
      Number of prepared updates added to cache overflow : <num>,
      Number of prepared updates resolved : <num>,
      durable timestamp queue entries walked : <num>,
      durable timestamp queue insert to empty : <num>,
      durable timestamp queue inserts to head : <num>,
      durable timestamp queue inserts total : <num>,
      durable timestamp queue length : <num>,
      number of named snapshots created : <num>,
      number of named snapshots dropped : <num>,
      prepared transactions : <num>,
      prepared transactions committed : <num>,
      prepared transactions currently active : <num>,
      prepared transactions rolled back : <num>,
      query timestamp calls : <num>,
      read timestamp queue entries walked : <num>,
      read timestamp queue insert to empty : <num>,
      read timestamp queue inserts to head : <num>,
      read timestamp queue inserts total : <num>,
      read timestamp queue length : <num>,
      rollback to stable calls : <num>,
      rollback to stable updates aborted : <num>,
      rollback to stable updates removed from cache overflow : <num>,
      set timestamp calls : <num>,
      set timestamp durable calls : <num>,
      set timestamp durable updates : <num>,
      set timestamp oldest calls : <num>,
      set timestamp oldest updates : <num>,
      set timestamp stable calls : <num>,
      set timestamp stable updates : <num>,
      transaction begins : <num>,
      transaction checkpoint currently running : <num>,
      transaction checkpoint generation : <num>,
      transaction checkpoint max time (msecs) : <num>,
      transaction checkpoint min time (msecs) : <num>,
      transaction checkpoint most recent time (msecs) : <num>,
      transaction checkpoint scrub dirty target : <num>,
      transaction checkpoint scrub time (msecs) : <num>,
      transaction checkpoint total time (msecs) : <num>,
      transaction checkpoints : <num>,
      transaction checkpoints skipped because database was clean : <num>,
      transaction failures due to cache overflow : <num>,
      transaction fsync calls for checkpoint after allocating the transaction ID : <num>,
      transaction fsync duration for checkpoint after allocating the transaction ID (usecs) : <num>,
      transaction range of IDs currently pinned : <num>,
      transaction range of IDs currently pinned by a checkpoint : <num>,
      transaction range of IDs currently pinned by named snapshots : <num>,
      transaction range of timestamps currently pinned : <num>,
      transaction range of timestamps pinned by a checkpoint : <num>,
      transaction range of timestamps pinned by the oldest active read timestamp : <num>,
      transaction range of timestamps pinned by the oldest timestamp : <num>,
      transaction read timestamp of the oldest active reader : <num>,
      transaction sync calls : <num>,
      transactions committed : <num>,
      transactions rolled back : <num>,
      update conflicts : <num>
   },
   concurrentTransactions : {
      write : {
         out : <num>,
         available : <num>,
         totalTickets : <num>
      },
      read : {
         out : <num>,
         available : <num>,
         totalTickets : <num>
      },
      monitor : {
         timesDecreased: <num>,
         timesIncreased: <num>,
         totalAmountDecreased: <num>,
         totalAmountIncreased: <num>
      }
   },
   snapshot-window-settings : {
      total number of SnapshotTooOld errors : <num>,
      max target available snapshots window size in seconds : <num>,
      target available snapshots window size in seconds : <num>,
      current available snapshots window size in seconds : <num>,
      latest majority snapshot timestamp available : <string>,
      oldest majority snapshot timestamp available : <string>
   }
}

참고

다음 항목은 전체 목록이 아닙니다.

wiredTiger.uri: 문자열입니다. MongoDB에서 내부적으로 사용할 수 있습니다.

wiredTiger.async: 비동기 연산 API와 관련 있는 통계를 반환하는 문서입니다. 이 문서는 MongoDB에서는 사용되지 않습니다.

wiredTiger.block-manager: 블록 관리자 연산에 대한 통계를 반환하는 문서입니다.

wiredTiger.cache

캐시에 대한 통계와 캐시에서의 페이지 제거를 반환하는 문서입니다.

다음 항목은 주요 wiredTiger.cache 통계 중 일부를 설명합니다.

wiredTiger.cache.maximum bytes configured: 최대 캐시 크기입니다.

wiredTiger.cache.bytes currently in the cache: 현재 캐시에 있는 데이터의 크기(단위: 바이트)입니다. 이 값은 maximum bytes configured 값보다 크지 않아야 합니다.

wiredTiger.cache.unmodified pages evicted: 페이지 제거에 대한 주요 통계입니다.

wiredTiger.cache.tracked dirty bytes in the cache: 캐시에 있는 더티 데이터의 크기(단위: 바이트)입니다. 이 값은 bytes currently in the cache 값보다 작아야 합니다.

wiredTiger.cache.pages read into cache: 캐시로 읽은 페이지의 수입니다. wiredTiger.cache.pages read into cache을(를) wiredTiger.cache.pages written from cache와(과) 함께 사용하면 I/O 활동의 개요를 확인할 수 있습니다.

wiredTiger.cache.pages written from cache: 캐시에서 기록된 페이지의 수입니다. wiredTiger.cache.pages written from cache을(를) wiredTiger.cache.pages read into cache와(과) 함께 사용하면 I/O 활동의 개요를 확인할 수 있습니다.

와이어드타이거 내부 캐시 크기를 조정하려면 storage.wiredTiger.engineConfig.cacheSizeGB 및 --wiredTigerCacheSizeGB를 참조하세요. WiredTiger 내부 캐시 크기를 기본값 이상으로 늘리지 마세요.

wiredTiger.connection: WiredTiger 연결과 관련 있는 통계를 반환하는 문서입니다.

wiredTiger.cursor: WiredTiger 커서에 대한 통계를 반환하는 문서입니다.

wiredTiger.data-handle: 데이터 핸들 및 스윕에 대한 통계를 반환하는 문서입니다.

wiredTiger.log: WiredTiger의 미리 쓰기 로그(예: 저널)에 대한 통계를 반환하는 문서입니다.
팁
다음도 참조하세요.
저널링과 와이어드타이거 스토리지 엔진

wiredTiger.reconciliation: 조정 프로세스에 대한 통계를 반환하는 문서입니다.

wiredTiger.session: 세션의 열린 커서 수와 열린 세션 수를 반환하는 문서입니다.

wiredTiger.thread-yield: 페이지 획득 도중의 수익률에 대한 통계를 반환하는 문서입니다.

wiredTiger.transaction

트랜잭션 체크포인트 및 연산에 대한 통계를 반환하는 문서입니다.

wiredTiger.transaction.transaction checkpoint most recent time (msecs): 가장 최근의 체크포인트를 생성하는 데 소요된 시간의 양(단위: 밀리초)입니다. 대신 쓰기 로드에서 이 값이 증가하면 I/O 하위 시스템이 포화되었다는 의미일 수 있습니다.

돌아가기

프로필

shardConnPoolStats

정의

호환성

참고

구문

팁

다음도 참조하세요.

행동

초기화

포함 mirroredReads

출력

참고

어설션

bucketCatalog

catalogStats

changeStreamPreImages

연결

참고

참고

defaultRWConcern

electionMetrics

팁

다음도 참조하세요.

팁

다음도 참조하세요.

extra_info

flowControl

globalLock

hedgingMetrics

중요

indexBuilds

indexBulkBuilder

indexStats

인스턴스 정보

잠금

logicalSessionRecordCache

팁

다음도 참조하세요.

팁

다음도 참조하세요.

mem

지표

참고

팁

다음도 참조하세요.

참고

참고

mirroredReads

팁

다음도 참조하세요.

팁

다음도 참조하세요.

팁

다음도 참조하세요.

네트워크

opLatencies

opWorkingTime

opReadConcernCounters

경고

제거됨

opWriteConcernCounters

참고

참고

참고

참고

opcounters

참고

opcountersRepl

oplogTruncation

planCache

queryStats

queryAnalyzers

queues

중요

대기열 정보

querySettings

readConcernCounters

readPreferenceCounters

repl

보안

참고

포함 `mirroredReads`