protected override MemberInfo GetUpdatedMe(MemberInfo me)
 {
     return(me.Updated(isAlive: true,
                       state: CurrentRole,
                       lastCommitPosition: _getLastCommitPosition(),
                       writerCheckpoint: _writerCheckpoint.ReadNonFlushed(),
                       chaserCheckpoint: _chaserCheckpoint.ReadNonFlushed(),
                       epoch: _epochManager.GetLastEpoch(),
                       nodePriority: _nodePriority,
                       utcNow: _timeProvider.UtcNow));
 }
        public IDictionary <string, object> GetSystemStats()
        {
            var stats = new Dictionary <string, object>();

            GetPerfCounterInformation(stats, 0);
            var process = Process.GetCurrentProcess();

            var diskIo = DiskIo.GetDiskIo(process.Id, _log);

            if (diskIo != null)
            {
                stats["proc-diskIo-readBytes"]    = diskIo.ReadBytes;
                stats["proc-diskIo-writtenBytes"] = diskIo.WrittenBytes;
                stats["proc-diskIo-readOps"]      = diskIo.ReadOps;
                stats["proc-diskIo-writeOps"]     = diskIo.WriteOps;
            }

            var tcp = TcpConnectionMonitor.Default.GetTcpStats();

            stats["proc-tcp-connections"]               = tcp.Connections;
            stats["proc-tcp-receivingSpeed"]            = tcp.ReceivingSpeed;
            stats["proc-tcp-sendingSpeed"]              = tcp.SendingSpeed;
            stats["proc-tcp-inSend"]                    = tcp.InSend;
            stats["proc-tcp-measureTime"]               = tcp.MeasureTime;
            stats["proc-tcp-pendingReceived"]           = tcp.PendingReceived;
            stats["proc-tcp-pendingSend"]               = tcp.PendingSend;
            stats["proc-tcp-receivedBytesSinceLastRun"] = tcp.ReceivedBytesSinceLastRun;
            stats["proc-tcp-receivedBytesTotal"]        = tcp.ReceivedBytesTotal;
            stats["proc-tcp-sentBytesSinceLastRun"]     = tcp.SentBytesSinceLastRun;
            stats["proc-tcp-sentBytesTotal"]            = tcp.SentBytesTotal;

            stats["es-checksum"]           = _writerCheckpoint.Read();
            stats["es-checksumNonFlushed"] = _writerCheckpoint.ReadNonFlushed();

            var drive = EsDriveInfo.FromDirectory(_dbPath, _log);

            if (drive != null)
            {
                Func <string, string, string> driveStat = (diskName, stat) =>
                                                          string.Format("sys-drive-{0}-{1}", diskName.Replace("\\", "").Replace(":", ""), stat);
                stats[driveStat(drive.DiskName, "availableBytes")] = drive.AvailableBytes;
                stats[driveStat(drive.DiskName, "totalBytes")]     = drive.TotalBytes;
                stats[driveStat(drive.DiskName, "usage")]          = drive.Usage;
                stats[driveStat(drive.DiskName, "usedBytes")]      = drive.UsedBytes;
            }

            Func <string, string, string> queueStat = (queueName, stat) =>
                                                      string.Format("es-queue-{0}-{1}", queueName, stat);
            var queues = QueueMonitor.Default.GetStats();

            foreach (var queue in queues)
            {
                stats[queueStat(queue.Name, "queueName")]         = queue.Name;
                stats[queueStat(queue.Name, "groupName")]         = queue.GroupName ?? string.Empty;
                stats[queueStat(queue.Name, "avgItemsPerSecond")] = queue.AvgItemsPerSecond;
                stats[queueStat(queue.Name, "avgProcessingTime")] = queue.AvgProcessingTime;
                stats[queueStat(queue.Name, "currentIdleTime")]   = queue.CurrentIdleTime.HasValue
                                        ? queue.CurrentIdleTime.Value.ToString("G", CultureInfo.InvariantCulture)
                                        : null;
                stats[queueStat(queue.Name, "currentItemProcessingTime")] = queue.CurrentItemProcessingTime.HasValue
                                        ? queue.CurrentItemProcessingTime.Value.ToString("G", CultureInfo.InvariantCulture)
                                        : null;
                stats[queueStat(queue.Name, "idleTimePercent")]      = queue.IdleTimePercent;
                stats[queueStat(queue.Name, "length")]               = queue.Length;
                stats[queueStat(queue.Name, "lengthCurrentTryPeak")] = queue.LengthCurrentTryPeak;
                stats[queueStat(queue.Name, "lengthLifetimePeak")]   = queue.LengthLifetimePeak;
                stats[queueStat(queue.Name, "totalItemsProcessed")]  = queue.TotalItemsProcessed;
                stats[queueStat(queue.Name, "inProgressMessage")]    = queue.InProgressMessageType != null
                                        ? queue.InProgressMessageType.Name
                                        : "<none>";
                stats[queueStat(queue.Name, "lastProcessedMessage")] = queue.LastProcessedMessageType != null
                                        ? queue.LastProcessedMessageType.Name
                                        : "<none>";
            }

            return(stats);
        }
Exemple #3
0
 private bool AreCheckpointsDifferent()
 {
     return(_writerCheckpoint != null && _chaserCheckpoint != null && _writerCheckpoint.ReadNonFlushed() != _chaserCheckpoint.Read());
 }