Traces Query Builder An Implementation For Intuitive Trace Analysis

by StackCamp Team 68 views

Problem Statement

Trace analysis is crucial for operations teams, but querying traces shouldn't require deep SQL knowledge. This project aims to develop an intuitive traces query builder that empowers users to filter, group, and aggregate trace data effortlessly. This visual query builder will generate efficient SQL queries optimized for SignalDB's Flight protocol, making trace analysis accessible to a broader audience. This means that querying traces becomes more streamlined, allowing teams to quickly identify and resolve issues without needing to write complex SQL statements. The primary goal is to provide a user-friendly interface that simplifies the process of exploring trace data and extracting valuable insights. By abstracting away the complexities of SQL, the traces query builder enables users to focus on understanding the behavior of their systems and applications.

Building a traces query builder addresses a significant pain point for operations teams. The ability to quickly and easily construct queries means faster troubleshooting, improved monitoring, and more effective dashboard creation. This project emphasizes a point-and-click approach, ensuring that users can interact with their trace data in a way that feels natural and intuitive. The visual query builder will include a variety of components designed to facilitate the creation of sophisticated queries without the need for manual SQL coding. The goal is to make trace analysis an integral part of the operational workflow, empowering teams to proactively manage their systems and respond effectively to incidents. This enhanced accessibility can lead to improved system reliability, reduced downtime, and better overall performance.

The significance of this project lies in its potential to democratize trace analysis. By providing a user-friendly interface, it lowers the barrier to entry for individuals who may not have extensive SQL expertise. This empowers a wider range of team members to participate in the process of identifying and resolving issues, fostering collaboration and knowledge sharing. The traces query builder is designed to be flexible and extensible, accommodating a variety of use cases and evolving needs. It will support a range of filtering, grouping, and aggregation options, allowing users to tailor their queries to specific requirements. The integration with SignalDB's Flight protocol ensures efficient data retrieval, even for large datasets. This combination of accessibility, flexibility, and performance makes the visual query builder a powerful tool for trace analysis in modern operational environments.

Use Case

Trace analysis tools are indispensable for various roles within an organization. Operations engineers leverage these tools to investigate service issues, identifying bottlenecks and error sources. Site reliability engineers (SREs) monitor trace performance, ensuring that systems meet service level objectives (SLOs) and proactively addressing potential problems. Support teams use trace data to troubleshoot customer-reported problems, gaining insights into user interactions and system behavior. DevOps teams rely on trace-based dashboards to visualize key performance indicators (KPIs) and gain a holistic view of system health. These diverse use cases highlight the broad applicability of trace analysis and the importance of providing accessible and efficient tools.

The primary users of the traces query builder span multiple teams and roles. Operations engineers will use it to pinpoint the root cause of incidents, examining traces to understand the flow of requests and identify points of failure. SREs will use the query builder to monitor key metrics such as latency, error rates, and throughput, proactively identifying and addressing performance degradations. Support teams can leverage trace data to understand the context of customer issues, providing faster and more effective resolutions. DevOps teams will incorporate the query builder into their dashboards, creating visualizations that provide real-time insights into system performance and behavior. This widespread adoption will foster a data-driven culture, empowering teams to make informed decisions based on trace analysis.

Common queries illustrate the diverse range of questions that users need to answer. For instance, an engineer might ask, "Show me all traces for service X that took longer than 500ms," to identify performance bottlenecks. Another common query is, "Find error traces in the last hour," which helps in quickly identifying and addressing recent failures. SREs might group traces by operation and show the p95 latency to understand tail-end performance. Support teams often need to find traces with specific tags, such as "user_id=12345," to troubleshoot customer-specific issues. These examples highlight the need for a traces query builder that supports a variety of filtering, grouping, and aggregation options, empowering users to answer complex questions about their systems. The ability to construct these queries efficiently is crucial for maintaining system health and delivering a high-quality user experience.

Proposed Solution

The proposed solution is a React-based query builder interface designed to generate SQL queries for trace data. This visual query builder will provide a user-friendly way to construct complex queries without requiring knowledge of SQL. By leveraging React, we can create a dynamic and responsive interface that adapts to user interactions. The interface will consist of several key components, each designed to address a specific aspect of query construction. These components will work together to provide a seamless and intuitive experience for users of all skill levels. The goal is to make trace analysis accessible to a wider audience, empowering teams to quickly and easily extract valuable insights from their trace data. The SQL generation logic will be carefully crafted to ensure efficiency and compatibility with SignalDB's Flight protocol, enabling fast and reliable query execution.

Visual Query Builder Components

1. Service & Operation Selection

The Service & Operation Selection component is a crucial part of the traces query builder, enabling users to narrow down their search by specifying the services and operations of interest. This component will feature a multi-select dropdown for services, allowing users to choose one or more services to focus on. The operations dropdown will be dynamically filtered based on the selected services, ensuring that users only see relevant operations. An "includeSubservices" boolean option will allow users to extend their query to include downstream services, providing a more comprehensive view of the system. This functionality is essential for understanding the impact of issues across service boundaries. The component's design will prioritize ease of use and clarity, making it simple for users to quickly specify the scope of their trace analysis. The use of multi-select dropdowns allows for flexible and granular control over the selection of services and operations.

interface ServiceOperationFilter {
 service: string[];          // Multi-select dropdown
 operation: string[];        // Multi-select dropdown (filtered by service)
 includeSubservices: boolean; // Include downstream services
}

2. Duration Filtering

Duration Filtering is a key feature of the traces query builder, allowing users to focus on traces that fall within a specific duration range. This component will include an "enabled" boolean to toggle the duration filter on or off. Users can specify minimum and maximum duration values in milliseconds, seconds, or minutes, providing flexibility in defining the desired range. A time unit selector will allow users to switch between these units. This filter is crucial for identifying slow-running operations or performance bottlenecks. The interface will be designed to be intuitive and user-friendly, allowing users to quickly specify the desired duration range. This component will enable users to easily isolate traces that are contributing to performance issues, making it a valuable tool for trace analysis. The ability to specify both minimum and maximum durations allows for fine-grained control over the filtering process.

interface DurationFilter {
 enabled: boolean;
 min?: number;              // Minimum duration in ms
 max?: number;              // Maximum duration in ms
 unit: 'ms' | 's' | 'm';    // Time unit
}

3. Status & Error Filtering

Status & Error Filtering is an essential component for identifying problematic traces. This component will allow users to filter traces based on their status (success, error, or timeout). Additionally, users can filter by specific error types and HTTP status codes, providing a more granular view of errors. This functionality is crucial for quickly identifying and addressing issues within the system. The component will be designed to be user-friendly, allowing users to easily select the desired status and error criteria. By filtering based on status and error types, users can quickly isolate traces that are indicative of problems, enabling efficient trace analysis and troubleshooting. The inclusion of HTTP status code filtering further enhances the ability to pinpoint specific issues.

interface StatusFilter {
 status: ('success' | 'error' | 'timeout')[];
 errorTypes: string[];      // Specific error types
 statusCodes: number[];     // HTTP status codes
}

4. Tag-based Filtering

Tag-based Filtering is a powerful feature that allows users to filter traces based on custom tags. This component will enable users to specify a key, operator, and value for each tag filter. Supported operators will include "equals," "contains," "startsWith," and "regex," providing flexibility in matching tag values. Users can also specify the data type of the tag value (string, number, or boolean), ensuring accurate filtering. This functionality is crucial for filtering traces based on specific attributes or contexts. The interface will be designed to be intuitive, allowing users to easily add and configure multiple tag filters. By leveraging tag-based filtering, users can drill down into specific subsets of their trace data, enabling more targeted trace analysis.

interface TagFilter {
 key: string;
 operator: 'equals' | 'contains' | 'startsWith' | 'regex';
 value: string;
 type: 'string' | 'number' | 'boolean';
}

5. Time Range & Sampling

Time Range & Sampling is a critical component for specifying the timeframe and volume of trace data to analyze. This component will allow users to define a time range using a "from" and "to" date. Additionally, users can specify a sampling rate, which determines the percentage of traces to include in the query. This is particularly useful for analyzing large datasets, as it allows users to reduce the volume of data while still retaining representative samples. The component will be integrated with Grafana's time range picker, providing a seamless experience for users who are familiar with Grafana. By controlling the time range and sampling rate, users can optimize their queries for performance and relevance, making trace analysis more efficient.

interface TimeRangeFilter {
 from: Date;
 to: Date;
 samplingRate?: number;     // Percentage of traces to sample
}

Query Builder UI Mock

The Query Builder UI Mock provides a visual representation of the proposed interface. It showcases the arrangement of the different components, including Service selection, Operation selection, Duration filtering, Status filtering, Tag-based filtering, Time Range selection, Group By options, and Aggregation functions. The mock also includes action buttons for Previewing the Query, Resetting the form, and Applying the filters. This mock serves as a blueprint for the development of the traces query builder, ensuring that the interface is intuitive and user-friendly. It highlights the key elements that users will interact with when constructing queries. The layout is designed to be clear and organized, making it easy for users to navigate and find the options they need. The inclusion of preview and reset buttons provides users with the ability to review their queries and start over if necessary. This UI mock is a crucial step in the development process, ensuring that the final product meets the needs of its users.

┌─────────────────────────────────────────────────────────────┐
│ Query Builder - Traces                                      │
├─────────────────────────────────────────────────────────────┤
│ Service: [user-service ▼] [payment-service ▼] [+ Add]      │
│ Operation: [login ▼] [process-payment ▼] [+ Add]           │
│                                                             │
│ Duration: [✓] Between [100] ms and [5000] ms                │
│                                                             │
│ Status: [✓] Success [✓] Error [ ] Timeout                   │
│                                                             │
│ Tags: [user_id] [equals ▼] [12345] [+ Add Filter]          │
│                                                             │
│ Time Range: [Last 1 hour ▼] [Custom Range...]              │
│                                                             │
│ Group By: [service ▼] [operation ▼]                        │
│ Aggregation: [count ▼] [p95(duration) ▼] [+ Add]          │
│                                                             │
│ [ Preview Query ] [ Reset ] [ Apply ]                      │
└─────────────────────────────────────────────────────────────┘

SQL Generation Logic

The SQL Generation Logic is the core of the traces query builder, responsible for translating the user's selections into efficient SQL queries. This logic will be implemented in the TracesQueryBuilder class, which includes a generateSQL method. This method takes a TracesQueryFilters object as input, representing the user's filter criteria. The method constructs a SQL query string by concatenating various clauses based on the filter settings. It adds WHERE clauses for service, duration, status, tags, and time range. It also includes GROUP BY clauses for grouping results and ORDER BY clauses for sorting. The generated SQL queries are designed to be compatible with SignalDB's schema and optimized for performance. The use of parameterized queries and proper escaping of user inputs ensures security. The SQL generation logic is a critical component of the traces query builder, as it directly impacts the efficiency and accuracy of trace analysis.

class TracesQueryBuilder {
 generateSQL(filters: TracesQueryFilters): string {
 let sql = `SELECT 
 trace_id,
 service_name,
 operation_name,
 duration_ms,
 status,
 timestamp,
 tags
 FROM traces
 WHERE 1=1`;

 // Add service filter
 if (filters.services.length > 0) {
 sql += ` AND service_name IN (${filters.services.map(s => `'${s}'`).join(', ')})`;
 }

 // Add duration filter
 if (filters.duration.enabled) {
 if (filters.duration.min) sql += ` AND duration_ms >= ${filters.duration.min}`;
 if (filters.duration.max) sql += ` AND duration_ms <= ${filters.duration.max}`;
 }

 // Add status filter
 if (filters.status.length > 0) {
 sql += ` AND status IN (${filters.status.map(s => `'${s}'`).join(', ')})`;
 }

 // Add tag filters
 filters.tags.forEach(tag => {
 switch (tag.operator) {
 case 'equals':
 sql += ` AND tags->>'${tag.key}' = '${tag.value}'`;
 break;
 case 'contains':
 sql += ` AND tags->>'${tag.key}' LIKE '%${tag.value}%'`;
 break;
 // ... other operators
 }
 });

 // Add time range
 sql += ` AND timestamp >= '${filters.timeRange.from.toISOString()}'`;
 sql += ` AND timestamp <= '${filters.timeRange.to.toISOString()}'`;

 // Add grouping and aggregation
 if (filters.groupBy.length > 0) {
 sql += ` GROUP BY ${filters.groupBy.join(', ')}`;
 }

 sql += ` ORDER BY timestamp DESC LIMIT 1000`;

 return sql;
 }
}

Acceptance Criteria

The acceptance criteria outline the requirements that the traces query builder must meet to be considered complete and successful. These criteria cover a wide range of aspects, from core query builder features to advanced filtering, grouping, aggregation, query management, user experience, and integration with other systems. Meeting these criteria ensures that the traces query builder is a robust, user-friendly, and effective tool for trace analysis. The acceptance criteria provide a clear roadmap for the development team and serve as a checklist for evaluating the final product.

Core Query Builder Features

The core query builder features define the fundamental functionalities that the traces query builder must provide. These include a service selection dropdown with autocomplete, allowing users to quickly find and select services. The operation selection should be filtered by selected services, ensuring that users only see relevant operations. A duration range slider with configurable units (ms, s, m) is necessary for filtering traces by duration. Status filtering (success, error, timeout) is essential for identifying problematic traces. Tag-based filtering with multiple operators (equals, contains, startsWith, regex) provides flexibility in matching tag values. Finally, time range picker integration with Grafana ensures a seamless experience for users who are familiar with Grafana. These core features form the foundation of the traces query builder, enabling users to construct basic but essential queries.

  • [ ] Service selection dropdown with autocomplete
  • [ ] Operation selection filtered by selected services
  • [ ] Duration range slider with configurable units
  • [ ] Status filtering (success, error, timeout)
  • [ ] Tag-based filtering with multiple operators
  • [ ] Time range picker integration with Grafana

Advanced Filtering

Advanced filtering capabilities extend the power and flexibility of the traces query builder. Multiple tag filters with AND/OR logic allow users to create complex filter conditions. Regex support for tag values provides even more flexibility in matching tag values. Numeric range filtering for tag values enables filtering based on numerical ranges. Sampling rate configuration allows users to control the volume of trace data to analyze. Finally, the ability to include or exclude subservice traces provides a more comprehensive view of the system. These advanced filtering features empower users to construct highly specific queries, enabling more targeted trace analysis.

  • [ ] Multiple tag filters with AND/OR logic
  • [ ] Regex support for tag values
  • [ ] Numeric range filtering for tag values
  • [ ] Sampling rate configuration
  • [ ] Include/exclude subservice traces

Grouping & Aggregation

Grouping and aggregation are essential for summarizing and analyzing trace data. The traces query builder should allow users to group traces by service, operation, status, or custom tags. Aggregation functions such as count, p50, p95, p99, avg, min, and max should be supported, providing a range of statistical measures. The ability to perform multiple aggregations in a single query is crucial for efficiency. Proper handling of time series grouping is necessary for creating time-based visualizations. These grouping and aggregation features enable users to extract meaningful insights from their trace data, identifying trends and patterns.

  • [ ] Group by service, operation, status, or custom tags
  • [ ] Aggregation functions: count, p50, p95, p99, avg, min, max
  • [ ] Multiple aggregations in single query
  • [ ] Proper handling of time series grouping

Query Management

Query management features enhance the usability and efficiency of the traces query builder. A SQL preview with syntax highlighting allows users to review the generated SQL query before execution. Query validation before execution helps prevent errors and ensures that queries are syntactically correct. The ability to save and load query templates allows users to reuse frequently used queries. A query history with recent queries provides a convenient way to access previously executed queries. Finally, a reset to default state button allows users to clear the form and start over. These query management features streamline the query building process and improve the overall user experience.

  • [ ] SQL preview with syntax highlighting
  • [ ] Query validation before execution
  • [ ] Save/load query templates
  • [ ] Query history with recent queries
  • [ ] Reset to default state

User Experience

A positive user experience (UX) is crucial for the adoption and effectiveness of the traces query builder. The interface should have a responsive design that adapts to different screen sizes. Loading states and progress indicators provide feedback to the user during query execution. Error handling with helpful messages helps users understand and resolve issues. Tooltips and help text for complex features provide guidance and support. Finally, keyboard shortcuts for power users enhance efficiency. These UX considerations ensure that the traces query builder is intuitive, user-friendly, and efficient to use.

  • [ ] Responsive design for different screen sizes
  • [ ] Loading states and progress indicators
  • [ ] Error handling with helpful messages
  • [ ] Tooltips and help text for complex features
  • [ ] Keyboard shortcuts for power users

Integration

Integration with other systems is essential for maximizing the value of the traces query builder. Seamless integration with Grafana template variables allows users to create dynamic queries that adapt to different contexts. Support for dashboard time range overrides ensures consistency across dashboards. The ability to export query results to CSV/JSON facilitates data sharing and analysis in other tools. Finally, links to trace details in external systems provide a seamless way to navigate from query results to detailed trace information. These integration features ensure that the traces query builder fits seamlessly into existing workflows and enhances the overall trace analysis experience.

  • [ ] Seamless integration with Grafana template variables
  • [ ] Support for dashboard time range overrides
  • [ ] Export query results to CSV/JSON
  • [ ] Link to trace details in external systems

Implementation Notes

React Component Structure

The proposed React component structure outlines the organization of the traces query builder interface. The main component, <TracesQueryBuilder>, will serve as the container for all other components. Inside this container, individual components will handle specific aspects of query construction, such as <ServiceSelector>, <OperationSelector>, <DurationFilter>, <StatusFilter>, <TagFilters>, <TimeRangeSelector>, <GroupBySelector>, <AggregationSelector>, <QueryPreview>, and <ActionButtons>. This modular structure promotes code reusability and maintainability. Each component will be responsible for managing its own state and rendering its portion of the UI. The components will communicate with each other through props and callbacks, ensuring a clear separation of concerns. This well-defined component structure is crucial for building a scalable and maintainable traces query builder.

// Main query builder component
<TracesQueryBuilder>
 <ServiceSelector />
 <OperationSelector />
 <DurationFilter />
 <StatusFilter />
 <TagFilters />
 <TimeRangeSelector />
 <GroupBySelector />
 <AggregationSelector />
 <QueryPreview />
 <ActionButtons />
</TracesQueryBuilder>

State Management

Effective state management is crucial for the responsiveness and performance of the traces query builder. React hooks will be used for local state management within individual components. This allows components to manage their own state without relying on a global state management library. Proper validation and error handling will ensure that user inputs are valid and that errors are handled gracefully. Debouncing user inputs will prevent excessive API calls, improving performance. Caching dropdown options will also enhance performance by reducing the number of API requests. These state management strategies are essential for building a smooth and efficient user experience. The focus on local state management with React hooks promotes simplicity and maintainability.

  • Use React hooks for local state management
  • Implement proper validation and error handling
  • Debounce user inputs to prevent excessive API calls
  • Cache dropdown options for performance

SQL Generation

The SQL generation process must be robust and secure. Parameterized queries will be used to prevent SQL injection attacks. Proper escaping of user inputs will ensure that special characters are handled correctly. Query optimization hints will be included to improve query performance. Support for different SQL dialects may be needed in the future to accommodate different database systems. These considerations are crucial for ensuring that the generated SQL queries are secure, efficient, and compatible with the target database. The SQL generation logic is a critical component of the traces query builder, and its design must prioritize security and performance.

  • Parameterized queries for security
  • Proper escaping of user inputs
  • Query optimization hints
  • Support for different SQL dialects if needed

Integration with Backend

Integration with the backend is essential for retrieving trace data. The traces query builder will generate SQL queries from the builder state. These queries will be sent to the backend via the Flight protocol. The backend will handle streaming results for large datasets, ensuring that the UI remains responsive. Query cancellation will allow users to stop long-running queries. These integration considerations are crucial for ensuring that the traces query builder can efficiently retrieve and display trace data. The use of the Flight protocol is key to achieving high performance and scalability.

  • Generate SQL queries from builder state
  • Send queries via Flight protocol
  • Handle streaming results for large datasets
  • Implement query cancellation

Testing Strategy

A comprehensive testing strategy is essential for ensuring the quality and reliability of the traces query builder. The testing strategy will include unit tests, integration tests, and user experience tests. Each type of test will focus on different aspects of the system, ensuring that all components are thoroughly tested. The goal of the testing strategy is to identify and resolve defects early in the development process, leading to a more robust and user-friendly product. The results of the tests will be used to guide development and ensure that the traces query builder meets the acceptance criteria.

Unit Tests

Unit tests will focus on testing individual components and functions in isolation. The SQL generation logic will be tested with various filter combinations to ensure that it generates correct SQL queries. Individual React components will be tested to ensure that they render correctly and handle user interactions properly. Input validation and error handling will be tested to ensure that invalid inputs are rejected and errors are handled gracefully. Query builder state management will be tested to ensure that the state is updated correctly in response to user actions. These unit tests will provide a solid foundation for the overall quality of the traces query builder.

  • SQL generation logic with various filter combinations
  • Individual React components
  • Input validation and error handling
  • Query builder state management

Integration Tests

Integration tests will focus on testing the interactions between different components and systems. End-to-end query building and execution will be tested to ensure that the entire query process works correctly. Integration with Grafana template variables will be tested to ensure that queries can be parameterized. Performance testing with large datasets will be conducted to ensure that the system can handle large volumes of trace data. Error handling scenarios will be tested to ensure that errors are handled correctly across different components. These integration tests will verify that the different parts of the system work together seamlessly.

  • End-to-end query building and execution
  • Integration with Grafana template variables
  • Performance testing with large datasets
  • Error handling scenarios

User Experience Tests

User experience (UX) tests will focus on evaluating the usability and effectiveness of the traces query builder interface. Usability testing with operations teams will be conducted to gather feedback on the user interface and workflow. Query builder workflow validation will ensure that the query building process is intuitive and efficient. Performance testing with complex queries will ensure that the system remains responsive even with complex queries. Accessibility testing will ensure that the interface is accessible to users with disabilities. These UX tests will provide valuable insights into the user experience and will guide improvements to the interface.

  • Usability testing with operations teams
  • Query builder workflow validation
  • Performance testing with complex queries
  • Accessibility testing

Dependencies

The traces query builder will rely on several key dependencies. React and TypeScript will be used for building the user interface. Grafana UI components will provide a consistent look and feel with Grafana. SQL query generation utilities will assist in generating SQL queries. Flight protocol integration (#168) will be essential for communicating with the backend. Plugin architecture (#169) will allow for future extensibility. These dependencies provide the foundation for building a robust and scalable traces query builder.

  • React and TypeScript
  • Grafana UI components
  • SQL query generation utilities
  • Flight protocol integration (#168)
  • Plugin architecture (#169)

Definition of Done

The Definition of Done (DoD) outlines the criteria that must be met for the traces query builder to be considered complete. The query builder UI must be fully functional. The SQL generation must be working correctly. Integration with the Flight protocol must be implemented. Comprehensive test coverage is required. User documentation and examples must be provided. Performance benchmarks must be completed. Finally, code review and UX review must be completed. Meeting these criteria ensures that the traces query builder is a high-quality product that meets the needs of its users.

  • [ ] Query builder UI fully functional
  • [ ] SQL generation working correctly
  • [ ] Integration with Flight protocol
  • [ ] Comprehensive test coverage
  • [ ] User documentation and examples
  • [ ] Performance benchmarks completed
  • [ ] Code review and UX review completed

Related Issues

Several related issues provide context and dependencies for the traces query builder project. Epic #166, the Grafana datasource plugin, is a parent issue that encompasses the traces query builder. Dependencies include #168, Flight protocol integration, and #169, Plugin architecture. Related issue #170, Advanced SQL editor, explores potential future enhancements. These related issues highlight the interconnectedness of the traces query builder with other parts of the system.

  • Epic: #166 - Grafana datasource plugin
  • Depends on: #168 - Flight protocol integration
  • Depends on: #169 - Plugin architecture
  • Related: #170 - Advanced SQL editor

Estimated Effort

The estimated effort for developing the traces query builder is 13 story points, which translates to a time estimate of 3-4 weeks. The risk level is considered medium due to the complexity of the UI logic. This estimate provides a rough timeline for the project and helps in planning resources and timelines. The medium risk level reflects the challenges associated with building a complex UI with robust functionality.

  • Story Points: 13 (Large)
  • Time Estimate: 3-4 weeks
  • Risk Level: Medium (Complex UI logic)

Additional Notes

Several additional notes provide guidance and recommendations for the implementation of the traces query builder. Consider using a query builder library like React Query Builder as a foundation. Ensure that the generated SQL is compatible with SignalDB's schema. Plan for extensibility as new trace fields are added. Consider integration with existing trace analysis tools. These notes provide valuable insights and best practices for building a successful traces query builder.

  • Consider using a query builder library like React Query Builder as a foundation
  • Ensure generated SQL is compatible with SignalDB's schema
  • Plan for extensibility as new trace fields are added
  • Consider integration with existing trace analysis tools