chore: import upstream snapshot with attribution

doc/source/serve/doc_code/monitoring/custom_metric_snippet.py

@@ -0,0 +1,36 @@
+# __start__
+from ray import serve
+from ray.serve import metrics
+
+import time
+import requests
+
+
+@serve.deployment
+class MyDeployment:
+    def __init__(self):
+        self.num_requests = 0
+        self.my_counter = metrics.Counter(
+            "my_counter",
+            description=("The number of odd-numbered requests to this deployment."),
+            tag_keys=("model",),
+        )
+        self.my_counter.set_default_tags({"model": "123"})
+
+    def __call__(self):
+        self.num_requests += 1
+        if self.num_requests % 2 == 1:
+            self.my_counter.inc()
+
+
+my_deployment = MyDeployment.bind()
+serve.run(my_deployment)
+
+while True:
+    requests.get("http://localhost:8000/")
+    time.sleep(1)
+
+    # __end__
+    break
+response = requests.get("http://localhost:8000/")
+assert response.status_code == 200

doc/source/serve/doc_code/monitoring/deployment_logger.py

@@ -0,0 +1,29 @@
+# __start__
+from ray import serve
+
+import logging
+import requests
+
+logger = logging.getLogger("ray.serve")
+
+
+@serve.deployment
+class Counter:
+    def __init__(self):
+        self.count = 0
+
+    def __call__(self, request):
+        self.count += 1
+        logger.info(f"count: {self.count}")
+        return {"count": self.count}
+
+
+counter = Counter.bind()
+serve.run(counter)
+
+for i in range(10):
+    requests.get("http://127.0.0.1:8000/")
+# __end__
+
+response = requests.get("http://127.0.0.1:8000/")
+assert response.json() == {"count": 11}

doc/source/serve/doc_code/monitoring/logging_config.py

@@ -0,0 +1,129 @@
+# flake8: noqa
+#  __deployment_json_start__
+import requests
+from ray import serve
+from ray.serve.schema import LoggingConfig
+
+
+@serve.deployment(logging_config=LoggingConfig(encoding="JSON"))
+class Model:
+    def __call__(self) -> int:
+        return "hello world"
+
+
+serve.run(Model.bind())
+
+resp = requests.get("http://localhost:8000/")
+
+# __deployment_json_end__
+
+
+#  __serve_run_json_start__
+import requests
+from ray import serve
+from ray.serve.schema import LoggingConfig
+
+
+@serve.deployment
+class Model:
+    def __call__(self) -> int:
+        return "hello world"
+
+
+serve.run(Model.bind(), logging_config=LoggingConfig(encoding="JSON"))
+
+resp = requests.get("http://localhost:8000/")
+
+# __serve_run_json_end__
+
+
+#  __level_start__
+
+
+@serve.deployment(logging_config=LoggingConfig(log_level="DEBUG"))
+class Model:
+    def __call__(self) -> int:
+        logger = logging.getLogger("ray.serve")
+        logger.debug("This debug message is from the router.")
+        return "hello world"
+
+
+# __level_end__
+
+serve.run(Model.bind())
+
+resp = requests.get("http://localhost:8000/")
+
+
+# __logs_dir_start__
+@serve.deployment(logging_config=LoggingConfig(logs_dir="/my_dirs"))
+class Model:
+    def __call__(self) -> int:
+        return "hello world"
+
+
+# __logs_dir_end__
+
+
+# __enable_access_log_start__
+import requests
+import logging
+from ray import serve
+
+
+@serve.deployment(logging_config={"enable_access_log": False})
+class Model:
+    def __call__(self):
+        logger = logging.getLogger("ray.serve")
+        logger.info("hello world")
+
+
+serve.run(Model.bind())
+
+resp = requests.get("http://localhost:8000/")
+
+# __enable_access_log_end__
+
+
+# __application_and_deployment_start__
+import requests
+import logging
+from ray import serve
+
+
+@serve.deployment
+class Router:
+    def __init__(self, handle):
+        self.handle = handle
+
+    async def __call__(self):
+        logger = logging.getLogger("ray.serve")
+        logger.debug("This debug message is from the router.")
+        return await self.handle.remote()
+
+
+@serve.deployment(logging_config={"log_level": "INFO"})
+class Model:
+    def __call__(self) -> int:
+        logger = logging.getLogger("ray.serve")
+        logger.debug("This debug message is from the model.")
+        return "hello world"
+
+
+serve.run(Router.bind(Model.bind()), logging_config={"log_level": "DEBUG"})
+resp = requests.get("http://localhost:8000/")
+# __application_and_deployment_end__
+
+# __configure_serve_component_start__
+from ray import serve
+
+
+serve.start(
+    logging_config={
+        "encoding": "JSON",
+        "log_level": "DEBUG",
+        "enable_access_log": False,
+    }
+)
+
+# __configure_serve_component_end__

doc/source/serve/doc_code/monitoring/metrics_snippet.py

@@ -0,0 +1,23 @@
+# __start__
+from ray import serve
+
+import time
+import requests
+
+
+@serve.deployment
+def sleeper():
+    time.sleep(1)
+
+
+s = sleeper.bind()
+
+serve.run(s)
+
+while True:
+    requests.get("http://localhost:8000/")
+    # __end__
+    break
+
+response = requests.get("http://localhost:8000/")
+assert response.status_code == 200

doc/source/serve/doc_code/monitoring/monitor_deployment.py

@@ -0,0 +1,33 @@
+# flake8: noqa
+# fmt: off
+
+# __monitor_start__
+from typing import List, Dict
+
+from ray import serve
+from ray.serve.schema import ServeStatus, ApplicationStatusOverview
+
+
+@serve.deployment
+def get_healthy_apps() -> List[str]:
+    serve_status: ServeStatus = serve.status()
+    app_statuses: Dict[str, ApplicationStatusOverview] = serve_status.applications
+
+    running_apps = []
+    for app_name, app_status in app_statuses.items():
+        if app_status.status == "RUNNING":
+            running_apps.append(app_name)
+
+    return running_apps
+
+
+monitoring_app = get_healthy_apps.bind()
+# __monitor_end__
+
+serve.run(monitoring_app, name="monitor")
+
+import requests
+
+resp = requests.get("http://localhost:8000/")
+
+assert requests.get("http://localhost:8000/").json() == ["monitor"]

doc/source/serve/doc_code/monitoring/monitoring.py

@@ -0,0 +1,27 @@
+# flake8: noqa
+
+# __start__
+# File name: monitoring.py
+
+from ray import serve
+import logging
+from starlette.requests import Request
+
+logger = logging.getLogger("ray.serve")
+
+
+@serve.deployment
+class SayHello:
+    async def __call__(self, request: Request) -> str:
+        logger.info("Hello world!")
+        return "hi"
+
+
+say_hello = SayHello.bind()
+# __end__
+
+# serve.run(say_hello)
+
+# import requests
+# response = requests.get("http://localhost:8000/")
+# assert response.text == "hi"

doc/source/serve/doc_code/monitoring/request_id.py

@@ -0,0 +1,15 @@
+from ray import serve
+
+import requests
+
+
+@serve.deployment
+class Model:
+    def __call__(self) -> int:
+        return 1
+
+
+serve.run(Model.bind())
+resp = requests.get("http://localhost:8000", headers={"X-Request-ID": "123-234"})
+
+print(resp.headers["X-Request-ID"])