web/src/plugins/logs/JsonPreview.vue (2)

374-382: Enhance error notification with error code

The error notification implementation has been improved but could be enhanced further.

Consider adding error codes for better error tracking:

-          $q.notify({
-            message:
-              err.response?.data?.message || "Failed to get the Original data",
-            color: "negative",
-            position: "bottom",
-            timeout: 1500,
-          });
+          $q.notify({
+            message: `Error [OZ-${err.response?.status || 500}]: ${
+              err.response?.data?.message || "Failed to get the Original data"
+            }`,
+            color: "negative",
+            position: "bottom",
+            timeout: 1500,
+          });

---

434-445: Consider memoizing filtered tabs computation

The filteredTabs computed property contains multiple conditions that could impact performance if recomputed frequently.

Consider breaking down the conditions into separate computed properties for better maintainability and performance:

-    const filteredTabs = computed(() => {
-      return tabs.filter((tab) => {
-        if (
-          props.value._o2_id == undefined ||
-          searchAggData.hasAggregation ||
-          searchObj.data.stream.selectedStream.length > 1
-        ) {
-          return false;
-        }
-        return true;
-      });
-    });
+    const isValidForUnflattenedView = computed(() => {
+      return (
+        props.value._o2_id != undefined &&
+        !searchAggData.hasAggregation &&
+        searchObj.data.stream.selectedStream.length === 1
+      );
+    });
+
+    const filteredTabs = computed(() => {
+      return isValidForUnflattenedView.value ? tabs : [];
+    });

web/src/composables/useLogs.ts (5)

Line range hint 4028-4039: Fix variable scoping issue in getRegionInfo

The variable regionObj is declared outside the for...in loop and is reused in each iteration. This leads to all elements in clusterData referencing the same object due to JavaScript's object reference behavior. Declare regionObj within the loop to ensure each element is a distinct object.

Apply this diff to fix the issue:

 const getRegionInfo = () => {
   searchService.get_regions().then((res) => {
     const clusterData = [];
-    let regionObj: any = {};
     const apiData = res.data;
     for (const region in apiData) {
+      let regionObj: any = {
+        label: region,
+        children: [],
+      };
-      regionObj = {
-        label: region,
-        children: [],
-      };
       for (const cluster of apiData[region]) {
         regionObj.children.push({ label: cluster });
       }
       clusterData.push(regionObj);
     }

     store.dispatch("setRegionInfo", clusterData);
   });
 };

---

Line range hint 4031-4038: Escape streamName to prevent regex injection in quoteTableNameDirectly

The function quoteTableNameDirectly uses new RegExp with streamName, which may contain special regex characters. This could lead to unintended matches or security vulnerabilities. Consider escaping streamName before using it in the regular expression.

Apply this diff to fix the issue:

 function quoteTableNameDirectly(sql: string, streamName: string) {
+  const escapedStreamName = streamName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const regex = new RegExp(`FROM\\s+${streamName}`, "gi");
+  const regex = new RegExp(`FROM\\s+${escapedStreamName}`, "gi");
   const modifiedSql = sql.replace(regex, `FROM "${streamName}"`);
   return modifiedSql;
 }

---

Line range hint 3994-3999: Use Set for efficient trace ID management

Currently, searchRequestTraceIds is an array, and methods addTraceId and removeTraceId perform linear searches, which can be inefficient with large numbers of trace IDs. Using a Set will improve performance with constant-time insertion and deletion.

Apply this diff to refactor:

- searchObj.data.searchRequestTraceIds = [];
+ searchObj.data.searchRequestTraceIds = new Set<string>();

 const addTraceId = (traceId: string) => {
-  if (searchObj.data.searchRequestTraceIds.includes(traceId)) {
+  if (searchObj.data.searchRequestTraceIds.has(traceId)) {
     return;
   }
-  searchObj.data.searchRequestTraceIds.push(traceId);
+  searchObj.data.searchRequestTraceIds.add(traceId);
 };

 const removeTraceId = (traceId: string) => {
-  searchObj.data.searchRequestTraceIds =
-    searchObj.data.searchRequestTraceIds.filter(
-      (id: string) => id !== traceId,
-    );
+  searchObj.data.searchRequestTraceIds.delete(traceId);
 };

---

Line range hint 2805-3184: Refactor extractFields function to improve readability

The extractFields function is lengthy and complex, spanning over 300 lines. This makes it difficult to maintain and understand. Consider breaking it down into smaller, reusable helper functions to enhance readability and maintainability.

---

Line range hint 3460-3480: Ensure intervals are cleared properly in refreshData

In refreshData, when searchObj.meta.refreshInterval is zero or negative, clearInterval is called without checking if store.state.refreshIntervalID is defined. This could lead to unexpected behavior. Consider adding a check before calling clearInterval.

Apply this diff to improve error handling:

 else {
-  clearInterval(store.state.refreshIntervalID);
+  if (store.state.refreshIntervalID) {
+    clearInterval(store.state.refreshIntervalID);
+    store.dispatch("setRefreshIntervalID", null);
+  }
 }

Configuration used: CodeRabbit UI
Review profile: CHILL

web/src/components/ingestion/recommended/LinuxConfig.vue (1)

56-56: Consider adding error handling for undefined values.

While the formatting looks good, the template literal could fail if props.currUserEmail or store.state.organizationData.organizationPasscode are undefined. Consider adding null checks or default values.

-    `${props.currUserEmail}:${store.state.organizationData.organizationPasscode}`,
+    `${props.currUserEmail || ''}:${store.state.organizationData?.organizationPasscode || ''}`,

web/src/components/ingestion/recommended/KubernetesConfig.vue (3)

Line range hint 97-138: Consider improving list indentation for better readability.

While the conversion to unordered lists and Tailwind styling is good, the nested list indentation could be more consistent. Consider adjusting the indentation of nested <ul> elements to better reflect the hierarchy.

-          <ul class="tw-list-disc tw-ml-5">
+            <ul class="tw-list-disc tw-ml-5">

---

222-222: Remove empty style block.

The style block is empty and includes SCSS support that isn't being used. Consider removing it entirely unless you plan to add styles in the near future.

-<style scoped lang="scss"></style>

---

Looking at the code, I can now generate the final response since I have found that the component actually has the necessary code to generate the Basic Auth token but doesn't use it in the helm commands.

Basic Auth token placeholder should be replaced with computed accessKey

The component already computes the correct Basic Auth token using the accessKey computed property, which base64 encodes the user email and organization passcode. However, this computed value isn't being used in the helm commands where [BASIC_PASSCODE] appears. The helm commands should use ${accessKey.value} instead of the static placeholder.

• In collectorCmd computed property, replace:

  --set exporters."otlphttp/openobserve".headers.Authorization="Basic [BASIC_PASSCODE]"

  with:

  --set exporters."otlphttp/openobserve".headers.Authorization="Basic ${accessKey.value}"

• Make the same replacement in collectorCmdThisCluster computed property.

🔗 Analysis chain

Line range hint 201-211: Add instructions for handling the Basic Auth token.

The helm commands include a placeholder [BASIC_PASSCODE] for the Authorization header, but there are no instructions for users on how to replace it securely. Consider adding a note explaining how to generate and use the correct Basic Auth token.

---

Let me gather more context about any existing documentation or instructions regarding the Basic Auth token.

---

Let me check if there are any related instructions or comments in the Vue component itself or nearby files.

🏁 Scripts executed

The following scripts were executed for the analysis:

Script:

#!/bin/bash
# Check if there are any actual credentials accidentally committed
rg -i 'authorization.*basic.*[a-zA-Z0-9+/]{20,}' || echo "No hardcoded Basic Auth tokens found."

Length of output: 2286

---

Script:

#!/bin/bash
# Check for any documentation or comments about Basic Auth token generation
rg -i -A 3 -B 3 'basic.*auth|basic.*token|basicauth' web/src/components/ingestion/

# Also check for any related documentation in markdown files
fd -e md -x rg -i 'basic.*auth|basic.*token|basicauth' {}

Length of output: 792

---

Script:

#!/bin/bash
# Check the content of the Kubernetes config component and surrounding files
cat web/src/components/ingestion/recommended/KubernetesConfig.vue

# Check for any related components that might contain instructions
fd -t f . web/src/components/ingestion/recommended/ -x cat {}

Length of output: 27875

web/src/composables/useLogs.ts (4)

Line range hint 4095-4106: Improve SQL table name quoting robustness.

The current regex-based approach for quoting table names has potential issues:

1. It may fail with special characters in stream names
2. Case-insensitive matching could cause issues with case-sensitive databases
3. Global replacement could affect substrings in complex queries

Consider this safer implementation:

-  const regex = new RegExp(`FROM\\s+${streamName}`, "gi");
-  const modifiedSql = sql.replace(regex, `FROM "${streamName}"`);
+  // Escape special regex characters in streamName
+  const escapedStreamName = streamName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const regex = new RegExp(
+    `(FROM|JOIN)\\s+(${escapedStreamName})(?![a-zA-Z0-9_"])`,
+    'g'
+  );
+  const modifiedSql = sql.replace(regex, `$1 "${streamName}"`);

---

Line range hint 4095-4143: Enhance error handling in filter expression generation.

The current error handling silently logs errors and returns a potentially unsafe default expression. This could mask issues and lead to incorrect filter behavior.

Consider this improved error handling:

   } catch (e: any) {
-    console.log("Error while getting filter expression by field type", e);
-    return `${field} ${operator} '${field_value}'`;
+    const errorMsg = `Error generating filter expression for field "${field}": ${e.message}`;
+    console.error(errorMsg, e);
+    // Return a safe default or throw based on field_value type
+    if (typeof field_value === 'number' || typeof field_value === 'boolean') {
+      return `${field} ${operator} ${field_value}`;
+    }
+    return `${field} ${operator} '${field_value?.toString().replace(/'/g, "''")}'`;
   }

---

Line range hint 2919-2947: Optimize performance in record processing.

The current implementation processes records individually and performs multiple array operations, which could be optimized for better performance.

Consider these optimizations:

-  const recordwithMaxAttribute =
-    searchObj.data.queryResults.hits[maxAttributesIndex];
-
-  for (const key of Object.keys(recordwithMaxAttribute)) {
-    if (key == "_o2_id" || key == "_original") {
-      continue;
-    }
-    if (key == store.state.zoConfig.timestamp_column) {
-      searchObj.data.hasSearchDataTimestampField = true;
-    }
-    if (
-      !schemaFields.includes(key) &&
-      !commonSchemaFields.includes(key) &&
-      key != "_stream_name"
-    ) {
-      fieldObj = {
-        name: key,
-        type: "Utf8",
-        ftsKey: false,
-        group: stream.name,
-        isSchemaField: false,
-        showValues: false,
-        isInterestingField:
-          searchObj.data.stream.interestingFieldList.includes(key)
-            ? true
-            : false,
-        streams: [],
-      };
-      schemaMaps.push(fieldObj);
-      schemaFields.push(key);
-    }
+  // Create sets for faster lookups
+  const schemaFieldSet = new Set(schemaFields);
+  const commonSchemaFieldSet = new Set(commonSchemaFields);
+  const interestingFieldSet = new Set(searchObj.data.stream.interestingFieldList);
+  
+  // Process all keys at once
+  const recordKeys = Object.keys(recordwithMaxAttribute);
+  const newFields = recordKeys.filter(key => {
+    if (key === "_o2_id" || key === "_original" || key === "_stream_name") {
+      return false;
+    }
+    if (key === store.state.zoConfig.timestamp_column) {
+      searchObj.data.hasSearchDataTimestampField = true;
+      return false;
+    }
+    return !schemaFieldSet.has(key) && !commonSchemaFieldSet.has(key);
+  });
+
+  // Batch create field objects
+  const newFieldObjects = newFields.map(key => ({
+    name: key,
+    type: "Utf8",
+    ftsKey: false,
+    group: stream.name,
+    isSchemaField: false,
+    showValues: false,
+    isInterestingField: interestingFieldSet.has(key),
+    streams: [],
+  }));
+
+  schemaMaps.push(...newFieldObjects);
+  schemaFields.push(...newFields);

---

Line range hint 4095-4143: Enhance trace ID management robustness.

The trace ID management could be improved with validation and optimized array operations.

Consider these improvements:

+  const validateTraceId = (traceId: string): boolean => {
+    return /^[0-9a-f]{32}$/.test(traceId);
+  };
+
   const addTraceId = (traceId: string) => {
+    if (!validateTraceId(traceId)) {
+      console.warn(`Invalid trace ID format: ${traceId}`);
+      return;
+    }
     if (searchObj.data.searchRequestTraceIds.includes(traceId)) {
       return;
     }
     searchObj.data.searchRequestTraceIds.push(traceId);
   };
 
   const removeTraceId = (traceId: string) => {
-    searchObj.data.searchRequestTraceIds =
-      searchObj.data.searchRequestTraceIds.filter(
-        (id: string) => id !== traceId,
-      );
+    const index = searchObj.data.searchRequestTraceIds.indexOf(traceId);
+    if (index > -1) {
+      searchObj.data.searchRequestTraceIds.splice(index, 1);
+    }
   };

Configuration used: CodeRabbit UI
Review profile: CHILL

trace_id_field_name: "trace_id",
span_id_field_name: "span_id",

#!/bin/bash
# Search for any remaining camelCase versions that might have been missed
echo "Searching for old camelCase versions..."
rg -i "traceId|spanId" --type ts --type vue

# Search for new snake_case versions to ensure consistent usage
echo -e "\nVerifying new snake_case versions..."
rg -i "trace_id|span_id" --type ts --type vue

#!/bin/bash
# Search for any remaining camelCase versions that might have been missed
echo "Searching for old camelCase versions..."
rg -i "traceId|spanId" --type typescript --type javascript

# Search for new snake_case versions to ensure consistent usage
echo -e "\nVerifying new snake_case versions..."
rg -i "trace_id|span_id" --type typescript --type javascript

#!/bin/bash
# Search for any remaining camelCase versions that might have been missed
echo "Searching for old camelCase versions..."
rg -i "traceId|spanId"

# Search for new snake_case versions to ensure consistent usage
echo -e "\nVerifying new snake_case versions..."
rg -i "trace_id|span_id"