tim laqua dot com » powershell

Monitoring and Starting Data Collector Sets with Powershell

Tim — Thu, 20 Oct 2011 01:33:24 +0000

I figure it's about time I posted an update to my previous post on Monitoring, Starting, and Stopping Perfmon Performance Counter Logs using VBScript. In the years since that post, a few operating systems came out and many much more interesting languages happened by. So this update is in Powershell. You could do it in pretty much any language, but Powershell seems to be my weapon of choice lately.

The basic premise here is that we want our Data Collector Sets to always be running. Seems like a reasonable request, but for various reasons, Data Collector Sets just... stop. This script should be run regularly (every 5 minutes?) to ensure that the sets keep collecting data. In the event that the script finds some work to do, it will send you an email.

#======= START Config ========
$emailServer = "1.2.3.4";
$fromAddress = "you@yourcompany.com";
$toAddress = "you@yourcompany.com";
$ignorePattern = '^(RandomCollectorSet|OSTest)$';
#======== END Config =========
 
$ErrorActionPreference = "SilentlyContinue"
$serverName = Get-Content env:computername;
$emailBody = ""
 
$collectors = New-Object -COM Pla.DataCollectorSetCollection;
$collectors.GetDataCollectorSets($null, "Service\*");
$collectors._NewEnum | ?{$_.Status -ne 1 -and $_.Name -notmatch $ignorePattern} | %{
	$_.Start($true);
	if($_.Status -eq 1) {
		$emailBody += "Started $($_.Name)`n"
	} else {
		$emailBody += "Failed to start $($_.Name)`n"
	}
};
 
if($emailBody -ne "") {
  $smtp = new-object Net.Mail.SmtpClient($emailServer);
  $smtp.Send(
    "$serverName <$fromAddress>", 
    $toAddress, 
    "Started Data Collector Set(s)", 
    $emailBody);
}

If you want the script to keep any of the non-user created collectors running, modify the namespace parameter of the GetDataCollectorSets method call.

Revisiting Embedded Text Qualifiers and the SSIS Flat File Connection Manager

Tim — Thu, 09 Jun 2011 01:45:42 +0000

To quickly summarize the problem at hand, the Flat File Connection Manager doesn't support embedded Text Qualifiers. The reason this is a big issue is because the most commonly used text qualifier is a double quote (") and that's also a commonly used punctuation mark. That means if you have a CSV to import and lines that looks like this:
"one","1","two","2","th""r""ee","3","asdf" """left","right""","mid""dle","w"",tf","w,""tf",",""omg","omg"","

You would expect to import

one	1	two	2	th"r"ee	3	asdf
"left	right"	mid"dle	w",tf	w,"tf	,"omg	omg",

That's not what you get, you get an error. I've seen a few different approaches to working around this known issue:

What I'd like to explore in this post is using regular expressions to transform the entire file in to something that can be natively consumed by SSIS. There are two options for dealing with this:

Tokenizing the quotation marks found within the cells
Change the text qualifier

I chose to change the text qualifier because SSIS natively supports multiple character text qualifiers. This will allow me to pick something ridiculous that is incredibly unlikely to appear in the data naturally. Changing the text qualifier also means we won't have to add any extra transformations as we would if we tokenized the embeded quotation marks (to turn them back in to quotation marks).

Let's start out with the file we're importing so we have some text to test against (C:\SSISTextQualifier\Input.csv)

"one","1","two","2","th""r""ee","3","asdf"
"""left","right""","mid""dle","w"",tf","w,""tf",",""omg","omg"","

Now let's iron out the regular expression we're going to need.

We'll start out with grabbing a bunch of stuff between two double-quotes

Ok, we don't just want a bunch of stuff - we want the stuff between each set of quotation marks - we make the * quantifier lazy with a question mark

Better... but that th""r""ee is clearly wrong... we have to stop the final quotation mark from matching properly escaped quotation marks. We can do that with a negative lookahead:

That's different - notice that now properly escaped quotation marks aren't abnormally terminating the column match anymore, now they're just acting like normal characters. We have to make a special exception for escaped quotation marks. Those have to essentially count as a single character:

Perfect - Now we can replace the text qualifiers with something awesome like |~| since we have matched the column content safely

Now that we have our regex, we just have to decide how to execute.

Plan A: SSIS Script Task

Create a new package with a single script task in it

Now edit the script (C#) and add the following up by the existing using statements:

using System.IO;
using System.RegularExpressions;

Modify the Main method to look something like this (depending on your paths):

        public void Main()
        {
            StreamReader sr = new System.IO.StreamReader(@"C:\SSISTextQualifier\Input.csv");
            string allText = sr.ReadToEnd();
            sr.Close();
            StreamWriter sw = new StreamWriter(@"C:\SSISTextQualifier\InputCleaned.csv");
            sw.Write(
                    Regex.Replace(
                        allText, 
                        @"""((?:""""|.)*?)""(?!"")", 
                        @"|~|$1|~|"
                    ).Replace("\"\"", "\"")
            );
            sw.Close();
            Dts.TaskResult = (int)ScriptResults.Success;
        }

Then run that task and you will have a new file called C:\SSISTextQualifier\InputCleaned.csv that's text qualified by |~| and the escaped double quotes have been replaced with a single double quote.

Plan B: Powershell

Since we often call SSIS packages from the SQL Server Agent, we can easily add a Powershell step right before the SSIS package to copy and cleanse our file. If that's the route you choose, your powershell step will look something like this:

gc C:\SSISTextQualifier\Input.csv | 
% {$_ -replace "`"((?:`"`"|.)*?)`"(?!`")", "|~|`$1|~|" -replace "`"`"", "`""} | 
sc C:\SSISTextQualifier\InputCleaned2.csv

Final Steps

However you got your data in to a new file (C:\SSISTextQualifier\InputCleaned.csv in my case) with a new text qualifier, you still have to then import the file. This is done using our old friend the Flat File Connection Manager with the source being the newly minted clean file and with our new text qualifier set as |~|

And that's pretty much it:

Conclusion

Personally, I think the Powershell plan is the cleanest and easiest to implement. The code isn't hidden away in a script task, and it looks cool. Doing it this way allows us to kind of abstract this "file fixing" from the SSIS data flows and let them do what they do best.

Restarting Automatic Services using Powershell

Tim — Fri, 15 Apr 2011 19:53:24 +0000

What? Why would you need to restart an automatic service? Because they die sometimes - there's probably some very good reasons for this, but I don't know them. What I do know is they die from time to time and don't come back. Sometimes they never get around to starting after a reboot.

I run the following Powershell script every 5 minutes to restart the ones that got tired:

#======= START Config ========
$emailServer = "1.2.3.4";
$fromAddress = "you@yourcompany.com";
$toAddress = "you@yourcompany.com";
$ignorePattern = '^(ShellHWDetection|MMCSS|sppsvc|clr_optimization.*)$';
#======== END Config =========
 
Get-WmiObject Win32_Service | 
? { 
  $_.StartMode -eq 'Auto' `
  -and $_.State -ne 'Running' `
  -and $_.Name -notmatch $ignorePattern
} | 
% { 
  $svcName = $_.Name; 
  $serverName = Get-Content env:computername;
  Start-Service -Name $_.Name -EA SilentlyContinue; 
  $smtp = new-object Net.Mail.SmtpClient($emailServer);
  $smtp.Send(
    "$serverName <$fromAddress>", 
    $toAddress, 
    "Started service ""$svcName""", 
    "Started service ""$svcName"" on $serverName.")
}

$ignorePattern is a regular expression for identifying what services to ignore (so services that you don't care to try and restart).

Dealing With Long Running SSAS Queries using Powershell

Tim — Fri, 15 Apr 2011 17:27:06 +0000

So, your Analysis Services instance keeps eating all the memory on your server despite proper memory configuration? This happens when queries get too big for their britches - SSAS memory limits are basically soft limits. Whatever an active query requires in terms of resources, SSAS will attempt to provide it. Even if it has to page the entire operating system out to disk to do it. You can mitigate this with good cube design, better aggregations, user training, etc - but it's bound to happen. When your cube gets big enough, one of your users will blow the entire server up.

First things fist - the original thought for this came form Chris Webb's article, Killing sessions automatically with SSIS. Now on to my solution - which is basically identical in theory, just implemented in PowerShell with an email notification at the end.

Create a SQL Agent job with a PowerShell step that runs the following script and schedule it to run every 30 seconds

#======= START Config ========
$asInstance = "ssasinstance";
$emailServer = "1.2.3.4";
$fromAddress = "you@yourcompany.com";
$toAddress = "you@yourcompany.com";
$maxQueryElapsedMS = 30000;
$bypassUserPattern = "yourusername";
#======== END Config =========
 
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.AnalysisServices.Xmla") ;
[Microsoft.AnalysisServices.xmla.xmlaclient]$client = 
  new-object Microsoft.AnalysisServices.Xmla.XmlaClient ;
$client.Connect($asInstance) ;
$commands = "";
$sessions = "";
$client.Discover("DISCOVER_COMMANDS", "", "", [ref] $commands, 0, 0, 1) ;
$client.Discover("DISCOVER_SESSIONS", "", "", [ref] $sessions, 0, 0, 1) ;
$sessionsXml = [xml]$sessions;
$sessionsRows = $sessionsXml.return.root.row;
$commandsXml = [xml]$commands;
$commandsRows = $commandsXml.return.root.row;
 
foreach ($row in $commandsRows) 
{
  if([int]$row.COMMAND_ELAPSED_TIME_MS -gt $maxQueryElapsedMS -and $row.COMMAND_TEXT -match "SELECT") 
  {
    $spid = $row.SESSION_SPID;
    $commandText = $row.COMMAND_TEXT;
    $session = ($sessionsRows | ? { [int]$_.SESSION_SPID -eq [int]$spid });
    $user = $session.SESSION_USER_NAME;
    $db = $session.SESSION_CURRENT_DATABASE;
    if($user -notmatch $bypassUserPattern) {
      $cancelXMLA = ""http://schemas.microsoft.com/analysisservices/2003/engine"">$spid";
      $client.Send($cancelXMLA, $null);
      $smtp = new-object Net.Mail.SmtpClient($emailServer); 
      $smtp.Send(
        "$asInstance <$fromAddress>", 
        $toAddress, 
        "Killed SPID: $spid", 
        "SPID $spid was detected as the owner of a long running query and was killed.`r`nUser: $user`r`nDB: $db`r`n`r`n$commandText"
      );
    }
  }
}
$client.Disconnect();

Great. Now sessions with active queries (aka "commands" with the word "SELECT" in them) taking over 30 seconds will be cancelled and we'll get an email w/ the query so we can debug! So you wake up the next morning and Japan called - a bunch of their pivots errored out last night and they're not happy. Hmm... Pry should have warned someone before we started cancelling queries...

Phase 2: Turn off the query/session killer, turn on the logging

Create the Log table:

CREATE TABLE [dbo].[LongRunningMDXQueryLog](
	[SPID] [INT] NOT NULL,
	[CommandStartTime] [DATETIME] NOT NULL,
	[Username] [NVARCHAR](255) NULL,
	[DATABASE] [NVARCHAR](255) NULL,
	[ElapsedTimeMS] [INT] NOT NULL,
	[CommandText] [NVARCHAR](MAX) NULL
)

Create the MERGE proc to handle log entries

CREATE PROCEDURE [dbo].[LongRunningMDXQueryLog_Merge]
	 @SPID INT
	,@CommandStartTime DATETIME
	,@Username VARCHAR(255)
	,@DATABASE VARCHAR(255)
	,@ElapsedTimeMS INT
	,@CommandText NVARCHAR(MAX)
AS
BEGIN
	;MERGE LongRunningMDXQueryLog a USING
	(
		SELECT
			 @SPID 
			,CAST(@CommandStartTime AS DATETIME)
			,@Username 
			,@DATABASE
			,@ElapsedTimeMS 
			,@CommandText 
	) b
	([SPID]
	,[CommandStartTime]
	,[Username]
	,[DATABASE]
	,[ElapsedTimeMS]
	,[CommandText])
	ON
	(a.[SPID] = b.[SPID]
	 AND a.[CommandStartTime] = b.[CommandStartTime]
	 AND a.[Username] = b.[Username]
	 AND a.[DATABASE] = b.[DATABASE]
	 AND a.[CommandText] = b.[CommandText])
	WHEN NOT MATCHED THEN
	INSERT
			   ([SPID]
			   ,[CommandStartTime]
			   ,[Username]
			   ,[DATABASE]
			   ,[ElapsedTimeMS]
			   ,[CommandText])
		 VALUES
			   ([SPID]
			   ,[CommandStartTime]
			   ,[Username]
			   ,[DATABASE]
			   ,[ElapsedTimeMS]
			   ,[CommandText])
	WHEN MATCHED THEN
	UPDATE
	SET
		[ElapsedTimeMS] = b.[ElapsedTimeMS]
	;
END

Create a job to run the following Powershell script every 30 seconds:

#======= START Config ========
$asInstance = "ssasinstance";
$logConnectionString = 
  "server=sqlserverinstance;" + 
  "database=databaseYouCreatedTheLogTableIn;" + 
  "trusted_connection=true;";
$maxQueryElapsedMS = 30000;
#======== END Config =========
 
[System.Reflection.Assembly]::LoadWithPartialName("Microsoft.AnalysisServices.Xmla") ;
[Microsoft.AnalysisServices.xmla.xmlaclient]$client = 
  new-object Microsoft.AnalysisServices.Xmla.XmlaClient ;
$client.Connect($asInstance) ;
$commands = "";
$sessions = "";
$client.Discover("DISCOVER_COMMANDS", "", "", [ref] $commands, 0, 0, 1) ;
$client.Discover("DISCOVER_SESSIONS", "", "", [ref] $sessions, 0, 0, 1) ;
$sessionsXml = [xml]$sessions;
$sessionsRows = $sessionsXml.return.root.row;
$commandsXml = [xml]$commands;
$commandsRows = $commandsXml.return.root.row;
 
foreach ($row in $commandsRows) 
{
  $elapsedTimeMS = $row.COMMAND_ELAPSED_TIME_MS;
  if([int]$elapsedTimeMS -gt $maxQueryElapsedMS -and $row.COMMAND_TEXT -match "SELECT") 
  {
    $spid = $row.SESSION_SPID;
    $commandText = $row.COMMAND_TEXT -replace "'", "''";
    $session = ($sessionsRows | ? { [int]$_.SESSION_SPID -eq [int]$spid });
    $user = $session.SESSION_USER_NAME;
    $db = $session.SESSION_CURRENT_DATABASE;
    $commandStartTime = 
      ([string]$row.COMMAND_START_TIME -replace '\.\d+$', '' -replace 'T', ' ');
    $sqlConn = New-Object System.Data.SQLClient.SQLConnection($logConnectionString);
    $sqlConn.Open();
    $sqlCommand = New-Object System.Data.SQLClient.SQLCommand;
    $sqlCommand.Connection = $sqlConn;
    $sqlCommand.CommandText = 
      "EXEC LongRunningMDXQueryLog_Merge " + 
        "$spid, " +
        "'$commandStartTime', " + 
        "'$user', " + 
        "'$db', " + 
        "$elapsedTimeMS, " + 
        "'$commandText'";
    $sqlCommand.ExecuteNonQuery()
    $sqlConn.Close();
  }
}
$client.Disconnect();

And now you have a table filled with queries that will be cancelled (read: "error out") when the query killing job is running. So now you fix it:

locate these users
figure out what crazy pivots are causing the problem
Refactor the pivot OR determine what dimensionality is missing from the cube

Once you go a day or so w/ a quiet log table, you can turn on the query killer and go on your merry way. It's been suggested that we should send the user an email - let them know that it wasn't an error... that we cancelled their query. Maybe - but honestly, you should probably email or call them personally to hash it out. If it happens once, chalk it up to happenstance. If it continues to occur, it's time for some user training and/or requirements gathering.

The real problem is that most end users don't know that 30 seconds is ridiculously long - they shouldn't have to wait that long. Not only does it hurt them, it hurts others using the system as well.

UPDATE: You may want to, at some point, actually view one of these monster queries to see what on earth they were querying for. Over a certain size, getting it out of SSMS can be pretty troublesome - A query similar to the following should do the trick:

DECLARE @SQLcommand VARCHAR(4000)
SET @SQLcommand = 'bcp "select CommandText 
from Database.dbo.LongRunningMDXQueryLog 
where SPID = 511519" 
queryout "c:\output.dtsx" -T -c'
 
EXEC xp_cmdshell @SQLcommand

VersionOne Nag: Reminding Us To Burn Our Points

Tim — Fri, 12 Feb 2010 04:19:41 +0000

You'll forget - we all do. After a hard day of work, the last thing that pops in to your head is "hey, I should go update this story in VersionOne before I go home." Oh no, the only thing you're thinking about is how bad traffic will be, what you're having for dinner, your trip to Seattle, which bar has the best drink specials tonight, etc. So accepting that we forget to burn points now and then, why don't we just make a script to remind us? While you're at it, might as well add a reminder for when you accidentally close a story without setting the ToDo points to zero.

Luckily, since you obviously use VersionOne (because it's the gold standard), there's an API for that:

Note: The following script will request your VersionOne username and password via Read-Host - if you want this to run every day at 4pm, you need to embed your username and password somewhere (securestring support in powershell is helpful, but still - nothing's perfect in this scenario unless you can use LDAP auth)

PowerShell script: v1Nag.ps1

$emailFrom = "whoever.replies@shouldgoto.com"
$emailSMTPServer = "your.smtpserver.com"
$teamName = "Your Team Name in VersionOne"
 
$url = "https://wwwXXX.v1host.com/yourhostingid/"
$username = Read-Host "User"
$password = Read-Host -assecurestring "Password"
 
$password = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto([System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($password))
 
$apiClient = resolve-path "versionone.sdk.apiclient.dll"
$objectModel = resolve-path "versionone.sdk.objectmodel.dll"
[Reflection.Assembly]::LoadFrom($apiClient) > $NULL
[Reflection.Assembly]::LoadFrom($objectModel) > $NULL
$v1 = new-object VersionOne.SDK.ObjectModel.V1Instance( $url, $username, $password)
$v1.Validate()
 
$sf = new-object VersionOne.SDK.ObjectModel.Filters.StoryFilter
$v1.Get.Iterations($null) | ? { $_.IsActive } | % { $sf.Iteration.Add($_) }
$v1.Get.Teams($null) | ? { $_.Name -match $teamName } | % { $sf.Team.Add($_) } 
$stories = $v1.Get.Stories($sf)
 
$memberDetail = @{}
 
foreach ($story in $stories) {
	foreach ($owner in $story.Owners) {
		if (!$memberDetail.Contains($owner.ID)) { 		
			$md = New-Object PSObject | select Email, DetailEstimate, ToDo, Effort, EffortToday, DoneWithToDo
			$md.Email = $owner.Email;
			$md.DetailEstimate = 0;
			$md.ToDo = 0;
			$md.Effort = 0;
			$md.EffortToday = 0;
			$md.DoneWithToDo = @()
			$memberDetail.Add($owner.ID, $md)
		}
 
		$memberDetail[$owner.ID].ToDo += $story.ToDo;
		$memberDetail[$owner.ID].DetailEstimate += $story.DetailEstimate;
 
		if ($story.ToDo -ne 0 -and $story.Status.CurrentValue -eq "Done") {
			$memberDetail[$owner.ID].DoneWithToDo += $story;
		}
 
		foreach ($effortRecord in $story.GetEffortRecords($null)) {
			$memberDetail[$owner.ID].Effort += $effortRecord.Value;
			if ($effortRecord.CreateDate -ge [DateTime]::Today) {
				$memberDetail[$owner.ID].EffortToday += $effortRecord.Value;
			}
		}
	}
}
 
$smtp = new-object Net.Mail.SmtpClient($emailSMTPServer)
 
$memberDetail.Values | ?{ $_.EffortToday -eq 0 -and $_.ToDo -gt 0} | % { $smtp.Send($emailFrom, $_.Email, "V1 Nag: No Points Burned Down Today", "Please make sure you have recorded any effort completed on your stories for the day.") }
 
$memberDetail.Values | ?{ $_.DoneWithToDo.Count -gt 0 } | % { $smtp.Send($emailFrom, $_.Email, "V1 Nag: Story Marked As Done With ToDo Balance", "Please make sure you have zero'd out ToDo on your Completed/Done stories.") }

You'll need to download the .NET SDK and build the requisite DLLs from:
http://community.versionone.com/Downloads/default.aspx