test_start&test_stop

test_start：开始新的负载测试时在每个节点上触发。如果在测试期间用户数量发生变化，则不会再次触发
test_stop: 当负载测试停止时在每个节点上触发

  1. @events.test_start.add_listener
  2. def on_test_start(**kwargs):
  3.     print(f'A new test is starting')
  6. @events.test_stop.add_listener
  7. def on_test_stop(**kwargs):
  8.     print('A new test is ending')

init_command_line_parser

自定义locust命令行选项

  1. # 使用实例：分布式压测时，如果场景需要不同worker对同一份测试数据中取的数据不同，
  2. # 可自定义命令行选项，结合init事件使用
  4. # ------------- 方式一 -------------------
  6. @events.init_command_line_parser.add_listener
  7. def add_user_parser(parser, **kwargs):
  8.     """自定义locust命令参数"""
  9.     parser.add_argument(
  10.         "-fi",
  11.         "--first_index",
  12.         help="获取截取列表首索引"
  13.              "[fc:]",
  14.         default=0,
  15.         type=str
  16.     )
  17.     parser.add_argument(
  18.         "-li",
  19.         "--last_index",
  20.         help="获取截取列表末索引"
  21.              "[:li]",
  22.         default=0,
  23.         type=str
  24.     )
  25.     args = parser.parse_args()
  26.     if args.first_index:
  27.         os.environ['first_index'] = args.first_index
  28.     if args.last_index:
  29.         os.environ['last_index'] = args.last_index
  32. # ----------- 方式二 ---------------------
  33. @events.init_command_line_parser.add_listener
  34. def add_user_parser(parser, **kwargs):
  35.     parser.add_argument("--user_id", type=str, default=None, required=True, help="召回用户ID")
  36.     parser.add_argument("--recall_type", type=str, default=None, required=True, help="召回类型")
  37.     parser.add_argument("--model_key", type=str, default=None, required=True, help="召回队列")
  38.     parser.add_argument("--scene", type=int, default=None, required=True, help="召回场景")
  39.     parser.add_argument("--content_type_limit", type=int, default=None, required=True, help="召回内容类型限定")
  42. @events.init.add_listener
  43. def _(environment, **kwargs):
  44.     logger.info(f"environment:{environment}")
  45.     logger.info(f"召回用户id~：{environment.parsed_options.user_id}")
  46.     logger.info(f"召回类型：{environment.parsed_options.recall_type}")
  47.     logger.info(f"召回队列：{environment.parsed_options.model_key}")
  48.     logger.info(f"召回场景：{environment.parsed_options.scene}")
  49.     logger.info(f"召回内容类型限定：{environment.parsed_options.content_type_limit}")
  52. class RecallTask(TaskSet):
  53.     """
  54.     # api perf
  55.     """ 
  57.     def on_start(self):
  58.         """
  59.         :return:
  60.         """
  62.         logger.info(f"self: {self}")
  63.         logger.info(f"self.env: {self.user.environment}")
  64.         logger.info(f"self.env.parsed_options: {self.user.environment.parsed_options}")
  65.         logger.info(f"self.user.environment.__dict__: {self.user.environment.__dict__}")
  66.         # 自定义参数访问方式
  67.         self.user_id = self.user.environment.parsed_options.user_id
  68.         logger.info(f"self.user_id: {self.user_id}")
  72. """
  73. 使用方式一：
  74.     命令行输入：locust -f locustfile.py --web-host=0.0.0.0 -P 8876 --user_id tangyuehan --recall_type MeetingRecall --model_key Meeting --scene 63 --content_type_limit 9
  76. 使用方式二：
  77.     使用配置文件 master.conf
  78. locustfile = _perf.py
  79. logfile = _perf.log
  80. loglevel = DEBUG
  81. # headless = false
  82. autostart = true
  83. master = true
  84. master-bind-host = 0.0.0.0
  85. master-bind-port = 8879
  86. expect-workers = 1
  87. host = 
  88. users = 3
  89. spawn-rate = 1
  90. run-time = 10s
  91. # csv = true
  92. # csv-full-history = true
  93. html = _locust.html
  95. # 以下为自定义参数
  96. user_id = xxxx
  97. recall_type = xxx
  98. model_key = xxx
  99. scene = 63
  100. content_type_limit = 9
  102. """

�init

每一个 Locust进程开始的时候触发init事件，可用于全局测试数据的初始化，也可针对每个worker进程设置。

  1. # 结合上文的init_command_line_parser事件使用
  3. @events.init.add_listener
  4. def on_locust_init(environment, **kwargs):
  5.     print("当前环境变量first_index为： %s" % os.environ.get('first_index'))
  6.     print("当前环境变量last_index为： %s" % os.environ.get('last_index'))
  7.     for i in range(10000)[int(os.environ.get('first_index')): int(os.environ.get('last_index'))]:
  8.         ids.put_nowait(i)
  9.     print('初始化测试数据完毕')
  10.     if isinstance(environment.runner, MasterRunner):
  11.         print("master节点执行")
  12.     else:
  13.         print("worker节点执行")

�spawning_complete

当所有用户生成时触发，可用于集合点注册

  1. all_locusts_spawned = BoundedSemaphore()
  2. all_locusts_spawned.acquire()
  5. @events.spawning_complete.add_listener
  6. def on_hatch_complete(**kwargs):
  7.     all_locusts_spawned.release()  # 创建集合点

�request_failure

请求完成且失败时触发

�request_success

请求完成且成功时触发

�request

请求完成时触发
自定义Locust客户端使用示例：

  1. class SocketIO(object):
  2.     _locust_environment = None
  3.     start_time = 0
  5.     def __init__(self):
  6.         self.events = None
  7.         self.ws = None
  9.     def _require_failure(self, name, response_time, message, action, context, **kwargs):
  10.         """统计失败请求数"""
  11.         self.events.request_failure.fire(
  12.             request_type="接收数据",
  13.             name=name,
  14.             response_time=response_time,
  15.             response_length=len(message),
  16.             exception=f'{action} Content Error!',
  17.             context=context,
  18.         )
  20.     def _require_success(self, name, response_time, message, **kwargs):
  21.         """统计成功请求数"""
  22.         self.events.request_success.fire(
  23.             request_type="接收数据",
  24.             name=name,
  25.             response_time=response_time,
  26.             response_length=len(message),
  27.         )
  29.     def _require_fire(self, name, response_time, message, context, **kwargs):
  30.         """通用统计请求数"""
  31.         self.events.request.fire(
  32.             request_type="接收数据",
  33.             name=name,
  34.             response_time=response_time,
  35.             response_length=len(message),
  36.             exception=None,
  37.             context=context,
  38.         )
  39.  .....

�

  1. from locust import TaskSet, constant, task, events, FastHttpUser
  2. from logzero import logger
  3. from locust.runners import MasterRunner
  4. from gevent._semaphore import BoundedSemaphore
  6. """hook事件"""
  8. # 注册init初始化事件
  9. @events.init.add_listener
  10. def _(environment, **kwargs):
  11.     logger.info("***初始化 locust，发生在解析locust文件之后，但在测试接口开始之前，分布式执行则每个slave初始化一次***")
  12.     if not isinstance(environment.runner, MasterRunner):
  13.         logger.info("***slave test setup***")
  14.     else:
  15.         logger.info("***开始启动master节点***")
  17. # 注册停止locust进程钩子事件
  18. @events.quitting.add_listener
  19. def _(environment, **kwargs):
  20.     logger.info("***Locust 进程退出时触发***")
  22. # 注册test_start事件
  23. @events.test_start.add_listener
  24. def on_test_start(**kwargs):
  25.     logger.info("***开始新的负载测试时在每个节点上触发。如果在测试期间用户数量发生变化，则不会再次触发***")
  28. # 注册test_stop事件
  29. @events.test_stop.add_listener
  30. def on_test_stop(**kwargs):
  31.     logger.info("***当负载测试停止时在每个节点上触发***")
  33. # 创建集合点
  34. all_locusts_spawned = BoundedSemaphore()
  35. all_locusts_spawned.acquire()
  37. # 注册集合点事件
  38. @events.spawning_complete.add_listener
  39. def on_hatch_complete(**kwargs):
  40.     all_locusts_spawned.release()
  43. class DemoUser(FastHttpUser):
  44.     """locust 任务"""
  45.     host = "http://coolaf.com"
  46.     max_wait = 0
  47.     min_wait = 0
  49.     def on_start(self):
  50.         """setup
  51.         """
  52.         logger.info("***每启动一个user执行一次***")
  54.     def on_stop(self):
  55.         """teardown
  56.         """
  57.         logger.info("***user停止后的清理工作***")
  59.     @task(1)
  60.     def execute_baidu_api(self):
  61.         """压测接口"""
  62.         all_locusts_spawned.wait()  # 限制在所有用户准备完成前处于等待状态
  63.         headers = {
  64.             "Connection": "keep-alive",
  65.             "Accept": "*/*"
  66.         }
  67.         with self.client.get(path="/zh/tool/unix", data=None, catch_response=True, headers=headers) as res:
  68.             if res.status_code == 200:
  69.                 res.success()
  70.             else:
  71.                 res.failure(f"{res.status_code}")
  74. # if __name__ == "__main__":
  75. #     import os
  76. #     filename = os.path.abspath(__file__)
  77. #     os.system(f'locust -f {filename} --web-host=0.0.0.0 -P 8879')
  80. """
  82. [I 211226 00:08:52 locustfile:18] ***初始化 locust，发生在解析locust文件之后，但在测试接口开始之前，分布式执行则每个slave初始化一次***
  83. [I 211226 00:08:52 locustfile:20] ***slave test setup***
  84. [2021-12-26 00:08:52,920] liyanzhen-2020-001.novalocal/INFO/locust.main: Starting Locust 2.5.1
  85. [2021-12-26 00:08:52,925] liyanzhen-2020-001.novalocal/INFO/locust.main: Starting web interface at http://10.138.35.88:8090
  86. [I 211226 00:08:52 locustfile:18] ***初始化 locust，发生在解析locust文件之后，但在测试接口开始之前，分布式执行则每个slave初始化一次***
  87. [I 211226 00:08:52 locustfile:22] ***开始启动master节点***
  88. [2021-12-26 00:08:52,943] liyanzhen-2020-001.novalocal/INFO/locust.main: Starting Locust 2.5.1
  89. [I 211226 00:08:52 locustfile:18] ***初始化 locust，发生在解析locust文件之后，但在测试接口开始之前，分布式执行则每个slave初始化一次***
  90. [I 211226 00:08:52 locustfile:20] ***slave test setup***
  91. [2021-12-26 00:08:52,945] liyanzhen-2020-001.novalocal/INFO/locust.main: Starting Locust 2.5.1
  92. [2021-12-26 00:08:52,953] liyanzhen-2020-001.novalocal/INFO/locust.runners: Client 'liyanzhen-2020-001.novalocal_44ae8e22fdf44c14aa41a083bf661dda' reported as ready. Currently 1 clients ready to swarm.
  93. [2021-12-26 00:08:53,102] liyanzhen-2020-001.novalocal/INFO/locust.runners: Client 'liyanzhen-2020-001.novalocal_863954e80407496380e0f7e64e0d32c6' reported as ready. Currently 2 clients ready to swarm.
  94. [2021-12-26 00:09:06,074] liyanzhen-2020-001.novalocal/INFO/locust.runners: Sending spawn jobs of 4 users at 1.00 spawn rate to 2 ready clients
  95. [I 211226 00:09:06 locustfile:32] ***开始新的负载测试时在每个节点上触发。如果在测试期间用户数量发生变化，则不会再次触发***
  96. [I 211226 00:09:06 locustfile:32] ***开始新的负载测试时在每个节点上触发。如果在测试期间用户数量发生变化，则不会再次触发***
  97. [I 211226 00:09:06 locustfile:50] ***每启动一个user执行一次***
  98. [I 211226 00:09:06 locustfile:32] ***开始新的负载测试时在每个节点上触发。如果在测试期间用户数量发生变化，则不会再次触发***
  99. [I 211226 00:09:07 locustfile:50] ***每启动一个user执行一次***
  100. [I 211226 00:09:08 locustfile:50] ***每启动一个user执行一次***
  101. [I 211226 00:09:09 locustfile:50] ***每启动一个user执行一次***
  102. [2021-12-26 00:09:09,171] liyanzhen-2020-001.novalocal/INFO/locust.runners: All users spawned: {"DemoUser": 4} (4 total users)
  103. [I 211226 00:09:15 locustfile:55] ***user停止后的清理工作***
  104. [I 211226 00:09:15 locustfile:55] ***user停止后的清理工作***
  105. [I 211226 00:09:15 locustfile:55] ***user停止后的清理工作***
  106. [I 211226 00:09:15 locustfile:55] ***user停止后的清理工作***
  107. [I 211226 00:09:15 locustfile:38] ***当负载测试停止时在每个节点上触发***
  108. [I 211226 00:09:15 locustfile:38] ***当负载测试停止时在每个节点上触发***
  109. [2021-12-26 00:09:15,735] liyanzhen-2020-001.novalocal/INFO/locust.runners: Removing liyanzhen-2020-001.novalocal_44ae8e22fdf44c14aa41a083bf661dda client from running clients
  110. [2021-12-26 00:09:15,736] liyanzhen-2020-001.novalocal/INFO/locust.runners: Client 'liyanzhen-2020-001.novalocal_44ae8e22fdf44c14aa41a083bf661dda' reported as ready. Currently 2 clients ready to swarm.
  111. [2021-12-26 00:09:15,736] liyanzhen-2020-001.novalocal/INFO/locust.runners: Removing liyanzhen-2020-001.novalocal_863954e80407496380e0f7e64e0d32c6 client from running clients
  112. [2021-12-26 00:09:15,736] liyanzhen-2020-001.novalocal/INFO/locust.runners: Client 'liyanzhen-2020-001.novalocal_863954e80407496380e0f7e64e0d32c6' reported as ready. Currently 2 clients ready to swarm.
  113. [I 211226 00:09:16 locustfile:38] ***当负载测试停止时在每个节点上触发***
  115. """