feat(docs): Fix broken link to Stubs in docs, added observability-testing.

Signed-off-by: BillyDoesDev <[email protected]>

Author: BillyDoesDev

src/pages/concepts/reference/glossary.js

@@ -4,7 +4,7 @@ import useDocusaurusContext from "@docusaurus/useDocusaurusContext";
 
 function Glossary() {
   const [state, setState] = useState(() => {
-    const alphabet = "ABCEFGIMRSTUW";
+    const alphabet = "ABCEFGIMORSTUW";
     const initialState = {};
     for (let i = 0; i < alphabet.length; i++) {
       initialState[alphabet[i]] = true;
@@ -96,6 +96,12 @@ function Glossary() {
         link: "/docs/concepts/reference/glossary/microservice-testing",
       },
     ],
+    O: [
+      {
+        name: "Observability Testing",
+        link: "/docs/concepts/reference/glossary/observability-testing",
+      },
+    ],
     R: [
       {
         name: "Regression Testing",
@@ -105,7 +111,7 @@ function Glossary() {
     S: [
       {
         name: "Stubs",
-        ink: "/docs/concepts/reference/glossary/stubs",
+        link: "/docs/concepts/reference/glossary/stubs",
       },
       {
         name: "Software Testing Life Cycle",

versioned_docs/version-3.0.0/concepts/reference/glossary/observability-testing.md

@@ -0,0 +1,76 @@
+---
+id: observability-testing
+title: Observability Testing with Keploy
+sidebar_label: Observability Testing
+description: This glossary has an explanation of all the terminologies that beginners find difficult to understand at first glance.
+tags:
+  - explanation
+  - glossary
+  - observability
+  - testing
+  - monitoring
+keywords:
+  - API
+  - observability
+  - testing
+  - logs
+  - metrics
+  - traces
+---
+
+## What is Observability Testing?
+
+<figure>
+  <img src="https://grafana.com/media/blog/otel-lgtm-docker-image/docker-image_components.png?w=900" />
+  <figcaption class="figcaption">The OTEL-LGTM Stack. Image Credits: <a href="https://grafana.com/blog/2024/03/13/an-opentelemetry-backend-in-a-docker-image-introducing-grafana/otel-lgtm/">Grafana</a></figcaption>
+</figure>
+
+
+Observability in testing ensures that software systems produce sufficient data (logs, metrics, and traces - the holy trinity of telemetry) to understand their internal state and diagnose issues during or after tests.
+
+Popular tools and frameworks used for tracking these metrics are [Grafana](https://grafana.com) and [Prometheus](https://prometheus.io/). To learn more about getting started with these tools, check out their elaborate [guide](https://grafana.com/docs/grafana/latest/getting-started/get-started-grafana-prometheus/).
+
+## What Does Observability Add To Testing?
+
+- **Improved debugging** — easier to pinpoint failures and their causes.
+- **Faster incident response** — helps teams react to test failures or outages.
+- **Enhanced confidence in system behavior** — tests validate not just outcomes, but how systems behave under load or failure.
+
+## Example Observability Checks During Testing
+
+- Validate that API request traces are emitted for each call.
+- Ensure error logs are generated when failures occur.
+- Confirm metrics (e.g., response times, throughput) meet expected thresholds during load tests.
+
+## Challenges in Observability Testing:
+
+- **Signal overload (too much data)**  
+  - Systems emit large volumes of logs, metrics, and traces, making it difficult to identify meaningful signals amidst noise.
+
+- **Lack of automated assertions**  
+  - Observability data is collected but not actively validated in test cases, causing issues to go undetected unless manually reviewed.
+
+- **Lack of production fidelity in test environments**  
+  - CI or staging environments may not emit the same telemetry as production, leading to false positives or missed issues.
+
+- **Non-determinism in metrics**  
+  - Performance data can fluctuate across test runs, making it difficult to assert on expected values reliably.
+
+- **Difficulty correlating logs, metrics, and traces**  
+  - Without unified tooling, it's hard to trace a single issue across different observability signals.
+
+
+## Overcoming Challenges with Keploy
+
+Keploy is an innovative testing tool designed to address many of the challenges associated with observability testing. Here's how it helps:
+<img src="https://keploy.io/docs/gif/record-replay.gif?raw=true"/>
+<br/>
+
+- **Automated Test Case Generation**: Keploy can generate test cases by recording your application's network calls. This automation significantly reduces the time and effort required to create comprehensive test suites.
+- **Dependency Mocking**: Keploy automatically generates dependency mocks based on recorded network interactions. This feature allows for faster and more efficient testing compared to traditional unit tests.
+- **Realistic Testing Environment**: With its built-in proxy setup, Keploy records system calls between services, creating a more accurate representation of the production environment in your tests.
+- **Efficient Integration Testing**: By capturing and replaying inter-service communications, Keploy enables more effective integration testing without the need to set up complex environments.
+- **Reduced Test Maintenance**: As Keploy generates tests based on actual system behavior, it helps keep tests up-to-date with changes in the observability, reducing the maintenance burden.
+- **Performance Testing**: The recorded interactions can be used to simulate realistic load scenarios, aiding in performance testing of observability.
+
+By leveraging Keploy's capabilities, development teams can overcome many of the traditional challenges associated with observability testing, leading to more robust and reliable distributed systems.