cwielenb/CNCF-Dataset huggingface dataset:
Project: Promscale (Observability and Analysis / Observability)
File: PromscaleQueryHighErrorRate.md

Promscale is experiencing high error rates while evaluating queries Frequent query evaluation failures. Alerts based on data retrieved via Promscale may not be accurate Check query errors in the grafana dashboard in Errors (HTTP) in the Query row. If the panel show high error rate, go to for mitigation steps Check if your database is reachable and accepting queries by running a simple query `select time, value from promscalequeryrequests_total limit 1;` Go to Grafana and open Promscale dashboard. Go to database health panel and see if it shows high error rates. If the error rate is not high, then the alerts are specific to the queries executed. Otherwise, see for mitigation Check database logs for errors Go to for mitigation steps Ensure database has proper resources Check Postgres logs and fix errors if any Enable prometheus query log using this Check the query log for failing PromQL queries Check the PromQL query syntax that is failing your grafana dashboard or recording rules Run the above PromQL query and verify if it can execute in a reasonable time
Project: Vector (Observability and Analysis / Observability)
File: helm.md

title: Install Vector using Helm short: Helm weight: 3 [Helm] is a package manager for Kubernetes that facilitates the deployment and management of applications and services on Kubernetes clusters. This page covers installing and managing the Vector chart. If you haven't already, start by adding the Vector repo: ```shell helm repo add vector https://helm.vector.dev helm repo update ``` The Vector [Agent] lets you collect data from your [sources] and then deliver it to a variety of destinations with [sinks]. To check available Helm chart configuration options: ```shell helm show values vector/vector ``` This example configuration file deploys Vector as an Agent, the full default configuration can be found . For more information about configuration options, see the [configuration] docs page. ```yaml cat <<-'VALUES' > values.yaml role: Agent VALUES ``` Once you add the Vector Helm repo, and added a Vector configuration file, install the Vector Agent: ```shell helm install vector vector/vector \ --namespace vector \ --create-namespace \ --values values.yaml ``` Or to update the Vector Agent: ```shell helm repo update && \ helm upgrade vector vector/vector \ --namespace vector \ --reuse-values ``` The Vector [Aggregator] lets you [transform] and ship data collected by other agents. For example, it can insure that the data you are collecting is scrubbed of sensitive information, properly formatted for downstream consumers, sampled to reduce volume, and more. To check available Helm chart configuration options: ```shell helm show values vector/vector ``` The chart deploys an Aggregator by default, the full configuration can be found . For more information about configuration options, see the [Configuration] docs page. Once you add the Vector Helm repo, install the Vector Aggregator: ```shell helm install vector vector/vector \ --namespace vector \ --create-namespace ``` Or to update the Vector Aggregator: ```shell helm repo update && \ helm upgrade vector vector/vector \ --namespace vector \ --reuse-values ``` To uninstall the Vector helm chart: ```shell helm uninstall vector --namespace vector ``` If you'd like to clone the charts, file an Issue or submit a Pull Request, please take a look at . {{< jump "/docs/administration/management" "helm" >}}
Project: Netdata (Observability and Analysis / Observability)
File: postgres_table_toast_cache_io_ratio.md

This alert monitors the TOAST hit ratio (i.e., cached I/O efficiency) of a specific table in a PostgreSQL database. If the hit ratio is low, it indicates that the database is performing more disk I/O operations than needed for the table, which may cause performance issues. TOAST (The Oversized-Attribute Storage Technique) is a mechanism in PostgreSQL to efficiently store large data items. It allows you to store large values (such as text or binary data) in a separate table, improving the overall performance of the database. The hit ratio is the percentage of cache hits (successful reads from the cache) compared to total cache requests (hits + misses). A high hit ratio indicates that the data frequently needed is stored in the cache, resulting in fewer disk I/O operations and better performance. Verify if the alert is accurate by checking the TOAST hit ratio in the affected PostgreSQL system. You can use the following query to retrieve the hit ratio of a specific table: ```sql SELECT CASE WHEN blkshit + blksread = 0 THEN 0 ELSE 100 * blkshit / (blkshit + blks_read) END as cachehitratio FROM pgstatiouser_tables WHERE schemaname = 'yourschema' AND relname = 'yourtable'; ``` Replace `yourschema` and `yourtable` with the appropriate values. Examine the table's indexes, and consider creating new indexes to improve query performance. Be cautious when creating indexes, as too many can negatively impact performance. Analyze the table's read and write patterns to determine if you need to adjust the cache settings, such as increasing the `shared_buffers` configuration value. Inspect the application's queries to see if any can be optimized to improve performance. For example, use EXPLAIN ANALYZE to determine if the queries are using indexes effectively. Monitor overall PostgreSQL performance with tools like pgstatstatements or pgstatactivity to identify potential bottlenecks and areas for improvement.
Project: Falcon (Observability and Analysis / Observability)
File: 2017-01-01-expression_update.md

category: Expression apiurl: '/api/v1/expression' title: "Update Expression" type: 'PUT' sample_doc: 'expression.html' layout: default Required ```{ "right_value": "0", "priority": 2, "pause": 1, "op": "==", "note": "this is a test exp", "max_step": 3, "id": 5, "func": "all(#3)", "expression": "each(metric=agent.alive endpoint=docker-agent)", "action": { "url": "http://localhost:1234/callback", "uic": [ "test", "test2" ], "callback": 0, "beforecallbacksms": 1, "beforecallbackmail": 0, "aftercallbacksms": 1, "aftercallbackmail": 0 } }``` ```Status: 200``` ```{"message":"expression:5 has been updated"}```
Project: Netdata (Observability and Analysis / Observability)
File: systemd_socket_unit_failed_state.md

The `systemdsocketunitfailedstate` alert is triggered when a `systemd` socket unit on your Linux server enters a failed state. This could indicate issues with the services that depend on these socket units, impacting their functionality or performance. `systemd` is the system and service manager for modern Linux systems. It initializes and manages the services on the system, ensuring a smooth boot process and operation. A socket unit is a special kind of `systemd` unit that encapsulates local and remote IPC (Inter-process communication) sockets. They are defined by .socket files and are used to start and manage services automatically when incoming traffic is received on socket addresses managed by the socket unit. Identify the failed socket unit(s): To list all the socket units with their current state, run: ``` systemctl --state=failed --type=socket ``` This command will display the socket units in a failed state. Check the status of the failed socket unit: To view the detailed status of a particular failed socket unit, use: ``` systemctl status yoursocketunit.socket ``` Replace `yoursocketunit` with the name of the failed socket unit you're investigating. This will provide more information about the socket unit and possible error messages. Examine the logs: Check the logs for any errors or issues related to the failed socket unit: ``` journalctl -u yoursocketunit.socket ``` Replace `yoursocketunit` with the name of the failed socket unit you're investigating. This will display relevant logs for the socket unit. Restart the failed socket unit: Once the issue is identified and resolved, you can attempt to restart the failed socket unit: ``` systemctl restart yoursocketunit.socket ``` Replace `yoursocketunit` with the name of the failed socket unit you're investigating. This will attempt to restart the socket unit and put it into an active state. Monitor the socket unit: After restarting the socket unit, monitor its status to ensure it stays active and operational: ``` systemctl status yoursocketunit.socket ``` Replace `yoursocketunit` with the name of the failed socket unit you're investigating. Verify that the socket unit remains in an active state.
Project: Grafana Tempo (Observability and Analysis / Observability)
File: gcs.md

title: Google Cloud Storage description: Learn about Google Cloud Storage permissions for Tempo. aliases: ../../configuration/gcs/ # /docs/tempo/<TEMPO_VERSION>/configuration/gcs/ For configuration options, check the storage section on the page. The following authentication methods are supported: Google Cloud Platform environment variable `GOOGLEAPPLICATIONCREDENTIALS` Google Cloud Platform Workload Identity The `(service-)account` that will communicate towards GCS should be assigned to the bucket which will receive the traces and should have the following IAM policies within the bucket: `storage.objects.create` `storage.objects.delete` `storage.objects.get` `storage.buckets.get` `storage.objects.list`
Project: Elastic (Observability and Analysis / Observability)
File: coalesce.md

<!-- This is generated by ESQL's AbstractFunctionTestCase. Do no edit it. See ../README.md for how to regenerate it. --> Returns the first of its arguments that is not null. If all arguments are null, it returns `null`. ``` ROW a=null, b="b" | EVAL COALESCE(a, b) ```
Project: Netdata (Observability and Analysis / Observability)
File: splunk_victorops.md

<!--startmeta customediturl: "https://github.com/netdata/netdata/edit/master/integrations/cloud-notifications/integrations/splunk_victorops.md" meta_yaml: "https://github.com/netdata/netdata/edit/master/integrations/cloud-notifications/metadata.yaml" sidebar_label: "Splunk VictorOps" learn_status: "Published" learnrelpath: "Alerts & Notifications/Notifications/Centralized Cloud Notifications" message: "DO NOT EDIT THIS FILE DIRECTLY, IT IS GENERATED BY THE NOTIFICATION'S metadata.yaml FILE" endmeta--> <img src="https://netdata.cloud/img/victorops.svg" width="150"/> From the Cloud interface, you can manage your space's notification settings and from there you can add a specific configuration to get notifications delivered on Splunk On-Call/VictorOps. <img src="https://img.shields.io/badge/maintained%20by-Netdata-%2300ab44" /> To add Splunk VictorOps notification (also known as Splunk On-Call) you need: A Netdata Cloud account Access to the space as an Admin The Space needs to be on a paid plan Destination URL for your Splunk VictorOps REST Endpoint Integration. Refer to the for detailed instructions. Click on the Space settings cog (located above your profile icon) Click on the Notification tab Click on the + Add configuration button (near the top-right corner of your screen) On the Splunk VictorOps card click on + Add A modal will be presented to you to enter the required details to enable the configuration: Notification settings are Netdata specific settings Configuration name - provide a descriptive name for your configuration to easily identify it. Rooms - select the nodes or areas of your infrastructure you want to receive notifications about. Notification - choose the type of notifications you want to receive: All Alerts and unreachable, All Alerts, Critical only. Integration configuration are the specific notification integration required settings, which vary by notification method. For Splunk VictorOps: Destination URL - The URL provided by VictorOps of your REST endpoint.
Project: Netdata (Observability and Analysis / Observability)
File: 10min_dbengine_global_flushing_warnings.md

The Database Engine works like a traditional database. It dedicates a certain amount of RAM to data caching and indexing, while the rest of the data resides compressed on disk. Unlike other memory modes, the amount of historical metrics stored is based on the amount of disk space you allocate and the effective compression ratio, not a fixed number of metrics collected. By using both RAM and disk space, the database engine allows for long-term storage of per-second metrics inside of the Netdata Agent itself. Netdata monitors the number of times when `dbengine` dirty pages were over 50% of the instance page cache in the last 10 minutes. In this situation, the metric data are at risk of not being stored in the database. To remedy this issue, reduce disk load or use faster disks. This alert is triggered in warn state when the number of `dbengine` dirty pages which were over 50% of the instance is greater than 0.
Project: Grafana Tempo (Observability and Analysis / Observability)
File: serverless_aws.md

title: Search with AWS Lambda description: Learn how to set up AWS Lambda for serverless backend search. alias: /docs/tempo/latest/operations/backendsearch/serverlessaws/ /docs/tempo/latest/operations/serverless_aws/ weight: 95 This document explains how to set up AWS Lambda for serverless backend search. Read for more guidance on configuration options for backend search. Build the code package: ```bash cd ./cmd/tempo-serverless && make build-lambda-zip ``` This will create a ZIP file containing the binary required for the function. The file name will be of the form: `./lambda/tempo-<branch name>-<commit hash>.zip`. Here is an example of that name: ```bash ls lambda/*.zip lambda/tempo-serverless-backend-search-297172a.zip ``` Provision an S3 bucket. Copy the ZIP file into your bucket. ``` aws s3 cp lambda/tempo-serverless-backend-search-297172a.zip gs://<newly provisioned gcs bucket> ``` Provision the Lambda. For a Lambda function to be invoked via HTTP, we also need to create an ALB and some other resources. This example uses Terraform and only includes the function definition. Additionally, you will need a VPC, security groups, IAM roles, an ALB, target groups, etc., but that is beyond the scope of this guide. ``` locals { // this can be increased if you would like to use multiple functions count = 1 } resource "awslambdafunction" "lambda" { count = local.count function_name = "${local.name}-${count.index}" description = "${local.name}-${count.index}" role = <arn of appropriate role> handler = "main" runtime = "go1.x" timeout = "60" s3_key = "tempo-serverless-backend-search-297172a.zip" s3_bucket = <S3 bucket created above> memory_size = 1769 # 1 vcpu vpc_config { subnet_ids = <appropriate subnets> securitygroupids = [<appropriate security groups>] } environment { variables = { "TEMPOS3BUCKET" = "<S3 bucket name backing your Tempo instance>" "TEMPO_BACKEND" = "s3" "TEMPOS3HEDGEREQUESTSAT" = "400ms" "TEMPOS3HEDGEREQUESTSUP_TO" = "2" "TEMPOS3ENDPOINT" = "s3.dualstack.us-east-2.amazonaws.com" } } } ``` Add the hostname of the newly-created ALB to the querier config: ``` querier: search: external_endpoints: http://<alb dns hostname> ```
Project: Headlamp (Observability and Analysis / Observability)
File: lib_k8s_crd.CRClassArgs.md

title: "Interface: CRClassArgs" linkTitle: "CRClassArgs" slug: "libk8scrd.CRClassArgs" .CRClassArgs apiInfo: { `group`: `string` ; `version`: `string` }[] _ isNamespaced: `boolean` _ pluralName: `string` _ singularName: `string`
Project: Opstrace (Observability and Analysis / Observability)
File: managing-users.md

An administrator can provision and manage "users" in Opstrace. A "user" represents a human interacting with the Opstrace UI in an interactive session; the authentication proof is meant to be presented by a browser. An administrator can then* provide fine-grained permissions for what users can and cannot do. \* This is a roadmap item; all users are currently granted the ADMIN role Adding a user is easy. Removing a user is easy.
Project: Litmus (Observability and Analysis / Chaos Engineering)
File: containersolutions.md

We bring culture, strategy, and technology together to make sure your Cloud Native transformation is done right. We have used Litmus to build out Chaos Engineering platforms with some of our large E-Commerce customers to improve resilience for big sales periods such as Black Friday. We looked into quite a few tools, and Litmus provided us with the flexibility we needed, whilst bootstrapping many of the components we would have to write ourselves. We also used Litmus Chaos experiments when discussing some of our customer's architecture constraints, and showing them real world cases of how to make Kubernetes more resilient. One concrete use case was our customer wanting to build a cluster per app, whilst we wanted to build bigger clusters for easier management. We would use Litmus to show what application failure looks like on one part of the cluster, and show global resilience in their cluster when this happens. The Litmus community and *product have been a great addition to our tool stack, and provided many benefits for us.
Project: Grafana Mimir (Observability and Analysis / Observability)
File: migrate-query-scheduler-from-dns-to-ring-based-service-discovery.md

aliases: ../../operators-guide/deploy-grafana-mimir/jsonnet/migrate-query-scheduler-from-dns-to-ring-based-service-discovery/ description: Learn how to migrate query-scheduler from DNS-based to ring-based service discovery menuTitle: Migrate query-scheduler to ring-based service discovery title: Migrate query-scheduler from DNS-based to ring-based service discovery weight: 50 The query-scheduler supports two service discovery mechanisms: To migrate the query-scheduler from DNS-based to ring-based service discovery when your Mimir cluster is deployed using Jsonnet: Configure the query-scheduler instances to join a ring, but keep the querier and query-frontend instances discovering query-schedulers via DNS: ```jsonnet { _config+:: { queryschedulerservicediscoverymode: 'ring', queryschedulerservicediscoveryringreadpath_enabled: false, } } ``` Wait until query-scheduler changes have been applied. Open the page and ensure all query-scheduler instances are registered to the ring. Configure query-frontend and querier instances to discover query-schedulers via the ring: ```jsonnet { _config+:: { queryschedulerservicediscoverymode: 'ring', queryschedulerservicediscoveryringreadpath_enabled: true, } } ```
Project: Grafana Mimir (Observability and Analysis / Observability)
File: configure-grafana-enterprise-metrics.md

title: "Configure Grafana Enterprise Metrics" menuTitle: "Enterprise Metrics" description: "Learn how to enable Grafana Enterprise Metrics." From the Grafana Helm chart point of view, the main differences between Grafana Mimir and Grafana Enterprise Metrics (GEM) are: GEM requires a valid license. Instead of using NGINX as the router of requests to internal components, GEM deploys its own enterprise gateway component that authenticates and routes requests. More mandatory and optional components are available, such as the admin API and various proxies. Follow the instructions and . It is recommended, but not required to use the same name as the Helm release. For example if the cluster name is `mygem`, you'd install the chart with `helm install mygem grafana/mimir-distributed`. Follow the instruction in to acquire a license. There are two options: Provide the license as a value for the `license.contents` Helm value. Either on the command line for the `helm` command as `--set-file 'license.contents=./license.jwt'` or by writing the contents into your custom values: ```yaml license: contents: "iyJhbGci..." ``` Store the license in a Kubernetes . In this case use the following custom values: ```yaml license: external: true secretName: <name-of-your-secret> ``` Add the following value to your custom values: ```yaml enterprise: enabled: true ``` If you want to use a different cluster name for the license and a different Helm release name on the command line, also set: ```yaml mimir: structuredConfig: cluster_name: <cluster-name-in-license> ```
Project: Elastic (Observability and Analysis / Observability)
File: mv_sort.md

<!-- This is generated by ESQL's AbstractFunctionTestCase. Do no edit it. See ../README.md for how to regenerate it. --> Sorts a multivalued field in lexicographical order. ``` ROW a = [4, 2, -3, 2] | EVAL sa = mvsort(a), sd = mvsort(a, "DESC") ```
Project: Cortex (Observability and Analysis / Observability)
File: RELEASE.md

The `klog` is released on an as-needed basis. The process is as follows: An issue is proposing a new release with a changelog since the last release All must LGTM this release An OWNER runs `git tag -s $VERSION` and inserts the changelog and pushes the tag with `git push $VERSION` The release issue is closed An announcement email is sent to `kubernetes-dev@googlegroups.com` with the subject `[ANNOUNCE] kubernetes-template-project $VERSION is released`
Project: Netdata (Observability and Analysis / Observability)
File: disk_inode_usage.md

This alarm presents the percentage of used `inodes` storage of a particular disk. The number of `inodes` indicates the number of files and folders you have. An `inode` is a data structure, containing metadata about a file. All filenames are internally mapped to respective `inode` numbers, so if you have a lot of files, it means there are a lot of `inodes`. If the alarm is raised, it means that your storage device is running out of `inode` space. Each disk has a particular limitation on the amount of `inodes` it can store, determined by its size. Many modern filesystems use dynamically allocated `inodes` instead of a static table. These should not be presented on the charts associated with this alarm, and should not ever trigger it. If such a filesystem does trigger this alarm, and it's constantly reporting max `inode` usage, it's probably a bug in the filesystem driver. Some such filesystems incorrectly report having max `inode` count when they should not because they have no max limit, and in turn they trigger a false positive alarm. Clear cache files or delete unnecessary files and folders To reduce the amount of how many `inodes` you store currently, you can clear your cache, trash any unnecessary files and folders in your system. We strongly suggest that you practice a high degree of caution when cleaning up drives, and removing files, make sure that you are certain that you delete only unnecessary files.