@jdlinker/system/src/views/jlap/monitor/server/server.api.ts

jdLinker 系统模块

import { defHttp } from '@jdlinker/func';

enum Api {
  cpuCount = '/actuator/metrics/system.cpu.count',
  cpuUsage = '/actuator/metrics/system.cpu.usage',
  processStartTime = '/actuator/metrics/process.start.time',
  processUptime = '/actuator/metrics/process.uptime',
  processCpuUsage = '/actuator/metrics/process.cpu.usage',

  jvmMemoryMax = '/actuator/metrics/jvm.memory.max',
  jvmMemoryCommitted = '/actuator/metrics/jvm.memory.committed',
  jvmMemoryUsed = '/actuator/metrics/jvm.memory.used',
  jvmBufferMemoryUsed = '/actuator/metrics/jvm.buffer.memory.used',
  jvmBufferCount = '/actuator/metrics/jvm.buffer.count',
  jvmThreadsDaemon = '/actuator/metrics/jvm.threads.daemon',
  jvmThreadsLive = '/actuator/metrics/jvm.threads.live',
  jvmThreadsPeak = '/actuator/metrics/jvm.threads.peak',
  jvmClassesLoaded = '/actuator/metrics/jvm.classes.loaded',
  jvmClassesUnloaded = '/actuator/metrics/jvm.classes.unloaded',
  jvmGcMemoryAllocated = '/actuator/metrics/jvm.gc.memory.allocated',
  jvmGcMemoryPromoted = '/actuator/metrics/jvm.gc.memory.promoted',
  jvmGcMaxDataSize = '/actuator/metrics/jvm.gc.max.data.size',
  jvmGcLiveDataSize = '/actuator/metrics/jvm.gc.live.data.size',
  jvmGcPause = '/actuator/metrics/jvm.gc.pause',

  tomcatSessionsCreated = '/actuator/metrics/undertow.sessions.created',
  tomcatSessionsExpired = '/actuator/metrics/undertow.sessions.expired',
  tomcatSessionsActiveCurrent = '/actuator/metrics/undertow.sessions.active.current',
  tomcatSessionsActiveMax = '/actuator/metrics/undertow.sessions.active.max',
  tomcatSessionsRejected = '/actuator/metrics/undertow.sessions.rejected'
}

/**
 * 查询cpu数量
 */
export const getCpuCount = () => {
  return defHttp.get({ url: Api.cpuCount }, { isTransformResponse: false });
};

/**
 * 查询系统 CPU 使用率
 */
export const getCpuUsage = () => {
  return defHttp.get({ url: Api.cpuUsage }, { isTransformResponse: false });
};

/**
 * 查询应用启动时间点
 */
export const getProcessStartTime = () => {
  return defHttp.get({ url: Api.processStartTime }, { isTransformResponse: false });
};

/**
 * 查询应用已运行时间
 */
export const getProcessUptime = () => {
  return defHttp.get({ url: Api.processUptime }, { isTransformResponse: false });
};

/**
 * 查询当前应用 CPU 使用率
 */
export const getProcessCpuUsage = () => {
  return defHttp.get({ url: Api.processCpuUsage }, { isTransformResponse: false });
};

/**
 * 查询JVM 最大内存
 */
export const getJvmMemoryMax = () => {
  return defHttp.get({ url: Api.jvmMemoryMax }, { isTransformResponse: false });
};

/**
 * JVM 可用内存
 */
export const getJvmMemoryCommitted = () => {
  return defHttp.get({ url: Api.jvmMemoryCommitted }, { isTransformResponse: false });
};

/**
 * JVM 已用内存
 */
export const getJvmMemoryUsed = () => {
  return defHttp.get({ url: Api.jvmMemoryUsed }, { isTransformResponse: false });
};

/**
 * JVM 缓冲区已用内存
 */
export const getJvmBufferMemoryUsed = () => {
  return defHttp.get({ url: Api.jvmBufferMemoryUsed }, { isTransformResponse: false });
};

/**
 *JVM 当前缓冲区数量
 */
export const getJvmBufferCount = () => {
  return defHttp.get({ url: Api.jvmBufferCount }, { isTransformResponse: false });
};

/**
 **JVM 守护线程数量
 */
export const getJvmThreadsDaemon = () => {
  return defHttp.get({ url: Api.jvmThreadsDaemon }, { isTransformResponse: false });
};

/**
 *JVM 当前活跃线程数量
 */
export const getJvmThreadsLive = () => {
  return defHttp.get({ url: Api.jvmThreadsLive }, { isTransformResponse: false });
};

/**
 *JVM 峰值线程数量
 */
export const getJvmThreadsPeak = () => {
  return defHttp.get({ url: Api.jvmThreadsPeak }, { isTransformResponse: false });
};

/**
 *JVM 已加载 Class 数量
 */
export const getJvmClassesLoaded = () => {
  return defHttp.get({ url: Api.jvmClassesLoaded }, { isTransformResponse: false });
};

/**
 *JVM 未加载 Class 数量
 */
export const getJvmClassesUnloaded = () => {
  return defHttp.get({ url: Api.jvmClassesUnloaded }, { isTransformResponse: false });
};

/**
 **GC 时, 年轻代分配的内存空间
 */
export const getJvmGcMemoryAllocated = () => {
  return defHttp.get({ url: Api.jvmGcMemoryAllocated }, { isTransformResponse: false });
};

/**
 *GC 时, 老年代分配的内存空间
 */
export const getJvmGcMemoryPromoted = () => {
  return defHttp.get({ url: Api.jvmGcMemoryPromoted }, { isTransformResponse: false });
};

/**
 *GC 时, 老年代的最大内存空间
 */
export const getJvmGcMaxDataSize = () => {
  return defHttp.get({ url: Api.jvmGcMaxDataSize }, { isTransformResponse: false });
};

/**
 *FullGC 时, 老年代的内存空间
 */
export const getJvmGcLiveDataSize = () => {
  return defHttp.get({ url: Api.jvmGcLiveDataSize }, { isTransformResponse: false });
};

/**
 *系统启动以来GC 次数
 */
export const getJvmGcPause = () => {
  return defHttp.get({ url: Api.jvmGcPause }, { isTransformResponse: false });
};

/**
 *tomcat 已创建 session 数
 */
export const getTomcatSessionsCreated = () => {
  return defHttp.get({ url: Api.tomcatSessionsCreated }, { isTransformResponse: false });
};

/**
 *tomcat 已过期 session 数
 */
export const getTomcatSessionsExpired = () => {
  return defHttp.get({ url: Api.tomcatSessionsExpired }, { isTransformResponse: false });
};

/**
 *tomcat 当前活跃 session 数
 */
export const getTomcatSessionsActiveCurrent = () => {
  return defHttp.get({ url: Api.tomcatSessionsActiveCurrent }, { isTransformResponse: false });
};

/**
 *tomcat 活跃 session 数峰值
 */
export const getTomcatSessionsActiveMax = () => {
  return defHttp.get({ url: Api.tomcatSessionsActiveMax }, { isTransformResponse: false });
};

/**
 *超过session 最大配置后，拒绝的 session 个数
 */
export const getTomcatSessionsRejected = () => {
  return defHttp.get({ url: Api.tomcatSessionsRejected }, { isTransformResponse: false });
};

export const getMoreInfo = (infoType) => {
  if (infoType == '1') {
    return {};
  }
  if (infoType == '2') {
    return { 'jvm.gc.pause': ['.count', '.totalTime'] };
  }
  if (infoType == '3') {
    return {
      'tomcat.global.request': ['.count', '.totalTime'],
      'tomcat.servlet.request': ['.count', '.totalTime']
    };
  }
};

export const getTextInfo = (infoType) => {
  if (infoType == '1') {
    return {
      'system.cpu.count': { color: 'green', text: 'CPU 数量', unit: '核' },
      'system.cpu.usage': {
        color: 'green',
        text: '系统 CPU 使用率',
        unit: '%',
        valueType: 'Number'
      },
      'process.start.time': {
        color: 'purple',
        text: '应用启动时间点',
        unit: '',
        valueType: 'Date'
      },
      'process.uptime': { color: 'purple', text: '应用已运行时间', unit: '秒' },
      'process.cpu.usage': {
        color: 'purple',
        text: '当前应用 CPU 使用率',
        unit: '%',
        valueType: 'Number'
      }
    };
  }
  if (infoType == '2') {
    return {
      'jvm.memory.max': {
        color: 'purple',
        text: 'JVM 最大内存',
        unit: 'MB',
        valueType: 'RAM'
      },
      'jvm.memory.committed': {
        color: 'purple',
        text: 'JVM 可用内存',
        unit: 'MB',
        valueType: 'RAM'
      },
      'jvm.memory.used': {
        color: 'purple',
        text: 'JVM 已用内存',
        unit: 'MB',
        valueType: 'RAM'
      },
      'jvm.buffer.memory.used': {
        color: 'cyan',
        text: 'JVM 缓冲区已用内存',
        unit: 'MB',
        valueType: 'RAM'
      },
      'jvm.buffer.count': { color: 'cyan', text: '当前缓冲区数量', unit: '个' },
      'jvm.threads.daemon': {
        color: 'green',
        text: 'JVM 守护线程数量',
        unit: '个'
      },
      'jvm.threads.live': {
        color: 'green',
        text: 'JVM 当前活跃线程数量',
        unit: '个'
      },
      'jvm.threads.peak': {
        color: 'green',
        text: 'JVM 峰值线程数量',
        unit: '个'
      },
      'jvm.classes.loaded': {
        color: 'orange',
        text: 'JVM 已加载 Class 数量',
        unit: '个'
      },
      'jvm.classes.unloaded': {
        color: 'orange',
        text: 'JVM 未加载 Class 数量',
        unit: '个'
      },
      'jvm.gc.memory.allocated': {
        color: 'pink',
        text: 'GC 时, 年轻代分配的内存空间',
        unit: 'MB',
        valueType: 'RAM'
      },
      'jvm.gc.memory.promoted': {
        color: 'pink',
        text: 'GC 时, 老年代分配的内存空间',
        unit: 'MB',
        valueType: 'RAM'
      },
      'jvm.gc.max.data.size': {
        color: 'pink',
        text: 'GC 时, 老年代的最大内存空间',
        unit: 'MB',
        valueType: 'RAM'
      },
      'jvm.gc.live.data.size': {
        color: 'pink',
        text: 'FullGC 时, 老年代的内存空间',
        unit: 'MB',
        valueType: 'RAM'
      },
      'jvm.gc.pause.count': {
        color: 'blue',
        text: '系统启动以来GC 次数',
        unit: '次'
      },
      'jvm.gc.pause.totalTime': {
        color: 'blue',
        text: '系统启动以来GC 总耗时',
        unit: '秒'
      }
    };
  }
  if (infoType == '3') {
    return {
      'undertow.sessions.created': {
        color: 'green',
        text: 'undertow 已创建 session 数',
        unit: '个'
      },
      'undertow.sessions.expired': {
        color: 'green',
        text: 'undertow 已过期 session 数',
        unit: '个'
      },
      'undertow.sessions.active.current': {
        color: 'green',
        text: 'undertow 当前活跃 session 数',
        unit: '个'
      },
      'undertow.sessions.active.max': {
        color: 'green',
        text: 'undertow 活跃 session 数峰值',
        unit: '个'
      },
      'undertow.sessions.rejected': {
        color: 'green',
        text: '超过session 最大配置后，拒绝的 session 个数',
        unit: '个'
      },
      'undertow.global.sent': {
        color: 'purple',
        text: '发送的字节数',
        unit: 'bytes'
      },
      'undertow.global.request.max': {
        color: 'purple',
        text: 'request 请求最长耗时',
        unit: '秒'
      },
      'undertow.global.request.count': {
        color: 'purple',
        text: '全局 request 请求次数',
        unit: '次'
      },
      'undertow.global.request.totalTime': {
        color: 'purple',
        text: '全局 request 请求总耗时',
        unit: '秒'
      },
      'undertow.servlet.request.max': {
        color: 'cyan',
        text: 'servlet 请求最长耗时',
        unit: '秒'
      },
      'undertow.servlet.request.count': {
        color: 'cyan',
        text: 'servlet 总请求次数',
        unit: '次'
      },
      'undertow.servlet.request.totalTime': {
        color: 'cyan',
        text: 'servlet 请求总耗时',
        unit: '秒'
      },
      'undertow.threads.current': {
        color: 'pink',
        text: 'tomcat 当前线程数（包括守护线程）',
        unit: '个'
      },
      'undertow.threads.config.max': {
        color: 'pink',
        text: 'undertow 配置的线程最大数',
        unit: '个'
      }
    };
  }
};

/**
 * 查询cpu数量
 * @param params
 */
export const getServerInfo = (infoType) => {
  if (infoType == '1') {
    return Promise.all([getCpuCount(), getCpuUsage(), getProcessStartTime(), getProcessUptime(), getProcessCpuUsage()]);
  }
  if (infoType == '2') {
    return Promise.all([
      getJvmMemoryMax(),
      getJvmMemoryCommitted(),
      getJvmMemoryUsed(),
      getJvmBufferCount(),
      getJvmBufferMemoryUsed(),
      getJvmThreadsDaemon(),
      getJvmThreadsLive(),
      getJvmThreadsPeak(),
      getJvmClassesLoaded(),
      getJvmClassesUnloaded(),
      getJvmGcLiveDataSize(),
      getJvmGcMaxDataSize(),
      getJvmGcMemoryAllocated(),
      getJvmGcMemoryPromoted(),
      getJvmGcPause()
    ]);
  }
  if (infoType == '3') {
    return Promise.all([
      getTomcatSessionsActiveCurrent(),
      getTomcatSessionsActiveMax(),
      getTomcatSessionsCreated(),
      getTomcatSessionsExpired(),
      getTomcatSessionsRejected()
    ]);
  }
};