Merge branch 'main' of github.com:Baselime/docs

api/index.md

@@ -14,7 +14,7 @@ The Baselime API Integration enable the creation of appplications that can inter
 
 ## Getting Started
 
-To create an API integration, get in touch with the Baselime Team via email at [boris@baselime.io](mailto:boris@baselime.io).
+To create an API integration, get in touch with the Baselime Team via email at [techies@baselime.io](mailto:techies@baselime.io).
 
 Provide the following details:
 

oac/index.yml

@@ -1,4 +1,4 @@
 label: Observability as Code
-order: -3
+order: -4
 expanded: false
 icon: device-desktop

sending-data/platforms/opentelemetry.md

@@ -5,20 +5,27 @@ order: -4
 
 If your codebase is already instrumented with [OpenTelemetry](https://opentelemetry.io/), you can start sending your tracing data to Baselime today.
 
+
 Add the Baselime OpenTelemetry endpoint to your exporter:
 +++HTTP
-- Endpoint `https://otel.baselime.io/v1/`
+- Endpoint `otel.baselime.io/v1/`
 - Header: `x-api-key: <BASELIME_API_KEY>`
 - Header: `x-baselime-dataset: <YOUR_DATASET>` - the dataset to send the data to
+!!!
+Get your public Baselime API key in the [Baselime console](https://console.baselime.io).
+!!!
 +++gRPC
-- Endpoint `grpc://grpc.baselime.io:4317`
+- Endpoint `otel-ingest.baselime.io:4317`
 - Header: `api-key: <BASELIME_API_KEY>`
 - Header: `io.baselime.dataset: <YOUR_DATASET>` - the dataset to send the data to
-+++
-
 !!!
 Get your public Baselime API key in the [Baselime console](https://console.baselime.io).
 !!!
++++
+
+---
+Baselime supports [AWS PrivateLink](https://aws.amazon.com/privatelink/) for OTEL.
+[!ref icon="../../assets/images/logos/aws.svg"](../private-link.md)
 
 ---
 

sending-data/private-link.md

@@ -0,0 +1,131 @@
+---
+label: AWS PrivateLink for OpenTelemetry
+order: -1
+---
+
+# AWS PrivateLink for OpenTelemetry
+
+Baselime supports AWS PrivateLink, enabling you to securely send the data directly from your VPC to Baselime's platform without exposing your data to the public internet.
+
+!!!info
+Endpoint service name `com.amazonaws.vpce.eu-west-1.vpce-svc-03611009d136b2d65`
+!!!
+!!!warning
+Use endpoint `otel-ingest.baselime.io` instead of ~~`otel.baselime.io`~~ for both **HTTP** and **gRPC** when using PrivateLink
+!!!
+
+## How to set it up
++++ AWS Console
+* Navigate to "VPC" > "Endpoints" > "Create Endpoint"
+  * Select "PrivateLink" as the service category.
+  * Search for "todo" in the service name.
+  * Select the VPC and subnets you want to associate with the endpoint.
+  * Create a security group for your endpoint.
+    * Make sure the security group allows outbound traffic to CIDR of the VPC or specific subnet of that VPC you selected in the previous step.
+    * Make sure the security group allows inbound traffic from CIDR of the VPC or specific subnet of that VPC you selected in the previous step.
+  * Click on "Create Endpoint".
+* Wait for the endpoint to be created and accepted by Baselime.
+* Once accepted navigate to "VPC" > "Endpoints" and select the endpoint you just created.
+  * "Actions" > "Modify private DNS name" > Tick "Enable private DNS names" > "Save changes"
+
+![Creating VPC Endpoint](../assets/images/illustrations/sending-data/privateLink/private_link_console_1.png)
+
++++ CDK
+```typescript
+import * as ec2 from '@aws-cdk/aws-ec2';
+import * as cdk from '@aws-cdk/core';
+
+// Create or import your VPC
+const vpc = ec2.Vpc.fromLookup(this, "vpc", {
+    vpcId: "your-vpc-id",
+});
+
+// Create Security Group allowing inbound traffic from your VPC CIDR
+const sg = new ec2.SecurityGroup(this, "SecurityGroup", {
+  vpc,
+  allowAllOutbound: true,
+  description: "Security group for Baselime VPC Endpoint",
+  securityGroupName: "baselime-endpoint-sg",
+});
+sg.addIngressRule(ec2.Peer.ipv4(vpc.vpcCidrBlock), ec2.Port.tcp(443), "Allow HTTPS ingress");
+sg.addIngressRule(ec2.Peer.ipv4(vpc.vpcCidrBlock), ec2.Port.tcp(4317), "Allow gRPC ingress");
+
+
+
+// Create Endpoint for Baselime OTEL
+const endpoint = new ec2.InterfaceVpcEndpoint(this, 'Endpoint', {
+  service: new ec2.InterfaceVpcEndpointService('com.amazonaws.vpce.eu-west-1.vpce-svc-03611009d136b2d65', 443),
+  vpc: vpc,
+  subnets: {
+    subnetType: ec2.SubnetType.PRIVATE,
+  },
+  // Enable private DNS names once accepted on our side
+  privateDnsEnabled: hasBeenAccepted,
+  securityGroups: [sg],
+});
+```
+
++++ Terraform
+```terraform
+// Create or import your VPC
+
+// Create Security Group allowing inbound traffic from your VPC CIDR
+resource "aws_security_group" "baselime-otel" {
+  name        = "baselime-otel-endpoint-sg"
+  description = "Security group for Baselime OTEL VPC Endpoint"
+  vpc_id      = aws_vpc.main.id
+
+  ingress {
+    description = "Allow HTTPS ingress"
+    from_port   = 443
+    to_port     = 443
+    protocol    = "tcp"
+    cidr_blocks = [aws_vpc.main.cidr_block]
+  }
+
+  ingress {
+    description = "Allow gRPC ingress"
+    from_port   = 4317
+    to_port     = 4317
+    protocol    = "tcp"
+    cidr_blocks = [aws_vpc.main.cidr_block]
+  }
+
+  egress {
+    from_port   = 0
+    to_port     = 0
+    protocol    = "-1"
+    cidr_blocks = [aws_vpc.main.cidr_block]
+  }
+}
+
+resource "aws_vpc_endpoint" "baselime-otel" {
+  vpc_id              = aws_vpc.main.id
+  service_name        = "com.amazonaws.vpce.eu-west-1.vpce-svc-03611009d136b2d65"
+  vpc_endpoint_type   = "Interface"
+  security_group_ids  = [aws_security_group.baselime-otel.id]
+  private_dns_enabled = true
+  subnet_ids          = aws_subnet.private.*.id
+}
+```
++++
+
+After about 60 seconds all your traffic to `otel-ingest.baselime.io` will be routed through the PrivateLink.
+
+## How it works
+
+#### Without PrivateLink Endpoint
+When using Baselime without a PrivateLink endpoint, the DNS `otel-ingest.baslime.io` resolves to the public
+IP address of Baselime's platform. Your OTEL collector then sends the telemetry data to Baselime's platform
+over the public internet. Our endpoints are protected by TLS, so your data is encrypted in transit.
+![Sending data without PrivateLink](../assets/images/illustrations/sending-data/privateLink/without_private_link.png)
+
+#### With PrivateLink Endpoint
+When using Baselime with a PrivateLink endpoint, the DNS `otel-ingest.baslime.io` resolves the the private IP of a Network
+Interface that exists in your VPC, and the IP itself is one of from the CIDR range of your VPC. Your OTEL collector
+then sends the data to Baselime's platform over the private network. This means that your data never leaves AWS
+infrastructure, and is never exposed to the public internet.
+
+![Sending data with PrivateLink](../assets/images/illustrations/sending-data/privateLink/with_private_link.png)
+
+Read more about [AWS PrivateLink](https://aws.amazon.com/privatelink/) on the AWS website.

tux/faq.md

@@ -0,0 +1,49 @@
+---
+label: FAQ
+order: -3
+---
+
+# Tux FAQ
+
+---
+
+## General
+
+### Does Tux train on my telemetry data?
+
+No, Tux does not train on your telemetry data. Our third-party Language Model (LLM) providers also do not train on your specific data. Tux operates by following a specific process to generate answers to your queries:
+
+- **User query**: A user asks a question
+- **Code retrieval**: Baselime, performs a query to retrieve the relevant telemetry data to the user's question. During this process, strict permissions are enforced to ensure that only telemetry data for the user is retrieved
+- **Prompt to Language Model**: Baselime sends a prompt, and the telemetry data to a Language Model (LLM). This prompt provides the context for the LLM to generate a meaningful response
+- **Response to user**: The response generated by the LLM is then sent back to Tux and presented to the user
+
+This process ensures that Tux can provide helpful answers to your questions while respecting data privacy and security by not training on or retaining your specific telemetry data.
+
+### Is there a public facing Tux API?
+
+Currently, there is no public-facing Tux API available.
+
+### Does Tux require Baselime to function?
+
+Yes, Tux relies on Baselime for two essential functions:
+
+- It is used to retrieve context relevant to user queries
+- Baselime acts as a proxy for the LLM provider to facilitate the interaction between Tux and the LLM
+
+### Can Tux answer questions non-related to observability?
+
+Tux is an expert in cloud computing and observability. Tux is not designed to answer non-observability related questions or provide general information on topics outside of cloud computing or your applications.
+
+---
+
+## Third party dependencies
+
+### What third-party cloud services does Tux depend on?
+
+Tux relies on one primary third-party dependency, i.e., OpenAI API.
+
+### Can I use my own API keys?
+
+No, you cannot use your own API keys at this point.
+

tux/index.yml

@@ -0,0 +1,4 @@
+label: Tux
+order: -3
+expanded: false
+icon: hubot

tux/overview.md

@@ -0,0 +1,34 @@
+---
+label: Overview
+order: -1
+---
+
+# Tux
+
+---
+
+Tux is an AI assistant that resolves errors and performance issues in your applications. Tux understands your architecture by leveraging the powers of Baselime to gather context from your telemtry data, and enables you to resolve issues before they become problems.
+
+[!embed](https://www.youtube.com/watch?v=gcF1XW8aIuQ)
+
+Tux is your personal observability assistant, equiped with a deep understanding of:
+- Your telemetry data (logs, metrics, traces, wide events, etc.)
+- Your cloud architecture
+- Vast knowledge of open-source code
+
+---
+
+## Getting started
+
+You can start using Tux as soon as you start [sending data to Baselime](../sending-data/index.md).
+
+---
+
+## What data is collected and how is it used?
+
+Tux collects and uses data in the following ways:
+
+- **Prompts and responses**: When you use Tux, Baselime collects your prompts and responses to provide the service. Baselime does not use any of our data to train models.
+
+- **Usage data and feedback**: Baselime collects usage data and feedback to improve the developer experience.
+

tux/quickstart.md

@@ -0,0 +1,44 @@
+---
+label: Quickstart
+order: -2
+---
+
+# Tux Quickstart
+
+---
+
+Tux offers an interactive, chat-based interface that enables you ask questions about the behaviour of your applications.
+
+---
+
+## Key Features
+
+You can start a chat with Tux from one of:
+
+- A trace
+- A request
+- An error
+
+by clicking on the "Analysis" tab.
+
+![Analysis tav](../assets/images/illustrations/tux/tab.png)
+
+
+Tux starts analysing your data within the context you requested it. For example, if you ask for analysis of a trace, Tux will request the trace from Baselime, alongside the associated logs and span events, and also the known shape of your application architecture.
+
+![Example trace](../assets/images/illustrations/tux/trace.png)
+![Example analysis from Tux](../assets/images/illustrations/tux/analysis.png)
+
+Tux will use this data to give you comprehensive insights into the behaviour of your application, with actionable suggestions and code samples for fixing issues fast.
+
+From there you can ask subsequent questions to delve deeper into the analysis. Tux can run complex queries on your telemetry data and correlate with your application architecture.
+
+![Subsequent question with a query](../assets/images/illustrations/tux/follow.png)
+
+---
+
+## Example of Use
+
+- **Error Analysis**: Submit an error and ask Tux to identify the root cause. Follow up with questions about potential fixes.
+- **Performance Optimization**: Analyze a trace to understand performance bottlenecks and receive optimization suggestions.
+