cwielenb/CNCF-Dataset huggingface dataset:
Project: Netdata (Observability and Analysis / Observability)
File: 10s_ipv4_tcp_resets_received.md

TCP reset is an abrupt closure of the session. It causes the resources allocated to the connection to be immediately released and all other information about the connection is erased. The Netdata Agent monitors the average number of sent TCP RESETS over the last 10 seconds. This can indicate a port scan or that a service running on the system has crashed. Additionally, it's a result of a high number of sent TCP RESETS. Furthermore, it can also indicate a SYN reset attack. TCP uses a three-way handshake to establish a reliable connection. The connection is full duplex, and both sides synchronize (SYN) and acknowledge (ACK) each other. The exchange of these four flags is performed in three steps: SYN, SYN-ACK, and ACK. When an unexpected TCP packet arrives at a host, that host usually responds by sending a reset packet back on the same connection. A reset packet is one with no payload and with the RST bit set in the TCP header flags. There are a few circumstances in which a TCP packet might not be expected. The most common cases are: A TCP packet received on a port that is not open. An aborting connection Half opened connections Time wait assassination Listening endpoint Queue is Full A TCP Buffer Overflow Basically, A TCP Reset usually occurs when a system receives data which doesn't agree with its view of the connection. Use tcpdump to capture the traffic and use Wireshark to inspect the network packets. You must stop the capture after a certain observation period (60s up to 5 minutes). This command will create a dump file which can be interpreted by Wireshark that contains all the TCP packets with RST flag set. ``` tcpdump -i any 'tcp[tcpflags] & (tcp-rst) == (tcp-rst)' -s 65535 -w output.pcap ``` Counter measure on malicious TCP resets SYN cookie is a technique used to resist IP address spoofing attacks. In particular, the use of SYN cookies allows a server to avoid dropping connections when the SYN queue fills up. Enable SYN cookies in Linux: Check if your system has the SYN cookies service enabled. If the value is 1, then the service is enabled, if not proceed to step 2. ``` cat /proc/sys/net/ipv4/tcp_syncookies ``` Bump this `net.ipv4.tcp_syncookies=1` value under `/etc/sysctl.conf` Apply the configuration ``` sysctl -p ``` Enable SYN cookies in FreeBSD: Check if your system has the SYN cookies service enabled. If the value is 1, then the service is enabled, if not proceed to step 2. ``` sysctl net.inet.tcp.syncookies_only ``` Bump this `net.inet.tcp.syncookies_only=1` value under `/etc/sysctl.conf` Apply the configuration ``` /etc/rc.d/sysctl reload ``` The use of SYN cookies does not break any protocol specifications, and therefore should be compatible with all TCP implementations. There are, however, a few caveats that take effect when SYN cookies are in use.
Project: Parseable (Observability and Analysis / Observability)
File: pull_request_template.md

<!-- Thanks for trying to help us make Parseable be the best it can be! Please fill out as much of the following information as is possible (where relevant, and remove it when irrelevant) to help make the intention and scope of this PR clear in order to ease review. --> Fixes #XXXX. <!-- Replace XXXX with the id of the issue fixed in this PR. Remove this section if there is no corresponding issue. Don't reference the issue in the title of this pull-request. --> <!-- Describe the goal of this PR --> <!-- Describe the possible solutions and chosen one with the rationale. --> <!-- Describe key changes made in the patch. --> <hr> This PR has: [ ] been tested to ensure log ingestion and log query works. [ ] added comments explaining the "why" and the intent of the code wherever would not be obvious for an unfamiliar reader. [ ] added documentation for new or modified features or behaviors.
Project: Botkube (Observability and Analysis / Observability)
File: README.tpl.md

{{ template "chart.versionBadge" . }}{{ template "chart.typeBadge" . }}{{ template "chart.appVersionBadge" . }} {{ template "chart.description" . }} {{ template "chart.homepageLine" . }} {{ define "chart.maintainersTable" }} | Name | Email | | - | | {{- range .Maintainers }} | {{ .Name }} | {{ if .Email }}<{{ .Email }}>{{ end }} | {{- end }} {{ end }} {{ template "chart.maintainersSection" . }} {{ template "chart.sourcesSection" . }} {{ template "chart.requirementsSection" . }} {{ define "chart.valuesHeader" }}## Parameters {{ end }} {{ define "chart.valuesTable" }} | Key | Type | Default | Description | |--|||-| {{- range .Values }} | | {{ .Type }} | {{ if .Default }}{{ .Default }}{{ else }}{{ .AutoDefault }}{{ end }} | {{ if .Description }}{{ regexReplaceAllLiteral "# ." .Description }}{{ else }}{{ regexReplaceAllLiteral "# ." .AutoDescription "" }}{{ end }} | {{- end }} {{- end }} {{ template "chart.valuesSection" . }} AWS has introduced IAM Role for Service Accounts in order to provide fine-grained access. This is useful if you are looking to run Botkube inside an EKS cluster. For more details visit https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts.html. Annotate the Botkube Service Account as shown in the example below and add the necessary Trust Relationship to the corresponding Botkube role to get this working. ``` serviceAccount: annotations: eks.amazonaws.com/role-arn: "{rolearnto_assume}" ```
Project: Grafana Loki (Observability and Analysis / Observability)
File: labeldrop.md

title: labeldrop menuTitle: description: The 'labeldrop' Promtail pipeline stage. aliases: ../../../clients/promtail/stages/labeldrop/ weight: The labeldrop stage is an action stage that drops labels from the label set that is sent to Loki with the log entry. ```yaml labeldrop: [<string>] ... ``` For the given pipeline: ```yaml replace: expression: "(.*)" replace: "podname:{{ .kubernetespod_name }} {{ .Value }}" labeldrop: kubernetespodname ``` Given the following log line: ``` log message\n ``` The first stage would append the value of the`kubernetespodname` label into the beginning of the log line. The labeldrop stage would drop the label from being sent to Loki, and it would now be part of the log line instead.
Project: Thanos (Observability and Analysis / Observability)
File: use-cases.md

There are many great use cases of , we collect them here for others to refer to. Case add by If your want to build a horizontal scalable Prometheus for large kubernetes cluster monitoring, you can use + . is not another Prometheus compatible TSDB but a Prometheus sharding solution, which uses to generate special config file only contains part of targets assigned from for every Prometheus shard. is used for global data view, rules processing and long term storage capabilities. your can see usage detail . is working well to scrape basic metrics of cluster (kubelet, cadvisor, kube-state-metrics and node-exporter...) with following cluster size. Just use one Prometheus config file, without any `federation` or `hashmod`. 1k+ Nodes 60k+ Pods 100k+ Containers
Project: Vector (Observability and Analysis / Observability)
File: 2019-11-21-windows-support.md

date: "2020-03-31" title: "Windows Support Is Here!" description: "Bringing the performance and reliability of Vector to Windows" authors: ["binarylogic"] pr_numbers: [1205] release: "0.6.0" hideonrelease_notes: false badges: type: "new feature" domains: ["platforms"] platforms: ["windows"] aliases: ["/blog/windows-support"] We're excited to announce that Vector can now be installed on Windows! To get started, check out the or head over to the and download the appropriate Windows archive. Just like on Linux, installation on Windows is quick and easy. . It's important to point out that Vector's support for Windows is first-class. This is not a makeshift integration. Vector is written in , and Windows is a , meaning the same reliability and performance is brought to Windows as it is on Linux. Beyond Rust's tier 1 support for Windows, Vector does not require the installation of any dependencies. This makes installation as simple as copying the Vector binary onto your machine. There are no additional DLL files to install or environment changes required. In addition to installing Vector through a , we've included an that makes installing Vector even simpler. This can be done : ```bat msiexec /i vector-x64.msi /quiet ``` Or manually through the GUI installer: A core tenet of Vector is that users should own and control their data; this starts with data collection. So often we see organizations deploying many (sometimes 10 or more) data collectors just because upstream and downstream support is lacking. This is especially true when Windows environments are involved. This leads to fragmentation in the tooling used to build out these pipelines. Vector aims to solve this, and supporting Windows is a big step towards accomplishing that vision.
Project: Krkn (Observability and Analysis / Chaos Engineering)
File: cloud_setup.md

Supported Cloud Providers: NOTE: For clusters with AWS make sure is installed and properly using an AWS account NOTE: For clusters with GCP make sure is installed. A google service account is required to give proper authentication to GCP for node actions. See for how to create a service account. NOTE: A user with 'resourcemanager.projects.setIamPolicy' permission is required to grant project-level permissions to the service account. After creating the service account you will need to enable the account using the following: ```export GOOGLEAPPLICATIONCREDENTIALS="<serviceaccount.json>"``` NOTE: For clusters with Openstack Cloud, ensure to create and source the to set the OPENSTACK environment variables from the server where Kraken runs. NOTE: For Azure node killing scenarios, make sure is installed. You will also need to create a service principal and give it the correct access, see for creating the service principal and setting the proper permissions. To properly run the service principal requires Azure Active Directory Graph/Application.ReadWrite.OwnedBy api permission granted and User Access Administrator. Before running you will need to set the following: Login using ```az login``` ```export AZURETENANTID=<tenant_id>``` ```export AZURECLIENTSECRET=<client secret>``` ```export AZURECLIENTID=<client id>``` See the to install alicloud cli. ```export ALIBABAID=<accesskey_id>``` ```export ALIBABA_SECRET=<access key secret>``` ```export ALIBABAREGIONID=<region id>``` Refer to to get the region id for the region you are running on. Set cloud_type to either alibaba or alicloud in your node scenario yaml file. Set the following environment variables ```export VSPHEREIP=<vSphereclientIPaddress>``` ```export VSPHEREUSERNAME=<vSphereclient_username>``` ```export VSPHEREPASSWORD=<vSphereclient_password>``` These are the credentials that you would normally use to access the vSphere client. If no api key is set up with proper VPC resource permissions, use the following to create: Access group Service id with the following access With policy VPC Infrastructure Services* Resources = All Roles: Editor Administrator Operator Viewer API Key Set the following environment variables ```export IBMC_URL=https://<region>.iaas.cloud.ibm.com/v1``` ```export IBMCAPIKEY=<ibmcloudapi_key>```
Project: Vector (Observability and Analysis / Observability)
File: socket.md

title: Socket description: Collect logs using the client component_kind: source layout: component tags: ["socket", "component", "source", "logs"] aliases: ["/docs/reference/sources/tcp", "/docs/reference/sources/udp"] {{/* This doc is generated using: The template in layouts/docs/component.html The relevant CUE data in cue/reference/components/... */}}
Project: Checkmk (Observability and Analysis / Observability)
File: 16559.md

key | value | date | 2024-03-01T09:06:53+00:00 version | 2.3.0b1 class | fix edition | cre component | wato level | 1 compatible | yes The attributes "IPv4/6 address" are toggled based on the "IP address family" attribute in the host properties dialog. This behavior is now also applied to the "Additional IPv4/6 addresses" attributes.
Project: Graylog (Observability and Analysis / Observability)
File: TypeAheadInput.md

```js import createReactClass from 'create-react-class'; const TypeAheadInputExample = createReactClass({ getInitialState() { return { selectedNumber: undefined, }; }, onChange(event, selectedNumber) { this.setState({ selectedNumber: selectedNumber.number }); }, render() { const { selectedNumber } = this.state; const suggestions = ['One', 'Two', 'Three', 'Four', 'Five']; return ( <div> <p>Selected number: {selectedNumber === undefined ? 'none' : selectedNumber}</p> <TypeAheadInput id="typeahead-input" label="Numbers" displayKey="number" suggestionText="Select number" suggestions={suggestions} onSuggestionSelected={this.onChange} /> </div> ); }, }); <TypeAheadInputExample /> ```
Project: Graylog (Observability and Analysis / Observability)
File: SortableList.md

```js import createReactClass from 'create-react-class'; import SortableList from './SortableList' const SortableListExample = createReactClass({ getInitialState() { return { list: [ { id: 'one', title: 'One' }, { id: 'two', title: 'Two' }, { id: 'three', title: 'Three' }, { id: 'four', title: 'Four' }, { id: 'five', title: 'Five' }, ], sortedList: [], }; }, onSortList(nextSortedList) { this.setState({ sortedList: nextSortedList }); }, render() { const { list, sortedList } = this.state; return ( <div> <p>Sorted list: {sortedList.map(item => item.title).join(', ')}</p> <SortableList items={list} onMoveItem={this.onSortList} /> </div> ); }, }); <SortableListExample /> ```
Project: Graylog (Observability and Analysis / Observability)
File: SelectableList.md

```js import createReactClass from 'create-react-class'; const SelectableListExample = createReactClass({ getInitialState() { return { options: [ { label: 'Uno', value: 'one' }, { label: 'Dos', value: 'two' }, { label: 'Tres', value: 'three' }, { label: 'Cuatro', value: 'four' }, { label: 'Cinco', value: 'five' }, ], selectedOptions: [ { label: 'Cuatro', value: 'four' }, { label: 'Cuatro', value: 'four' }, ], }; }, onChange(nextSelectedOptions) { this.setState({ selectedOptions: nextSelectedOptions }); }, render() { const { options, selectedOptions } = this.state; return ( <SelectableList selectedOptionsType="object" options={options} onChange={this.onChange} selectedOptions={selectedOptions} /> ); }, }); <SelectableListExample /> ```
Project: Teletrace (Observability and Analysis / Observability)
File: glossary.md

Terminology you may or may not be familiar with used by the Teletrace project. The process of gathering information about the runtime and execution to enable troubleshooting and investigation. Usually this process involves added specialized code (in our context the OpenTelemetry SDK) to the application in order to generate the needed information. A language specific SDK to collect information about a specific part of an application, an instrumentation library can be arbitrarily general or specific, for example: collect information about a generic python function collect information about a node.js express server Short for OpenTelemetry Protocol, this is the transport protocol used by OpenTelemetry instrumentation libraries. A CNCF project that aims to standardize generating, collecting, and exporting telemetry data using instrumentation libraries for a wide variety of languages. An application built by the OpenTelemetry community to collect telemetry data from instrumented applications, or other OpenTelemtry collectors. The collector supports a wide variety of input formats, possible processors, and a wide variety of exporters, and can be further extended using plugins. A custom build of the OpenTelemetry Collector which can change the bundled plugins (add new ones / remove unused ones) is called a Distro. Captures information about the entity for which telemetry is recorded. For example, a process producing telemetry that is running in a container on Kubernetes has a pod name, it is in a namespace and possibly is part of a deployment which also has a name. All three of these attributes can be included in the Resource and applied to any data source. A span represents a single operation within a trace, it contains a start and end time, a unique identifier, the name of the operation, and any relevant metadata in its Attributes. Spans can also have parent-child relationships to represent the hierarchical structure of a distributed system. A key-value collection of metadata captured on a given Span, Attributes usually follow OpenTelemetry's for naming, but can have any arbitrary name. A trace is a collection of spans that represent the path of a request through the system. Each span contains information about a particular operation, including its start and end time, the service that performed the operation, and any relevant metadata, such as the request headers and response status code. The process of tracing the progression of a single request, called a Trace, as it is handled by services that make up an application. A Distributed Trace transverses process, network and security boundaries.
Project: Checkmk (Observability and Analysis / Observability)
File: 16508.md

key | value | compatible | yes version | 2.4.0b1 date | 2024-03-07T16:34:41+00:00 level | 1 class | feature component | wato edition | cre The LDAP connection test does not give enough information about which DN configured results in an error. This werk adds identifying information for the DN to the error message to make it easier to identify the problem.
Project: Checkmk (Observability and Analysis / Observability)
File: 16448.md

key | value | compatible | yes version | 2.4.0b1 date | 2024-02-05T11:36:15+00:00 level | 1 class | fix component | liveproxy edition | cee When the liveproxyd starts or ends at a particular time TS and remote inventory data is written between TS and \<TS+1 then it's not synced.
Project: Krkn (Observability and Analysis / Chaos Engineering)
File: memory_hog.md

This scenario is based on the arcaflow plugin. The purpose of this scenario is to create Virtual Memory pressure on a particular node of the Kubernetes/OpenShift cluster for a time span. To enable this plugin add the pointer to the scenario input file `scenarios/arcaflow/memory-hog/input.yaml` as described in the Usage section. This scenario takes a list of objects named `input_list` with the following properties: kubeconfig : string the kubeconfig needed by the deployer to deploy the sysbench plugin in the target cluster namespace : string the namespace where the scenario container will be deployed Note: this parameter will be automatically filled by kraken if the `kubeconfig_path` property is correctly set node_selector : key-value map the node label that will be used as `nodeSelector` by the pod to target a specific cluster node duration : string stop stress test after N seconds. One can also specify the units of time in seconds, minutes, hours, days or years with the suffix s, m, h, d or y. vm_bytes : string N bytes per vm process or percentage of memory used (using the % symbol). The size can be expressed in units of Bytes, KBytes, MBytes and GBytes using the suffix b, k, m or g. vm_workers : int Number of VM stressors to be run (0 means 1 stressor per CPU) To perform several load tests in the same run simultaneously (eg. stress two or more nodes in the same run) add another item to the `inputlist` with the same properties (and eventually different values eg. different nodeselectors to schedule the pod on different nodes). To reduce (or increase) the parallelism change the value `parallelism` in `workload.yaml` file
Project: Inspektor Gadget (Observability and Analysis / Observability)
File: network.md

title: 'Using trace network' weight: 10 The network gadget monitors the network activity in the specified pods and records the list of TCP connections and UDP streams. Start the gadget: ```bash $ kubectl gadget trace network -n demo ``` Generate some network traffic: ```bash $ kubectl run -ti -n demo --image=busybox --restart=Never shell -- wget 1.1.1.1.nip.io ``` Observe the results: ``` K8S.NODE K8S.NAMESPACE K8S.POD TYPE PROTO PORT REMOTE minikube demo shell OUTGOING UDP 53 svc kube-system/kube-dns minikube demo shell OUTGOING TCP 80 endpoint 1.1.1.1 ``` Let's start the gadget in a terminal: ```bash $ sudo ig trace network -c test-container RUNTIME.CONTAINERNAME TYPE PROTO PORT REMOTE ``` Run a container that generates TCP and UDP network traffic: ```bash $ docker run --name test-container -ti --rm busybox /bin/sh -c "wget http://1.1.1.1.nip.io/" ``` The tools will show the network activity: ```bash $ sudo ig trace network -c test-container RUNTIME.CONTAINERNAME TYPE PROTO PORT REMOTE demo OUTGOING UDP 53 192.168.67.1 demo OUTGOING TCP 80 1.1.1.1 ```
Project: Netdata (Observability and Analysis / Observability)
File: zfs_pool_state_crit.md

The `zfspoolstate_crit` alert indicates that your ZFS pool is faulted or unavailable, which can cause access and data loss problems. It is important to identify the current state of the pool and take corrective actions to remedy the situation. Check the current ZFS pool state Run the `zpool status` command to view the status of all ZFS pools: ``` zpool status ``` This will display the pool state, device states, and any errors that occurred. Take note of any devices that are in DEGRADED, FAULTED, UNAVAIL, or OFFLINE states. Assess the problematic devices Check for any hardware issues or file system errors on the affected devices. For example, if a device is FAULTED due to a hardware failure, replace the device. If a device is UNAVAIL or OFFLINE, check the connectivity and make sure it's properly accessible. Repair the pool Depending on the root cause of the problem, you may need to take different actions: Repair file system errors using the `zpool scrub` command. This will initiate a scrub, which attempts to fix any errors in the pool. ``` zpool scrub [pool_name] ``` Replace a failed device using the `zpool replace` command. For example, if you have a new device `/dev/sdb` that will replace `/dev/sda`, run the following command: ``` zpool replace [pool_name] /dev/sda /dev/sdb ``` Bring an OFFLINE device back ONLINE using the `zpool online` command: ``` zpool online [pool_name] [device] ``` Note: Make sure to replace `[pool_name]` and `[device]` with the appropriate values for your system. Verify the pool state After taking the necessary corrective actions, run the `zpool status` command again to verify that the pool state has improved. Monitor pool health Continuously monitor the health of your ZFS pools to avoid future issues. Consider setting up periodic scrubs and reviewing system logs to catch any hardware or file system errors.
Project: Zabbix (Observability and Analysis / Observability)
File: SECURITY.md

Duo is committed to providing secure software to all our customers and users. We take all security concerns seriously and ask that any disclosures be handled responsibly. Please do not use Github issues or pull requests to report security vulnerabilities. If you believe you have found a security vulnerability in Duo software, please follow our response process described at https://duo.com/support/security-and-reliability/security-response.