Bakit ang mga logs ay palagi sa 2026 Ang mga log ay ang “truth,” ngunit ito ay din ang : least ergonomic data format ever invented 
 
 
 
 Scale: GB / TB bawat araw ay normal. Human eyeballs ay hindi. Format drift: Apache, Nginx, JVM, container runtime, app logs, vendor SDK logs... ang bawat isa ay may kanyang sarili na schema (o walang schema). : the real root cause often lives in   messages (timeouts + pool exhaustion + CPU spikes), not a single keyword. Hidden coupling co-occurring Ang mga LLM ay nagbabago ng equation dahil maaari mong i-describe ang intent sa simpleng Ingles— Huwag mag-sign ng isang buong parser upfront. then force structure on output Ang keyword ay . ang force Ang isang mahusay na prompt ay hindi "Analyze ang mga log." isang mahusay na prompt ay isang kontrata. Ang mental na modelo: mga prompts bilang mga kontrata, hindi mga tanong Tingnan ang iyong prompt tulad ng isang API spec: 
 
 
 
 
 Mga input: Ano ang ibinigay mo (log snippet, timeframe, schema hints). Task: Ano ang modelo ay dapat i-calculate (filter, extract, count, cluster). Output schema: Ano ang resulta ay dapat makita (tabula / JSON, deterministic fields). Mga limitasyon: Ano upang i-ignorate, kung paano magtatrabaho sa mga kaso ng edge, paglalarawan ng mga patakaran. Kung hindi mo ibinigay ang mga ito, ang modelo ay lumabas sa iyo ng isang novel. Part I — Log analysis prompts na hindi halusin Ang 5-block prompt template (battle-tested) Gamit ito bilang iyong default skeleton: 1) Role: You are a {domain role} specializing in {log type} analysis.
2) Context: System + timeframe + what "good" looks like.
3) Data: Paste logs or provide a schema + sample lines.
4) Tasks: Bullet list of explicit operations to perform.
5) Output: Strict schema (table or JSON). Include edge-case rules.
 Isang maliit na pagkakataon na may malaking epekto: (JSON o strict tables). Kung ang isang tao ay makikita ito pagkatapos, mahusay - ang mga tao ay maaaring makikita JSON. make the output machine-checkable Scenario A — Incident trial: i-extract ang ERROR/FATAL, normalize, dedupe Here’s a prompt that behaves like an on-call teammate: Role:
You are a senior SRE. You extract incident-relevant signals from mixed application logs.
​
Context:
- System: Checkout Service (Java) + Redis cache + MySQL
- Goal: Identify actionable error patterns for a post-incident summary
- Time window: 2026-02-16 19:10–19:20 UTC
​
Data:
{PASTE LOGS HERE}
​
Tasks:
1) Filter only ERROR and FATAL entries.
2) For each entry, extract:
   - ts, level, service/component (if present), exception/error type, resource (host/ip/url), raw message
3) Normalize error types:
   - e.g., "Conn refused", "Connection refused" -> "Connection refused"
   - Stack traces: keep only top frame + exception class
4) Deduplicate identical errors; count occurrences.
5) Produce top-3 error types by frequency.
​
Output (strict JSON):
{
  "window": "...",
  "total_errors": 0,
  "top_errors": [
    {
      "error_type": "",
      "count": 0,
      "example": {
        "ts": "",
        "level": "",
        "resource": "",
        "message": ""
      }
    }
  ],
  "all_errors": [
    {
      "ts": "",
      "level": "",
      "error_type": "",
      "resource": "",
      "message": ""
    }
  ]
}
​
Constraints:
- Never invent fields. If missing, use null.
- Keep error_type <= 40 chars.
 Bakit ito gumagana 
 
 
 
 Hindi mo ba kinakailangan para sa “analysis.” ikaw ay kinakailangan para sa extraction + normalization. I-imped ang creativity sa pamamagitan ng nangangailangan ng null para sa missing fields. Kailangan mo ng mga count, na inilagay ang aggregation sa halip ng story-telling. Scenario B — Product analytics: compute funnels mula sa behavior logs Para sa mga behavior logs, ikaw ay interesado sa at ang Wala na akong trace. Mga Username Matematika ng conversion Role:
You are a product analyst. You compute funnel metrics from event logs.
​
Data:
Each line is one event:
YYYY-MM-DD HH:MM:SS | user_id=... | event=... | item_id=... | device=...
​
Tasks:
1) For item_id=SKU-9411, count each event type.
2) Compute unique users per event (dedupe by user_id).
3) Compute:
   - view->add_to_cart
   - add_to_cart->purchase
4) If denominator is 0, return "N/A" and explain.
​
Output:
- Table: event, events_count, unique_users
- Then: formulas + results (2 decimals)
 Scenario C — Trend analysis: spot spikes, hypothesize causes (pagkakahalaga) Ang trend prompts ay hindi nawala kapag nagbibigay ang modelo ng "explain" bago ito ay "measures." Pagkatapos ng pagsusuri ay obligatory: Tasks:
1) Identify peak windows (>= P95) and trough windows (==0).
2) Describe the trend using only the provided numbers.
3) Provide 3 hypotheses, each tied to at least one data point.
4) List 5 follow-up queries you'd run in your log tool to validate.
 Ito ay tumutulong sa "maybe a deployment happened" mula sa maging isang fairy tale. Part II — Keyword clustering na talagang useful Ang clustering ng mga keyword ay kung saan ang mga team ay gumagamit ng oras dahil ang lahat ay nag-argument tungkol sa taxonomy. Ito ang definisyon ng taxonomy. Ang clustering template (6 mga block) 1) Role: You are an NLP engineer for operational logs.
2) Input: List of keywords/errors (raw strings).
3) Dimension: Cluster by {fault type | subsystem | user journey stage | time correlation}.
4) Rules:
   - Each keyword belongs to exactly one cluster.
   - Provide a short cluster name + description.
   - If ambiguous, choose best fit and add rationale.
5) Output: JSON array of clusters.
6) Constraints: 3–7 clusters total, names <= 20 chars.
 Halimbawa: cluster sa pamamagitan ng error type (ops-friendly) Mga pahinang tumuturo (intentionally messy): 
 
 
 
 
 
 
 
 
 
 Paglalarawan ng DB Conn Timeout MySQL: Ang koneksyon ay inihayag Ang Redis Handshake ay hindi ang napili ng mga taga-hanga: Mga pahinang tumuturo sa 502 Bad Gateway Thread pool sa loob ng NullPointerException sa OrderHandler Mga pahinang tumuturo sa timeout /cart Ang paggamit ng CPU ay 99% Ang mabilis na output ay dapat makita bilang: [
  {
    "cluster": "Resource Connect",
    "keywords": ["DB conn timeout", "MySQL: Connection refused", "Redis handshake failed", "Cache timeout /cart"],
    "notes": "Downstream connectivity and timeouts (DB/cache/network). Owner: SRE"
  },
  {
    "cluster": "Code Exceptions",
    "keywords": ["NullPointerException at OrderHandler", "java.lang.OutOfMemoryError"],
    "notes": "Application-level exceptions. Owner: Dev"
  },
  {
    "cluster": "Gateway/Infra",
    "keywords": ["502 Bad Gateway", "CPU usage 99%", "Thread pool exhausted"],
    "notes": "Edge/proxy errors and capacity saturation. Owner: SRE/Platform"
  }
]
 Tingnan kung ano ang nangangailangan: “AI vibes.” Ito ay direktang mapappable sa . who does what next Ang unsexy na katotohanan: kailangan mo pa rin ng preprocessing Ang mga LLM ay hindi isang substitute para sa: 
 
 
 
 
 
 Mga Filter ng Time Extraction ng mga field Mga sampling ang duplication Join / correlation sa pamamagitan ng mga signal Ito ay isang substitute para sa writing. Ang logic ay nagbabago sa lahat ng format. ang custom Ang winning workflow ay: 
 
 Ang tool ay gumagawa ng mga slicing. LLM ay gumagawa ng sense-making. Tool does the slicing. LLM does the sense-making. Advanced workflow 1 — Elastic (ELK) + prompts: reduc TB → 200 mga linya → clarity Ang isang pragmatic game: 
 
 
 
 
 Use your log platform to filter:
 
 
 
 
 
 service=checkout level >= ERROR @timestamp: 19:10–19:20 I-export ang maliit na subset (50-300 mga linya). I-feed sa triage prompt (JSON output) I-feed ang extracted error_type strings sa clustering prompt. If your team is adopting  sa Elastic tooling, kahit na mas mahusay: Ang ES ÁthaQL ay nagbibigay-daan sa mas madali upang gawin ang "pre-joins" (misyon, pag-aayos ng user tier o rehiyon) bago mo ibinigay ang data sa isang LLM. ES|QL Advanced Workflow 2 — OpenTelemetry logs: magbayad ng isang beses, pag-analisa sa lahat Kung maaari mong i-influence ang mga standard ng logging, gawin ito: 
 
 
 I-adopt ang consistent na mga attributes (service.name, deployment.environment, http.route, db.system, atbp) I-configure ang mga mensahe, ngunit i-configure ang mga pangunahing mga katotohanan ay din mga estruktural na mga field. Dahil ang mga prompts ng LLM ay naging mas simpleng kapag ang mga field ay consistent: 
 
 Ang "Extract error.message and db.statement" ay tumutulong sa "hindi kung ano ang ibig sabihin ng blob." Kung ang iyong mga log ay hindi na-structured, ang iyong prompt ay dapat maging isang parser. At ang mga parser ay kung saan ang kasiyahan ay umalis. Advanced workflow 3 — Python preprocessing + prompt clustering (na may isang twist) Kapag ang iyong mga log ay libreng form, gawin a Pumunta sa mga basics. Minimum ang Narito ang isang mas mabigat na halimbawa na i-convert raw na mga linya sa JSON na maaari mong i-paste sa isang LLM prompt. (Ito ay malakas na maliit - dahil ang target ay upang Huwag gamitin ang isang framework.) reduce chaos import re
import json
​
RAW = [
    "2026-02-16 19:12:05 ERROR checkout Thread-17 DB connection timeout url=jdbc:mysql://10.0.4.12:3306/payments",
    "2026-02-16 19:12:19 WARN  checkout Thread-03 heap at 87% host=app-2",
    "2026-02-16 19:13:02 ERROR cache    Thread-22 Redis handshake failed host=10.0.2.9:6379",
    "2026-02-16 19:13:45 FATAL checkout Thread-17 java.lang.OutOfMemoryError at OrderService.placeOrder(OrderService.java:214)"
]
​
PATTERN = re.compile(
    r"(?P<ts>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\s+"
    r"(?P<level>DEBUG|INFO|WARN|ERROR|FATAL)\s+"
    r"(?P<service>\w+)\s+"
    r"(?P<thread>Thread-\d+)\s+"
    r"(?P<msg>.*)"
)
​
def parse_line(line: str):
    m = PATTERN.match(line)
    if not m:
        return {"ts": None, "level": None, "service": None, "thread": None, "msg": line}
​
    d = m.groupdict()
    # lightweight resource hints (optional)
    d["resource"] = None
    if "host=" in d["msg"]:
        d["resource"] = d["msg"].split("host=", 1)[1].split()[0]
    if "url=" in d["msg"]:
        d["resource"] = d["msg"].split("url=", 1)[1].split()[0]
    return d
​
structured = [parse_line(x) for x in RAW]
print(json.dumps(structured, indent=2))
 Ngayon ang iyong LLM prompt ay maaaring : ang clean 
 
 
 
 Pagkakaiba sa pagitan ng {ERROR, FATAL} I-normalize ang msg sa error_type Cluster sa pamamagitan ng service o error type Mga pahinang tumuturo (at ang mga patakaran) 1) “Analyze these logs” (aka: please ramble) : demand extraction tasks + strict output scheme. Fix 2) Ang kontekstong window ay hindi Kung hindi mo ibinigay ang isang panahon / konteksto ng sistema, ang modelo ay hindi maaaring magbigay ng "normal na bull" mula sa "incident." ang add . Fix Pagkakaiba sa System + Window + Goal 3) Ang pag-iisip ay vague "Group these by relevance" ay kung paano makakuha ka ng 14 clusters na tinatawag na "Misc." : itakda ang isang dimensyon at matatagpuan ang mga clusters sa 3-7. Fix 4) Walang edge-case policy Division sa pamamagitan ng zero, empty inputs, ambiguous keywords... ang modelo ay magpahiwatig. Ang mga patakaran ng politika: na ang , “handa ng isang bagong cluster,” at iba pa. Fix null N/A 5) Pumunta ako sa isang crutch Ang isang “senior SRE” persona ay hindi gumagawa ng mga output. : itakda ang papel bilang tono lamang; correctness ay dumating mula . Fix Mga Task + Scheme + Mga Pagkakaiba Ang isang reusable "prompt pack" na maaari mong i-drop sa iyong team wiki 1) Triage prompt (ERROR / FATAL → JSON) 
 
 Paggamit para sa incident summaries at handoffs. 2) Metrics prompt (ang mga kaganapan → funnels) 
 
 Gamit para sa product/ops dashboards mula sa sampled logs. 3) Trend prompt (time series → spikes + hypotheses + follow-ups) 
 
 Pumunta sa “What changed?” session. 4) Clustering prompt (keywords → 3-7 incident buckets) 
 
 Paggamit ng isang live error taxonomy. Closing: kung ano ang “good” ay nakikita Kung gawin mo ito na totoo, ang iyong on-call flow ay nagbabago: 
 
 
 Pagkatapos: “grep + intuition + Slack archaeology” Pagkatapos: “filter → prompt → structured summary → owner → next query” Walang magic. Walang autonomous na mga agens. lamang isang disiplinado na kontrata sa pagitan ng iyo at ang modelo. At ito ay sapat na upang gumawa ng mga logs na magiging data dinala.

This story contains AI-generated text. The author has used AI either for research, to generate outlines, or write the text itself. 

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Read My Stories

Ang audio na ito ay ginawa sa orihinal na wika ng kuwento!

Prompt-Driven Log Analysis at Keyword Clustering

About Author

MGA KOMENTO

HANG TAGS

ANG ARTIKULONG ITO AY IPINAKITA SA

Related Stories

COVID-19: We Need More Than Data, We Need Insights!

How I deployed my spark document classification(Logistic Regression) model/s as a standalone app…

State of the Noonion: The Year of Profitability and Product Renaissance

Encrypted Instant Messaging Recommendations January 2017

COVID-19: We Need More Than Data, We Need Insights!

How I deployed my spark document classification(Logistic Regression) model/s as a standalone app…

State of the Noonion: The Year of Profitability and Product Renaissance

Encrypted Instant Messaging Recommendations January 2017

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps