Digma Developer Guide
  • Welcome to the Digma Docs!
  • What is a Continuous Feedback platform?
  • Digma Quickstart
  • Installation
    • Local Install
      • Local Install Architecture
      • Installation Troubleshooting
    • Central (on-prem) Install
      • Resource Requirements
  • INSTRUMENTATION
    • Instrumenting your code for tracing
    • Java
      • Automatic Instrumentation in the IDE (IntelliJ)
      • Spring, Spring Boot, Dropwizard
        • Instrumenting your code in CI/Staging or the terminal
        • Instrumenting your application in Docker Compose
        • Instrumenting your application on Kubernetes
        • Covering more of your code with Observability
        • Using GitHub Actions (beta)
        • Using Micrometer Tracing (Spring Boot 3.x only)
        • Instrumenting code running in CLI
      • Quarkus, Micronaut, OpenLiberty
    • .NET
    • Correlating observability and source code commits
    • Sending Data to Digma using the OTEL Collector
    • Sending Data to Digma Using the Datadog agent
  • Use Cases
    • Design and write code more efficiently by understanding the system flows
    • Get early feedback on bottlenecks and code issues
    • Prioritize Technical Debt
  • Digma Core Concepts
    • Environments
    • Assets
    • Analytics vs. Issues
  • Digma Features
    • Issues
      • Suspected N+1
      • Excessive API calls (chatty API)
      • Bottleneck
      • Scaling Issue
      • Session In View Query Detected
      • Query Optimization Suggested
      • High number of queries
      • Slow Endpoint
    • Analytics
      • Top Usage
      • Request Breakdown
      • Duration
      • Code Nexus
      • Duration Breakdown
      • Endpoint Low/High Usage
    • Performance Impact
    • Test observability
    • Issue Criticality
  • Sample Projects
    • Spring Boot
  • Troubleshooting
    • Reporting Plugin Issues
    • Digma Overload Warning
Powered by GitBook
On this page
  • Why use observability with tests
  • Running tests in the IDE
  • Connecting your CI tests with Digma
  1. Digma Features

Test observability

PreviousPerformance ImpactNextIssue Criticality

Last updated 1 year ago

Why use observability with tests

Tests can be a great source of observability. The ability to study the application in a controlled experiment, changing only the code each time - is a huge opportunity to uncover issues and study how the system behaves.

In practical terms, this means that Digma creates a two-way mapping between the test of each asset - database query, endpoint, code location, or consumer. From the test level, you can identify issues and study system analytics under the test environment.

Interestingly, from the scope of each asset, you can see which tests are triggering it, as well as any related insights and traces.

Running tests in the IDE

When you run your integration or end-to-end tests in the IDE, Digma will automatically pick up on that to add observability to each test context. Assuming that the Observability Toggle is turned on, Digma will wrap each test in a trace and begin to analyze which assets were called and how they performed.

Connecting your CI tests with Digma

Follow the instructions for instrumenting your app in CI as documented .

You should create unique for different test types, to avoid data anomalies and maintain consistency in the analytics.

here
environments