Exact Code Search: So findet man Code blitzschnell über mehrere Repositories hinweg

Kurz gesagt: Was wäre, wenn du jede Codezeile in 48 TB an Repositories in Millisekunden finden könntest? GitLabs neue Exact Code Search macht genau das möglich – mit präzisen Treffern, leistungsstarker Regex-Unterstützung und kontextbezogenen mehrzeiligen Ergebnissen, die die Arbeit mit großen Codebasen revolutionieren.

Warum traditionelle Code-Suche herausfordernd ist

Jeder, der mit Code arbeitet, kennt die Frustration bei der Suche über Repositories hinweg. Egal ob du als Entwickler(in) einen Fehler debuggst, als DevOps-Ingenieur(in) Konfigurationen untersuchst, als Sicherheitsanalyst(in) nach Schwachstellen suchst, als technische(r) Redakteur(in) Dokumentationen aktualisierst oder als Manager(in) Implementierungen überprüfst – du weißt genau, was du brauchst, aber herkömmliche Suchwerkzeuge lassen dich oft im Stich.

Diese konventionellen Tools liefern Dutzende von False Positives, bieten nicht den nötigen Kontext zum Verständnis der Ergebnisse und werden mit wachsenden Codebasen immer langsamer. Das Ergebnis? Wertvolle Zeit wird mit der Suche nach der Nadel im Heuhaufen verschwendet, anstatt Software zu entwickeln, zu sichern oder zu verbessern.

GitLabs Code-Suchfunktion basierte bisher auf Elasticsearch oder OpenSearch. Diese eignen sich zwar hervorragend für die Suche in Issues, Merge Requests, Kommentaren und anderen Daten mit natürlicher Sprache, wurden aber nicht speziell für Code entwickelt. Nach der Evaluierung zahlreicher Optionen haben wir eine bessere Lösung entwickelt.

Wir stellen vor: Exact Code Search – drei bahnbrechende Funktionen

Mit GitLabs Exact Code Search, derzeit in der Beta-Phase und angetrieben von Zoekt (ausgesprochen "sukt", niederländisch für "sucht"). Zoekt ist eine Open-Source-Code-Suchmaschine, die ursprünglich von Google entwickelt und jetzt von Sourcegraph gepflegt wird – speziell konzipiert für schnelle, präzise Code-Suche im großen Maßstab. Wir haben sie mit GitLab-spezifischen Integrationen, Verbesserungen für Unternehmensmaßstäbe und nahtloser Integration des Berechtigungssystems erweitert.

Diese Funktion revolutioniert, wie du Code findest und verstehst, mit drei Hauptfunktionen:

1. Exact Match-Modus: Null False Positives

Im Exact Match-Modus liefert die Suchmaschine nur Ergebnisse, die exakt deiner Suchanfrage entsprechen, und eliminiert False Positives. Diese Präzision ist unbezahlbar beim:

• Suchen nach spezifischen Fehlermeldungen

• Finden bestimmter Funktionssignaturen

• Aufspüren von Instanzen spezifischer Variablennamen

2. Regular Expression-Modus: Leistungsstarkes Pattern Matching

Für komplexe Suchanforderungen ermöglicht der Regular Expression-Modus die Erstellung ausgefeilter Suchmuster:

• Finde Funktionen, die bestimmten Namensmustern folgen

• Lokalisiere Variablen mit bestimmten Einschränkungen

• Identifiziere potenzielle Sicherheitslücken mittels Pattern Matching

3. Mehrzeilige Treffer: Code im Kontext sehen

Statt nur eine einzelne Zeile mit deinem Suchbegriff zu sehen, erhältst du den umgebenden Kontext, der für das Verständnis des Codes entscheidend ist. Das eliminiert die Notwendigkeit, für grundlegendes Verständnis in Dateien zu klicken, und beschleunigt deinen Workflow erheblich.

Von Funktionen zu Workflows: Anwendungsfälle und Auswirkungen aus der Praxis

Schauen wir uns an, wie diese Funktionen zu echten Produktivitätssteigerungen in alltäglichen Entwicklungsszenarien führen:

Debugging: Von der Fehlermeldung zur Ursache in Sekunden

Vor Exact Code Search:

Eine Fehlermeldung kopieren, suchen, durch Dutzende von Teiltreffern in Kommentaren und Dokumentation waten, durch mehrere Dateien klicken und schließlich den tatsächlichen Code finden.

Mit Exact Code Search:

1. Die exakte Fehlermeldung kopieren

2. Sie in Exact Code Search im Exact Match-Modus einfügen

3. Sofort die präzise Stelle finden, wo der Fehler ausgelöst wird, mit umgebendem Kontext

Auswirkung: Reduziere die Debugging-Zeit von Minuten auf Sekunden und eliminiere die Frustration durch False Positives.

Code-Exploration: Unbekannte Codebasen schnell meistern

Vor Exact Code Search:

Durch Verzeichnisse browsen, fundierte Vermutungen über Dateispeicherorte anstellen, Dutzende von Dateien öffnen und langsam eine mentale Karte der Codebasis aufbauen.

Mit Exact Code Search:

• Nach Schlüsselmethoden oder -klassen im Exact Match-Modus suchen

• Mehrzeilige Treffer überprüfen, um Implementierungsdetails zu verstehen

• Den Regular Expression-Modus nutzen, um ähnliche Muster in der Codebasis zu finden

Auswirkung: Baue eine mentale Karte der Code-Struktur in Minuten statt Stunden auf und beschleunige Onboarding und teamübergreifende Zusammenarbeit dramatisch.

Refactoring mit Zuversicht

Vor Exact Code Search:

Versuchen, alle Instanzen einer Methode zu finden, einige Vorkommen übersehen und durch unvollständiges Refactoring Fehler einführen.

Mit Exact Code Search:

• Den Exact Match-Modus nutzen, um alle Vorkommen von Methoden oder Variablen zu finden

• Kontext überprüfen, um Verwendungsmuster zu verstehen

• Dein Refactoring mit vollständigen Informationen über die Auswirkungen planen

Auswirkung: Eliminiere die "übersehene Instanz"-Fehler, die Refactoring-Bemühungen oft plagen, verbessere die Code-Qualität und reduziere Nacharbeit.

Sicherheitsaudits: Verwundbare Muster finden

Sicherheitsteams können:

• Regex-Muster erstellen, die bekanntem verwundbarem Code entsprechen

• Über alle Repositories in einem Namespace suchen

• Schnell potenzielle Sicherheitsprobleme mit Kontext identifizieren, der bei der Risikobewertung hilft

Auswirkung: Verwandle Sicherheitsaudits von manuellen, fehleranfälligen Prozessen in systematische, umfassende Überprüfungen.

Repository-übergreifende Einblicke

Suche über deinen gesamten Namespace oder deine Instanz, um:

• Ähnliche Implementierungen in verschiedenen Projekten zu identifizieren

• Möglichkeiten für gemeinsame Bibliotheken oder Standardisierung zu entdecken

Auswirkung: Baue Silos zwischen Projekten ab und identifiziere Möglichkeiten für Code-Wiederverwendung und Standardisierung.

Die technische Grundlage: Wie Zoekt Geschwindigkeit und Präzision liefert

Bevor wir in unsere Skalierungserfolge eintauchen, lass uns erkunden, was Zoekt grundlegend von traditionellen Suchmaschinen unterscheidet – und warum es exakte Treffer so unglaublich schnell finden kann.

Positionale Trigramme: Das Geheimnis blitzschneller exakter Treffer

Zoekts Geschwindigkeit kommt von der Verwendung positionaler Trigramme – einer Technik, die jede Sequenz von drei Zeichen zusammen mit ihren exakten Positionen in Dateien indexiert. Dieser Ansatz löst einen der größten Schmerzpunkte, die Entwickler(innen) mit Elasticsearch-basierter Code-Suche hatten: False Positives.

So funktioniert es:

Traditionelle Volltextsuchmaschinen wie Elasticsearch tokenisieren Code in Wörter und verlieren Positionsinformationen. Wenn du nach getUserId() suchst, könnten sie Ergebnisse liefern, die user, get und Id über eine Datei verteilt enthalten – was zu diesen frustrierenden False Positives für GitLab-Nutzer(innen) führt.

Zoekts positionale Trigramme behalten exakte Zeichensequenzen und ihre Positionen bei. Wenn du nach getUserId() suchst, sucht Zoekt nach den exakten Trigrammen wie get, etU, tUs, Use, ser, erI, rId, Id(, d(), alle in der korrekten Reihenfolge und Position. Das stellt sicher, dass nur exakte Treffer zurückgegeben werden.

Das Ergebnis? Suchanfragen, die zuvor Hunderte irrelevanter Ergebnisse lieferten, liefern jetzt nur noch die präzisen Treffer, nach denen du suchst. Das war eine unserer meistgewünschten Funktionen aus gutem Grund – Entwickler(innen) verloren erhebliche Zeit beim Durchsuchen von False Positives.

Regular Expression-Performance im großen Maßstab

Zoekt glänzt bei exakten Treffern und ist für Regular Expression-Suchen optimiert. Die Engine nutzt ausgefeilte Algorithmen, um Regex-Muster wenn möglich in effiziente Trigramm-Abfragen umzuwandeln und behält die Geschwindigkeit selbst bei komplexen Mustern über Terabytes von Code bei.

Entwickelt für Unternehmensmaßstäbe

Exact Code Search ist leistungsstark und für massive Skalierung mit beeindruckender Performance gebaut. Das ist nicht nur eine neue UI-Funktion – sie wird von einer komplett neu konzipierten Backend-Architektur angetrieben.

Terabytes von Code mit Leichtigkeit bewältigen

Allein auf GitLab.com indexiert und durchsucht unsere Exact Code Search-Infrastruktur über 48 TB an Code-Daten bei gleichzeitig blitzschnellen Antwortzeiten. Diese Größenordnung repräsentiert Millionen von Repositories über Tausende von Namespaces, alle innerhalb von Millisekunden durchsuchbar. Um das in Perspektive zu setzen: Diese Größenordnung repräsentiert mehr Code als die gesamten Linux-Kernel-, Android- und Chromium-Projekte zusammen. Dennoch kann Exact Code Search eine spezifische Zeile in dieser massiven Codebasis in Millisekunden finden.

Selbstregistrierende Node-Architektur

Unsere innovative Implementierung bietet:

• Automatische Node-Registrierung: Zoekt-Nodes registrieren sich selbst bei GitLab

• Dynamische Shard-Zuweisung: Das System weist Namespaces automatisch Nodes zu

• Gesundheitsüberwachung: Nodes, die sich nicht melden, werden automatisch als offline markiert

Diese selbstkonfigurierende Architektur vereinfacht die Skalierung dramatisch. Wenn mehr Kapazität benötigt wird, können Administratoren einfach weitere Nodes hinzufügen, ohne komplexe Neukonfiguration.

Verteiltes System mit intelligentem Load Balancing

Hinter den Kulissen arbeitet Exact Code Search als verteiltes System mit diesen Schlüsselkomponenten:

• Spezialisierte Such-Nodes: Zweckgebundene Server, die Indexierung und Suche übernehmen

• Intelligentes Sharding: Code wird basierend auf Namespaces über Nodes verteilt

• Automatisches Load Balancing: Das System verteilt Arbeit intelligent basierend auf Kapazität

• Hohe Verfügbarkeit: Mehrere Replikate gewährleisten kontinuierlichen Betrieb, selbst wenn Nodes ausfallen

Hinweis: Hohe Verfügbarkeit ist in die Architektur integriert, aber noch nicht vollständig aktiviert. Siehe Issue 514736 für Updates.

Nahtlose Sicherheitsintegration

Exact Code Search integriert sich automatisch mit GitLabs Berechtigungssystem:

• Suchergebnisse werden basierend auf den Zugriffsrechten des Nutzers gefiltert

• Nur Code aus Projekten, auf die der Nutzer Zugriff hat, wird angezeigt

• Sicherheit ist in die Kernarchitektur integriert, nicht nachträglich hinzugefügt

Optimierte Performance

• Effiziente Indexierung: Große Repositories werden in Dutzenden von Sekunden indexiert

• Schnelle Query-Ausführung: Die meisten Suchen liefern Ergebnisse mit Antwortzeiten unter einer Sekunde

• Streaming-Ergebnisse: Die neue gRPC-basierte föderierte Suche streamt Ergebnisse, sobald sie gefunden werden

• Frühzeitiger Abbruch: Sobald genügend Ergebnisse gesammelt wurden, pausiert das System die Suche

Von der Bibliothek zum verteilten System: Technische Herausforderungen, die wir gelöst haben

Während Zoekt die Kern-Suchtechnologie bereitstellte, war es ursprünglich als minimale Bibliothek zur Verwaltung von .zoekt-Indexdateien konzipiert – nicht als verteilte Datenbank oder Unternehmens-Service. Hier sind die wichtigsten technischen Herausforderungen, die wir überwunden haben, um es in GitLabs Maßstab zum Laufen zu bringen:

Herausforderung 1: Aufbau einer Orchestrierungsschicht

Das Problem: Zoekt war für die Arbeit mit lokalen Indexdateien konzipiert, nicht für die Verteilung über mehrere Nodes, die viele gleichzeitige Nutzer bedienen.

Unsere Lösung: Wir haben eine umfassende Orchestrierungsschicht aufgebaut, die:

• Datenbankmodelle erstellt und verwaltet, um Nodes, Indizes, Repositories und Aufgaben zu verfolgen

• Eine selbstregistrierende Node-Architektur implementiert (inspiriert von GitLab Runner)

• Automatische Shard-Zuweisung und Load Balancing über Nodes hinweg handhabt

• Bidirektionale API-Kommunikation zwischen GitLab Rails und Zoekt-Nodes bereitstellt

Herausforderung 2: Skalierung von Speicher und Indexierung

Das Problem: Wie verwaltet man effizient Terabytes von Indexdaten über mehrere Nodes bei gleichzeitig schnellen Updates?

Unsere Lösung: Wir implementierten:

• Intelligentes Sharding: Namespaces werden basierend auf Kapazität und Last über Nodes verteilt

• Unabhängige Replikation: Jeder Node indexiert unabhängig von Gitaly (unserem Git-Speicherdienst), wodurch komplexe Synchronisation eliminiert wird

• Watermark-Management: Ausgefeilte Speicherzuweisung, die verhindert, dass Nodes der Speicherplatz ausgeht

• Einheitliche Binary-Architektur: Ein einzelnes gitlab-zoekt-Binary, das sowohl im Indexer- als auch im Webserver-Modus arbeiten kann

Herausforderung 3: Berechtigungsintegration

Das Problem: Zoekt hatte kein Konzept von GitLabs komplexem Berechtigungssystem – Nutzer sollten nur Ergebnisse aus Projekten sehen, auf die sie Zugriff haben.

Unsere Lösung: Wir haben native Berechtigungsfilterung direkt in den Suchablauf integriert:

• Suchanfragen enthalten Nutzerberechtigungskontext

• Ergebnisse werden gefiltert, um nur die anzuzeigen, auf die der Nutzer zugreifen kann, falls sich Berechtigungen ändern, bevor die Indexierung abgeschlossen ist

Herausforderung 4: Betriebliche Einfachheit

Das Problem: Die Verwaltung eines verteilten Suchsystems sollte kein dediziertes Team erfordern.

Unsere Lösung:

• Auto-Scaling: Das Hinzufügen von Kapazität ist so einfach wie das Bereitstellen weiterer Nodes – sie registrieren sich automatisch und beginnen mit der Arbeit

• Selbstheilung: Nodes, die sich nicht melden, werden automatisch als offline markiert und ihre Arbeit wird umverteilt

• Zero-Configuration-Sharding: Das System bestimmt automatisch optimale Shard-Zuweisungen

Schrittweiser Rollout: Risikominimierung im großen Maßstab

Der Rollout eines komplett neuen Such-Backends für Millionen von Nutzern erforderte sorgfältige Planung. So haben wir die Auswirkungen auf Kunden minimiert und gleichzeitig Zuverlässigkeit sichergestellt:

Phase 1: Kontrolliertes Testen (gitlab-org-Gruppe)

Wir begannen damit, Exact Code Search nur für die gitlab-org-Gruppe zu aktivieren – unsere eigenen internen Repositories. Das ermöglichte uns:

• Das System mit echten Produktions-Workloads zu testen

• Performance-Engpässe zu identifizieren und zu beheben

• Den Bereitstellungsprozess zu optimieren

• Aus den Workflows und dem Feedback echter Nutzer zu lernen

Phase 2: Performance-Validierung und -Optimierung

Vor der Erweiterung konzentrierten wir uns darauf sicherzustellen, dass das System GitLab.coms Maßstab bewältigen konnte:

• Umfassendes Monitoring und Alerting implementiert

• Speicherverwaltung mit echtem Produktionsdatenwachstum validiert

Phase 3: Schrittweise Kundenerweiterung

Wir erweiterten schrittweise auf Kunden, die daran interessiert waren, Exact Code Search zu testen:

• Feedback zu Performance und Benutzererfahrung gesammelt

• Die Such-UI basierend auf echten Nutzer-Workflows verfeinert

• Indexierungs-Performance optimiert (große Repositories wie gitlab-org/gitlab indexieren jetzt in ~10 Sekunden)

• Die Architektur basierend auf betrieblichen Erkenntnissen verfeinert

• Indexierungs-Durchsatz massiv erhöht und Zustandsübergangs-Lebenszyklus verbessert

Phase 4: Breiter Rollout

Heute haben über 99 % der Premium- und Ultimate-lizenzierten Gruppen auf GitLab.com Zugriff auf Exact Code Search. Nutzer können:

• Zwischen Regex- und exaktem Suchmodus umschalten

• Die Vorteile ohne Konfigurationsänderungen erleben

• Bei Bedarf auf die vorherige Suche zurückgreifen (obwohl wenige dies wählen)

Der schrittweise Rollout bedeutete, dass Nutzer keine Service-Unterbrechungen, Performance-Verschlechterungen oder Feature-Lücken während des Übergangs erlebten. Wir haben bereits positives Feedback von Nutzern erhalten, die bemerken, dass ihre Ergebnisse relevanter und schneller werden.

Für technische Details: Interessiert an der detaillierten Architektur und Implementierung? Schau dir unser umfassendes Design-Dokument für ausführliche technische Details an, wie wir dieses verteilte Suchsystem gebaut haben.

Erste Schritte mit Exact Code Search

Der Einstieg in Exact Code Search ist einfach, da es bereits standardmäßig für Premium- und Ultimate-Gruppen auf GitLab.com aktiviert ist (über 99 % der berechtigten Gruppen haben derzeit Zugriff).

Schnellstart-Anleitung

1. Navigiere zur erweiterten Suche in deinem GitLab-Projekt oder deiner Gruppe

2. Gib deinen Suchbegriff im Code-Tab ein

3. Wechsle zwischen Exact Match- und Regular Expression-Modus

4. Nutze Filter, um deine Suche zu verfeinern

Grundlegende Such-Syntax

Egal ob du den Exact Match- oder Regular Expression-Modus verwendest, du kannst deine Suche mit Modifikatoren verfeinern:

| Abfrage-Beispiel | Was es bewirkt |

| ---------------- | ----------------------------------------------------------- |

| file:js | Sucht nur in Dateien, die "js" im Namen enthalten |

| foo -bar | Findet "foo", schließt aber Ergebnisse mit "bar" aus |

| lang:ruby | Sucht nur in Ruby-Dateien |

| sym:process | Findet "process" in Symbolen (Methoden, Klassen, Variablen) |

Profi-Tipp: Für die effizientesten Suchen beginne spezifisch und erweitere dann bei Bedarf. Die Verwendung von file:- und lang:-Filtern erhöht die Relevanz dramatisch.

Erweiterte Suchtechniken

Stapele mehrere Filter für Präzision:

is_expected file:rb -file:spec

Das findet "is_expected" in Ruby-Dateien, die nicht "spec" im Namen haben.

Nutze reguläre Ausdrücke für leistungsstarke Muster:

token.*=.*[\"']

Sieh dir diese Suche im GitLab Zoekt Repository an.

Die Suche hilft, hartcodierte Passwörter zu finden, die, wenn nicht gefunden, ein Sicherheitsproblem darstellen können.

Für detailliertere Syntax-Informationen, schau in die Exact Code Search-Dokumentation.

Verfügbarkeit und Bereitstellung

Aktuelle Verfügbarkeit

Exact Code Search befindet sich derzeit in der Beta-Phase für GitLab.com-Nutzer mit Premium- und Ultimate-Lizenzen:

• Verfügbar für über 99 % der lizenzierten Gruppen

• Die Suche in der UI nutzt automatisch Zoekt, wenn verfügbar, Exact Code Search in der Such-API ist hinter einem Feature-Flag

Bereitstellungsoptionen für Self-Managed

Für Self-Managed-Instanzen bieten wir mehrere Bereitstellungsmethoden:

• Kubernetes/Helm: Unsere am besten unterstützte Methode, mit unserem gitlab-zoekt Helm Chart

• Andere Bereitstellungsoptionen: Wir arbeiten an der Vereinfachung der Bereitstellung für Omnibus und andere Installationsmethoden

Die Systemanforderungen hängen von deiner Codebasis-Größe ab, aber die Architektur ist darauf ausgelegt, horizontal und/oder vertikal zu skalieren, wenn deine Anforderungen wachsen.

Was als Nächstes kommt

Während Exact Code Search bereits leistungsstark ist, verbessern wir sie kontinuierlich:

• Skalierungsoptimierungen zur Unterstützung von Instanzen mit Hunderttausenden von Repositories

• Verbesserte Self-Managed-Bereitstellungsoptionen, einschließlich vereinfachter Omnibus-Unterstützung

• Vollständige Hochverfügbarkeits-Unterstützung mit automatischem Failover und Load Balancing

Bleib dran für Updates, während wir von Beta zu General Availability übergehen.

Transformiere deine Arbeitsweise mit Code

GitLabs Exact Code Search repräsentiert ein grundlegendes Umdenken bei der Code-Entdeckung. Durch die Bereitstellung exakter Treffer, leistungsstarker Regex-Unterstützung und kontextbezogener Ergebnisse löst sie die frustrierendsten Aspekte der Code-Suche:

• Keine Zeitverschwendung mehr mit irrelevanten Ergebnissen

• Keine wichtigen Treffer mehr verpassen

• Kein Durchklicken von Dateien mehr nur für grundlegendes Verständnis

• Keine Performance-Probleme mehr bei wachsenden Codebasen

Die Auswirkungen gehen über die individuelle Produktivität hinaus:

• Teams arbeiten besser zusammen mit einfacher Code-Referenzierung

• Wissensaustausch beschleunigt sich, wenn Muster auffindbar sind

• Onboarding wird schneller mit schnellem Codebasis-Verständnis

• Sicherheit verbessert sich mit effektivem Muster-Auditing

• Abbau technischer Schulden wird machbarer

Exact Code Search ist nicht nur eine Funktion, es ist eine bessere Art, Code zu verstehen und damit zu arbeiten. Hör auf zu suchen und fang an zu finden.

Wir würden gerne von dir hören! Teile deine Erfahrungen, Fragen oder Feedback zu Exact Code Search in unserem Feedback-Issue. Dein Input hilft uns, Verbesserungen und neue Funktionen zu priorisieren.

Bereit für smartere Code-Suche? Erfahre mehr in unserer Dokumentation oder probiere es jetzt aus, indem du eine Suche in deinen Premium- oder Ultimate-lizenzierten Namespaces oder Projekten durchführst. Noch kein GitLab-Nutzer? Teste kostenlos GitLab Ultimate mit Duo!