ජෙන්කින්ස් හි SQL සේවාදායකයේ ස්වයංක්‍රීයකරණය: ප්‍රති result ලය අලංකාර ලෙස ලබා දීම

නැවතත් සැකසීමේ තේමාව දිගටම කරගෙන යාම Zero Touch PROD RDS යටතේ. අනාගත DBAs හට PROD සේවාදායකයන් වෙත කෙලින්ම සම්බන්ධ වීමට නොහැකි වනු ඇත, නමුත් භාවිතා කිරීමට හැකි වනු ඇත ජෙන්කින්ස් සීමිත මෙහෙයුම් කට්ටලයක් සඳහා රැකියා. DBA විසින් කාර්යය දියත් කරන අතර ටික වේලාවකට පසු මෙම මෙහෙයුම අවසන් කිරීම පිළිබඳ වාර්තාවක් සහිත ලිපියක් ලැබේ. මෙම ප්‍රතිඵල පරිශීලකයාට ඉදිරිපත් කළ හැකි ක්‍රම දෙස බලමු.

සරල පෙළ

අපි ඉතාම සුළු දෙයක් සමඟ ආරම්භ කරමු. පළමු ක්‍රමය කෙතරම් සරලද යත්, කතා කිරීමට කිසිවක් නැත (කතුවරයා මෙතැන් සිට FreeStyle jobs භාවිතා කරයි):

sqlcmd යමක් කරන අතර අපි එය පරිශීලකයාට ඉදිරිපත් කරමු. උදාහරණයක් ලෙස, උපස්ථ රැකියා සඳහා වඩාත් සුදුසුය:

මාර්ගය වන විට, RDS උපස්ථ/ප්‍රතිසාධනය යටතේ අසමමුහුර්ත බව අමතක නොකරන්න, එබැවින් ඔබ එය බලා සිටිය යුතුය:

declare @rds table
  (id int, task_type varchar(128), database_name sysname, pct int, duration int, 
   lifecycle varchar(128), taskinfo varchar(max) null, 
   upd datetime, cre datetime,
   s3 varchar(256), ovr int, KMS varchar(256) null)
waitfor delay '00:00:20' 
insert into @rds exec msdb.dbo.rds_task_status @db_name='{db}'
select @xid=max(id) from @rds

again:
waitfor delay '00:00:02'
delete from @rds
insert into @rds exec msdb.dbo.rds_task_status @db_name='{db}' 
# {db} substituted with db name by powershell
select @stat=lifecycle,@info=taskinfo from @rds where id=@xid
if @stat not in ('ERROR','SUCCESS','CANCELLED') goto again

දෙවන ක්රමය, CSV

මෙහි සෑම දෙයක්ම ඉතා සරල ය:

කෙසේ වෙතත්, මෙම ක්‍රමය ක්‍රියාත්මක වන්නේ CSV හි ආපසු ලබා දෙන දත්ත "සරල" නම් පමණි. ඔබ මේ ආකාරයෙන් TOP N CPU තීව්‍ර විමසුම් ලැයිස්තුවක් ආපසු ලබා දීමට උත්සාහ කරන්නේ නම්, විමසුම් පෙළෙහි ඕනෑම අක්ෂර - කොමා, උද්ධෘත සහ රේඛා බිඳීම් පවා අඩංගු විය හැකි නිසා CSV "විඛාදනයට" ලක් වේ. එමනිසා, අපට වඩාත් සංකීර්ණ දෙයක් අවශ්ය වේ.

HTML හි ලස්සන සලකුණු

මම ඔබට වහාම කේත කොටස දෙන්නම්

$Header = @"
<style>
TABLE {border-width: 1px; border-style: solid; border-color: black; border-collapse: collapse;}
TH {border-width: 1px; padding: 3px; border-style: solid; border-color: black; background-color: #6495ED;}
TD {border-width: 1px; padding: 3px; border-style: solid; border-color: black;}
</style>
"@
  
$Result = invoke-Sqlcmd -ConnectionString $jstr -Query "select * from DbInv" `
  | Select-Object -Property * -ExcludeProperty "ItemArray", "RowError", "RowState", "Table", "HasErrors"
if ($Result -eq $null) { $cnt = 0; }
elseif ($Result.getType().FullName -eq "System.Management.Automation.PSCustomObject") { $cnt = 1; }
else { $cnt = $Result.Rows.Count; } 
if ($cnt -gt 0) {
  $body = "<h2>My table</h2>"
  $Result | ConvertTo-HTML -Title "Rows" -Head $header -body $body `
    | Out-File "res.log" -Append -Encoding UTF8
  } else {
    "<h3>No data</h3>" | Out-File "res.log" -Append -Encoding UTF8
  }

මාර්ගය වන විට, System.Management.Automation.PSCustomObject සමඟ ඇති රේඛාව කෙරෙහි අවධානය යොමු කරන්න, එය ඉන්ද්‍රජාලික ය; ජාලයේ හරියටම එක් පේළියක් තිබේ නම්, සමහර ගැටළු මතු විය. විසඳුම වැඩි අවබෝධයකින් තොරව අන්තර්ජාලයෙන් ලබාගෙන ඇත. එහි ප්‍රතිඵලයක් වශයෙන්, ඔබට මෙවැනි දෙයක් හැඩතල ගැන්වීමේ ප්‍රතිදානය ලැබෙනු ඇත:

ප්රස්තාර ඇඳීම

අවවාදයයි: පහත කින්කි කේතය!
SQL සේවාදායකයේ අවසාන N මිනිත්තු සඳහා CPU දර්ශනය වන විහිලු විමසුමක් තිබේ - මේජර් සහෝදරයාට සියල්ල මතක ඇති බව පෙනේ! මෙම ප්‍රශ්නාවලිය උත්සාහ කරන්න:

DECLARE @ts_now bigint = (SELECT cpu_ticks/(cpu_ticks/ms_ticks) 
  FROM sys.dm_os_sys_info WITH (NOLOCK)); 
SELECT TOP(256) 
  DATEADD(ms, -1 * (@ts_now - [timestamp]), GETDATE()) AS [EventTime],
  SQLProcessUtilization AS [SQLCPU], 
  100 - SystemIdle - SQLProcessUtilization AS [OtherCPU]
FROM (SELECT record.value('(./Record/@id)[1]', 'int') AS record_id, 
  record.value('(./Record/SchedulerMonitorEvent/SystemHealth/SystemIdle)[1]', 'int') 
    AS [SystemIdle], 
  record.value('(./Record/SchedulerMonitorEvent/SystemHealth/ProcessUtilization)[1]', 'int') 
    AS [SQLProcessUtilization], [timestamp] 
  FROM (SELECT [timestamp], CONVERT(xml, record) AS [record] 
  FROM sys.dm_os_ring_buffers WITH (NOLOCK)
  WHERE ring_buffer_type = N'RING_BUFFER_SCHEDULER_MONITOR' 
    AND record LIKE N'%<SystemHealth>%') AS x) AS y 
ORDER BY 1 DESC OPTION (RECOMPILE);

දැන්, මෙම හැඩතල ගැන්වීම භාවිතා කරමින් ($Fragment විචල්‍යය)

<table style="width: 100%"><tbody><tr style="background-color: white; height: 2pt;">
  <td style="width: SQLCPU%; background-color: green;"></td>
  <td style="width: OtherCPU%; background-color: blue;"></td>
  <td style="width: REST%; background-color: #C0C0C0;"></td></tr></tbody>
</table>

අපට ලිපියේ ශරීරය සෑදිය හැකිය:

$Result = invoke-Sqlcmd -ConnectionString $connstr -Query $Query `
  | Select-Object -Property * -ExcludeProperty `
  "ItemArray", "RowError", "RowState", "Table", "HasErrors"
if ($Result.HasRows) {
  foreach($item in $Result) 
    { 
    $time = $itemEventTime 
    $sqlcpu = $item.SQLCPU
    $other = $itemOtherCPU
    $rest = 100 - $sqlcpu - $other
    $f = $fragment -replace "SQLCPU", $sqlcpu
    $f = $f -replace "OtherCPU", $other
    $f = $f -replace "REST", $rest
    $f | Out-File "res.log" -Append -Encoding UTF8
    }

කුමන ආකාරයෙන් පෙනෙනු ඇත:

ඔව්, මොන්සියර් විකෘති ගැන බොහෝ දේ දනී! මෙම කේතයේ අඩංගු වීම සිත්ගන්නා කරුණකි: Powershell (එහි ලියා ඇත), SQL, Xquery, HTML. අපට ජාවාස්ක්‍රිප්ට් HTML වෙත එක් කිරීමට නොහැකි වීම කණගාටුවට කරුණකි (එය ලිවීම සඳහා වන බැවින්), නමුත් පයිතන් කේතය ඔප දැමීම (එය SQL හි භාවිතා කළ හැකිය) සෑම කෙනෙකුගේම යුතුකමකි!

SQL ප්‍රොෆයිලර් ට්‍රේස් ප්‍රතිදානය

TextData ක්ෂේත්‍රය නිසා හෝඩුවාව CSV වෙත නොගැලපෙන බව පැහැදිලිය. නමුත් ලිපියක ලුහුබැඳීමේ ජාලයක් ප්‍රදර්ශනය කිරීම ද අමුතුයි - ප්‍රමාණය නිසා සහ මෙම දත්ත වැඩිදුර විශ්ලේෂණය සඳහා බොහෝ විට භාවිතා වන බැවිනි. එබැවින්, අපි පහත සඳහන් දේ කරන්නෙමු: අපි හරහා අමතන්න invoke-SqlCmd නිශ්චිත පිටපතක්, එය සිදු කරන ගැඹුරින්

select 
  SPID,EventClass,TextData,
  Duration,Reads,Writes,CPU,
  StartTime,EndTime,DatabaseName,HostName,
  ApplicationName,LoginName
   from ::fn_trace_gettable ( @filename , default )  

ඊළඟට, මත මිතුරා DBA විසින් ප්‍රවේශ විය හැකි සේවාදායකයේ, හිස් සැකිල්ලක් සහිත Traces දත්ත සමුදායක් ඇත, ආකෘති තහඩුව, සියලු නිශ්චිත තීරු පිළිගැනීමට සූදානම්. අපි මෙම ආකෘතිය අද්විතීය නමක් සහිත නව වගුවකට පිටපත් කරමු:

$dt = Get-Date -format "yyyyMMdd"
$tm = Get-Date -format "hhmmss"
$tableName = $srv + "_" + $dt + "_" + $tm
$copytab = "select * into " + $tableName + " from Model"
invoke-SqlCmd -ConnectionString $tstr -Query $copytab 

දැන් අපට එය භාවිතයෙන් අපගේ හෝඩුවාවක් ලිවිය හැකිය දත්ත.SqlClient.SqlBulkCopy - මම දැනටමත් ඉහත උදාහරණයක් ලබා දී ඇත. ඔව්, TextData හි නියතයන් වසං කිරීම ද හොඳ ය:

# mask data
foreach ($Row in $Result)
{ 
  $v = $Row["TextData"]
  $v = $v -replace "'([^']{2,})'", "'str'" -replace "[0-9][0-9]+", '999'
  $Row["TextData"] = $v
}

අපි අක්ෂර එකකට වඩා දිග සංඛ්‍යා 999 සමඟ ප්‍රතිස්ථාපනය කරන අතර, අපි එක් අක්ෂරයකට වඩා දිග නූල් 'str' සමඟ ප්‍රතිස්ථාපනය කරමු. 0 සිට 9 දක්වා සංඛ්‍යා බොහෝ විට කොඩි ලෙස භාවිතා වන අතර, අපි ඒවා ස්පර්ශ නොකරමු, එසේම හිස් සහ තනි අක්ෂර නූල් - 'Y', 'N', ආදිය බොහෝ විට ඒවා අතර දක්නට ලැබේ.

අපි අපේ ජීවිතයට යම් වර්ණයක් එකතු කරමු (තදින් 18+)

වගු තුළ, ඔබ බොහෝ විට අවධානය යොමු කළ යුතු සෛල ඉස්මතු කිරීමට අවශ්ය වේ. උදාහරණයක් ලෙස, FAILS, ඉහළ මට්ටමේ ඛණ්ඩනය, ආදිය. ඇත්ත වශයෙන්ම, මෙය හිස් SQL වලින් කළ හැකිය, PRINT භාවිතයෙන් HTML ජනනය කිරීම සහ ජෙන්කින්ස් හි ගොනු වර්ගය HTML වෙත සැකසීම:

declare @body varchar(max), @chunk varchar(max)
set @body='<font face="Lucida Console" size="3">'
set @body=@body+'<b>Server name: '+@@servername+'</b><br>'
set @body=@body+'<br><br>'
set @body=@body+'<table><tr><th>Job</th><th>Last Run</th><th>Avg Duration, sec</th><th>Last Run, Sec</th><th>Last Status</th></tr>'
print @body

DECLARE tab CURSOR FOR SELECT '<tr><td>'+name+'</td><td>'+
  LastRun+'</td><td>'+
  convert(varchar,AvgDuration)+'</td><td>'+
  convert(varchar,LastDuration)+'</td><td>'+
    case when LastStatus<>'Succeeded' then '<font color="red">' else '' end+
      LastStatus+
      case when LastStatus<>'Succeeded' then '</font>' else '' end+
     +'</td><td>'
  from #j2
OPEN tab;  
FETCH NEXT FROM tab into @chunk
WHILE @@FETCH_STATUS = 0  
BEGIN
  print @chunk
  FETCH NEXT FROM tab into @chunk;  
END  
CLOSE tab;  
DEALLOCATE tab;
print '</table>'

මම එවැනි කේතයක් ලිව්වේ ඇයි?

නමුත් ඊට වඩා ලස්සන විසඳුමක් තිබේ. HTML වෙත පරිවර්තනය කරන්න සෛල වර්ණ ගැන්වීමට අපට ඉඩ නොදේ, නමුත් ඇත්තෙන් පසුව අපට එය කළ හැකිය. උදාහරණයක් ලෙස, අපට ඛණ්ඩන මට්ටම 80 ට වැඩි සහ 90 ට වැඩි සෛල තෝරා ගැනීමට අවශ්‍යයි. අපි මෝස්තර එකතු කරමු:

<style>
.SQLmarkup-red { color: red; background-color: yellow; }
.SQLmarkup-yellow { color: black; background-color: #FFFFE0; }
.SQLmarkup-default { color: black; background-color: white; }
</style>

විමසුමේදීම අපි ව්යාජ තීරුවක් එකතු කරන්නෙමු වහාම පෙර අපට වර්ණ ගැන්වීමට අවශ්‍ය තීරුව. තීරුව හැඳින්විය යුතුය SQLmarkup-යමක්:

case  
  when ps.avg_fragmentation_in_percent>=90.0 then 'SQLmarkup-red'
  when ps.avg_fragmentation_in_percent>=80.0 then 'SQLmarkup-yellow'
  else 'SQLmarkup-default' 
  end as [SQLmarkup-1], 
ps.avg_fragmentation_in_percent, 

දැන්, Powershell මගින් ජනනය කරන ලද HTML ලැබුණු පසු, අපි ශීර්ෂයෙන් ව්‍යාජ තීරුව ඉවත් කර, දත්තවල සිරුරේ අපි තීරුවේ සිට ශෛලියට අගය මාරු කරන්නෙමු. මෙය සිදු කරනු ලබන්නේ ආදේශන දෙකකින් පමණි:

$html = $html `
  -replace "<th>SQLmarkup[^<]*</th>", "" `
  -replace "<td>SQLmarkup-(.+?)</td><td>",'<td class="SQLmarkup-$1">'

ප්රතිඵලය:


එය අලංකාර නොවේද? නැතත්, මෙම වර්ණ ගැන්වීම මට යමක් මතක් කර දෙයි


මූලාශ්රය: www.habr.com