How TeamCity Shines for You, Webinar Recording

The recording of our May 26th webinar with Wes Higbee, How TeamCity Shines for You, is available on JetBrains YouTube channel.

In this webinar Wes goes over some of the outstanding features of TeamCity which make development and delivery of software a pleasure. The webinar was divided into three main themes:

  • Testing and Visual Studio IDE Integration
  • IntelliJ TeamCity IDE plugin
  • Pipelines / Build Chains

Below is the precise timeline of the webinar and select Q&A.

Continue reading

Posted in Blogroll, Features, Webinar | Comments Off

High Time to Enter TeamCity Plugin Contest

Dear readers!

A little over a month ago we challenged our developers community to join the TeamCity plugin contest and create new plugins for TeamCity that would not only help others, but also entitle every plugin creator to 1 personal product license, and the winners – to really cool prizes from JetBrains!

We’d like to thank all the amazing developers of our community who stepped up and sent us their plugins – we received some really interesting work!

Dear participants, don’t hesitate to brag about your submissions – tweet about your success adding a link to your plugin with the #TeamCityContest hashtag and we’ll be happy to retweet your plugin information so all our subscribers can look at your plugin and give you feedback! There is still a chance to improve plugins by the end of the submission time.

We have been working hard to make it easy for anyone to get started creating a plugin for TeamCity, so check out our Getting Started guide and get your questions answered in the dedicated section of our documentation.

There are endless possibilities for TeamCity plugins: you are welcome to take a look at the plugins that already exist today, they may be a source of inspiration. Besides, our issue tracker will surely yield a few ideas to get you started.

We thought we’d give you a few pointers when it comes to our judges’ expectations, so we approached Paul Stack, Laurent Kempe, Wes Higbee and our team members with a small interview asking what plugins they’d like to see. There is an opinion that TeamCity could benefit from more plugins on the deployment side. Another idea for you – a plugin which would integrate TeamCity with Docker and Docker Hub – see if you can meet this challenge! As for criteria for a successful plugin, ease of configuration and use has been named as one of them; its potential to make the user more productive in comparison with the current situation is definitely taken into account by our judges.

We are really excited about your innovative ideas, so please keep the plugins coming! Remember, all submissions must be made by June 15th, 2015 at 11:59 AM EDT. A valid TeamCity plugin adds functionality that does not exist in TeamCity or in an existing plugin that has been published. All plugins will be reviewed and their functionality, code quality, and reliability will be considered!

Happy building and the best of luck!

Posted in Blogroll, Contest, Features, FYI, News & Events, Uncategorized | 1 Comment

How TeamCity Shines for You, May 26th Webinar

Join us Tuesday, May 26th, 16:00 – 17:00 CEST (10:00 – 11:00 AM EDT) for our free live webinar, How TeamCity Shines for You with Wes Higbee.

Developing software is hard work, the last thing you need are tools that are difficult to work with to deliver your software. Join this webinar to find out about the TeamCity features that make developing and delivering software a pleasure.

We’ll cover the following features and more: bringing information right where you need it with IDE plugins, what comes out of the box with TeamCity, build chains to orchestrate your deployment pipelines, how to setup consistent notifications and how to keep configuration stored in version control.

Space is limited, please register now. There will be an opportunity to ask questions during the webinar.

About the presenter:

Wes McClureWes Higbee is passionate about helping companies achieve remarkable results with technology and software. He’s had extensive experience developing software and working with teams to improve how software is developed to meet business objectives. Wes launched Full City Tech to leverage his expertise to help companies rapidly deliver high quality software to delight customers. He has a strong background in using Continuous Integration with TeamCity to bring quality to the table.
Posted in Blogroll, Features, Partner, Webinar | Comments Off

TeamCity 9.1 EAP1 is out

Greetings, everyone!

Just in case you haven’t heard yet, TeamCity 9.1 is planned to see the light in about a couple of months, and today you can take a sneak peek of our progress with the new version: TeamCity 9.1 EAP1 is officially available!

One of the noticeable improvements in this build 35957 is the ability to store versioned project settings in Perforce and Subversion version control systems.

Another important feature that administrators will find handy is the ability to override the default alphabetical order and apply custom reordering to projects, subprojects, and build configurations of a project to make it default for the other team members.

Automatic build triggering has been refined with the enhancements in the Schedule trigger, which can now watch builds in other build configurations and trigger a build on changes in those builds.

With all new features and over 100 bugfixes, we expect this EAP release to improve TeamCity user experience, so get the new EAP build and share your feedback on our forum or report any bugs directly to the tracker.

Please remember that TeamCity 9.1 is still under development, so just like with any EAP, make sure you install it on a trial server first, since it changes the data format.

Happy building!

Posted in Bugfix, EAP, Features, FYI, News & Events | 1 Comment

TeamCity 9.0.4 bugfix is released

We’ve just released TeamCity 9.0.4: an update addressing 55 issues and improvements related to different functionality.

This release comes bundled with ReSharper Command Line Tools 9.1, which should fix the regression with .Net code analysis which surfaced after upgrade to TeamCity 9.0.3. Among other enhancements is support for Maven 3.3.1 and Gradle 2.4.

This is mostly a bugfix release, and upgrade is recommended: see our release notes for the full list of fixes and do not think too long before upgrading!

Download TeamCity 9.0.4 and check the upgrade instructions. As usual, this TeamCity version uses the same data format as any of the 9.0. releases; so should you need to downgrade, it’s a piece of cake!

We’ve been focusing on the TeamCity 9.1 lately and will be rolling out the EAP soon, so stay tuned!

Happy upgrading and building!

Posted in Bugfix, EAP, FYI, News & Events, Tips&Tricks, Uncategorized | Comments Off

2015 TeamCity Plugin Contest: Don’t Hesitate to Participate

We are announcing the first ever TeamCity Plugin Contest! Whether you are new to TeamCity or a devoted fan, we believe you should be limited by your creativity alone and not by the tool you use, so how would you like to win up to $7000 in Amazon certificates, enterprise licenses for team tools, personal licenses for IDEs, or even a trip to one of JetBrains’ offices?

It’s easy – develop your own plugin to TeamCity! TeamCity has a flexible architecture which can be extended in a number of ways (runners for new build tools and testing frameworks, notifiers, etc.) and the contest is straightforward: create an innovative plugin to TeamCity or add some significant features to one of the existing plugins, and take a prize home!

Submissions start today and close at 11:59 AM (EDT) on June 15, 2015! Don’t hesitate to enter: winner or not, everyone who submits a valid plugin gets a free personal license for any JetBrains IDE!

See the full information on the prizes and conditions on our site and register to enter the contest!

The TeamCity documentation provides lots of information to help you write a plugin, and with our Getting Started guide you can create a simple plugin in a matter of minutes!

If you need inspiration, there are also a bunch of possible plugin ideas in our tracker for you.

We are sure you’ll have plenty of feedback while writing your plugin, and you are most welcome to post comments or issues to our forum or issue tracker!

Good luck and happy building!

Posted in Blogroll, Contest, FYI, News & Events | 3 Comments

Case Study: TeamCity in Clueda

This guest post is brought to you by Clueda engineering team.

cluedaClueda is a cognitive computing solutions provider. We extract knowledge and market moving events from infinite amounts of unstructured data in real-time. The Best in Big Data 2013 award-winning technology is based on over 100 man-years of research in systems biology and cognitive computing. The successful implementation of our software helps traders work more efficiently and increase trading profits on a daily basis. Founded in 2012 as spin-off from the elite research institution Helmholtz Zentrum Munich, Clueda currently has 25 employees.

The Pain

Within two years, Clueda has experienced significant growth, both in the size of our engineering team and complexity of our products. While the previously used development infrastructure worked well to build a product that our customers praised, we were looking for tools options that could sustain our growth and maintain our products at a high quality.

In the original small-team workflow, developers built projects on their own machine and manually deployed artifacts to an Artifactory repository. This is simple and straightforward. However, with the number of repositories reaching over 250 at a team size of about 20 developers, keeping track of the status and dependencies of the myriad of experimental and productive projects in development at any point in time became a prime issue.

Best practices suggest a continuous integration workflow: Instead of manually deploying builds to an artifact storage or even testing or productive system, we wanted to automate as many of such error-prone tasks as possible. Ideally, a testing system will always be updated with the most current state of the code in source control. But let’s be humble: an obvious starting point is centralizing compilation, testing and packaging of software artifacts.

Solution Space

There are many tools designed to help in the task of automated building and deploying, the most prominent ones being Jenkins, TeamCity and Bamboo. But before looking at the contenders, we need to identify the key points to be addressed.

Most of our development is JVM-centric, with Scala as the primary programming language. We use git for source control, sbt and Maven as build tools. A good solution would make it easy to run both and report results in a uniform and easily comprehended fashion.

Configuring build processes is not a one-off task. Requirements evolve, new steps are added, configuration changes. With dozens of projects at any one time, it is absolutely necessary that a solution be able to centrally manage build configurations and apply them to multiple projects at once, while still allowing individual projects to adapt and override these settings.

A preliminary survey showed that only the three “big guns” would fit our overall requirement for flexibility and compatibility with all our projects.

Looking at them in detail, we found:

  • Bamboo was a pleasurable experience in regards to usability, but it lacked the key features we needed in the first place.

  • Jenkins certainly has the largest ecosystem and rudimentarily supports sbt as a build tool. There is a Jobs DSL plugin available that may support scripting more complex tasks and some level of abstraction on the build process.

  • TeamCity is the only tool we found that has first-class support for build templates, which were straightforward to setup.


TeamCity quickly turned out to be the option that promised to save the most time. During evaluation, we had direct interaction with TeamCity developers, who were very responsive to our questions. This made the final decision very easy.


After 2 months of using TeamCity productively, we have automated many parts of building and deployment of all active projects. Code quality checks, such as Scalastyle and a self-built configuration verification, were easy to introduce into all configurations and have greatly simplified maintaining and improving our coding standards.

Whenever a developer pushes changes to their git repository, TeamCity pulls these changes and triggers the build process. After a successful build, which includes compiling, tests and code quality checks, development artifacts are deployed directly to Artifactory. Release builds are triggered manually and run through the sbt-release plugin, which ensures correct versioning and disables use of snapshot artifacts in a release, while TeamCity keeps track of the changes since the last release version. Nightly test runs ensure that our artifacts are always in a compatible state.


Because it is simple to improve the process, we are not content with the status quo. There’s plenty of ideas on how to improve processes. Here are some of our ideas.


TeamCity already enables a direct view on the documentation generated for each build. We will consolidate generated docs and automatically deploy them to a searchable website.

Dependency Management

Dependency Hell is cause for a large share of the swearwords uttered in software development offices. Centrally detecting such errors should lead to a more tranquil environment.


Continuous integration is seen by some as an old hat. Continuous deployment involves bringing the code from source control to production fully automated. TeamCity does not offer specific features for this, but it allows arbitrary deploy processes to be integrated into the environment, thus simplifying tracking the success of such operations.


Visualization can improve team engagement. There are a variety of plugins available for this task. Unfortunetely, none of them really fit what we had in mind. Luckily, TeamCity offers an extensive REST API

Posted in Blogroll, Case study, Features, FYI, Guest post, News & Events, Partner | Comments Off

TeamCity 9.0.3 is available

Please welcome TeamCity 9.0.3 (build #32334) with more than 150 bugfixes and improvements.

We added a couple of new options to projects import to control how import of users and groups should be performed in case of conflicts.

With this release we bundled new version of ReSharper Command Line Tools. This should fix a number of issues found in .NET Inspections runner. TeamCity 9.0.3 also adds support for NUnit 2.6.4.

Versioned settings feature have got several important stability fixes. Also a number of fixes have been done in WebSockets support. Finally, we fixed several performance problems mainly affecting large installations. See our release notes for the full list.

Given the number of fixed problems in this release, upgrade to 9.0.3 is highly recommended. Please download the build and follow the upgrade instructions. As usual upgrade to this bugfix release from another 9.0 version does not change data format, so in case of any problems downgrade will be simple.

As the team is switching their efforts to TeamCity 9.1 (which is planned for the end of Spring), this is probably the last 9.0.x bugfix release with so many fixes. We hope to publish the first 9.1 EAP build in a matter of weeks.

Stay tuned and happy building!

Posted in Bugfix, Uncategorized | Comments Off

Setting up TeamCity as Symbol and Source Server

When debugging applications with various Microsoft tools, you need to have symbol and source information, provided by the Microsoft Symbol Server and Source Server technology.

It’s been some time since we created a plugin which allows using TeamCity as a symbol and source server, and now, after some bug-fixing has been done, we decided we are ready to announce it officially.

So please welcome the TeamCity Symbol Server plugin! With just a few mouse clicks you can set up TeamCity to index the .PDB files and binaries for all your .Net applications and, once the plugin is enabled, you can easily debug applications or analyse crash dumps: your debugger will be able to automatically retrieve the required symbol files and to download the sources of the appropriate version for shared libraries referenced by you application, if, say, these modules are developed by a different team in your company and shared between several projects.


To set up TeamCity as a Symbol and Source server, we assume you have the following:

  1. TeamCity server 8.0.3 or later with a project and build configuration to build your application.
  2. Debugging Tools for Windows on the agent machine(s) where your application is built (can be installed using this link).

Now all you need to do is enable the TeamCity Symbol Server plugin in TeamCity and set a number of options in your debugger.

Download and install the plugin

  1. Since the plugin is not bundled with TeamCity, download the required version from here and install the plugin as usual.
  2. Now enable the symbol server on the Administration| Integrations| Symbol Server page. You will see that it is referenced by the following URL < TEAMCITY_SERVER_URL>/app/symbols. This is the URL to be used in the Visual Studio or windbg settings.

The permissions required to access symbols and sources via the TeamCity server are default for the project developer role, and the indexed data can be accessed in both public (not requiring authorization) and authorized modes.

Tune the build configuration settings

Next we need to add the Symbol Files indexer build feature to our build configuration settings:


Once you add the feature and save the settings, all PDB files published as build artifacts of this configuration and all related sources will be indexed.

Next let’s take a look at the files we are publishing as build artifacts. In this setup we are building an application referencing a dll and we are publishing a .zip archive which includes the application along with the PDB file and the library:


The plugin can handle the PDB files published separately or packed using the TeamCity artifact publishing rules.

That’s it! Now we can run the build. When the build is finished, the build log shows that source indexing was performed and symbols files signatures were collected and written to an xml file:

The file containing symbol files signatures is published internally and is available in the TeamCity internal artifacts under .teamcity\symbols:


Set the debugger options

Now we need to set a few options in the debugger, Visual Studio in this case:

  1. In the Debug menu, select Options and Settings, in the General section uncheck the default Enable Just My Code and Require source files to exactly match the original version options.
    If you do not have the source code on the local machine or the .pdb file does not match the source code, you can use Source Server to find and download the sources: select Enable source server support and check all the options in that section.VSDebugOptions
  2. During a debugging session in Visual Studio, the debugger automatically loads symbol files that are located in the project directory. To specify TeamCity as a symbol server, select the Symbols section on the left and add the TeamCity symbol server URL ( from the Administration| Integrations| Symbol Server page) to the list of symbol file locations.
    On the Symbols page you can also filter out or specify modules that you want the debugger to automatically load symbols for. These settings can be changed manually when you are debugging.VSSymbolSources
  3. Save your changes.

Now your debugger will load the required symbol and source files from TeamCity enabling you to successfully debug applications and crash dumps!

Try out the TeamCity Symbol Server plugin and let us know what you think!

Happy building and debugging!

Posted in Features, FYI, How-To's, News & Events, Tips&Tricks | Comments Off

Dashboarding with TeamCity

Data visualization has never been so popular as it is today. The human eye and brain are so powerful that they catch information and detect patterns on-the-fly: just in a blink of an eye you can extract a lot of information and make a decision on what to do next. Dashboards are everywhere for business and fun.

Here at JetBrains we have a ‘KitchenTV’ project – a set of pages rotated on several large screens in the office. In the beginning they were charts with data from our issue tracker, lists of tweets, nice widgets with weather information for all JetBrains office locations. Then the real-time visualization of the daily purchases was added – every time one of our products is bought, a ball of the corresponding color falls down forming several nice different-sized and -colored mountains at the end of the day, which are a lot of fun to look at.

Now we decided to contribute to this project and add some useful information from our internal TeamCity server for the common benefit, and we thought you might be interested too, so here it is.

At the moment we have two widgets. The first one shows the list of assigned investigations – so your colleagues can see your involvement in problem digging and fixing.

Screen Shot 2015-02-09 at 14.35.37

The next widget displays the list of most recent VCS commits. It means that anyone can quickly understand what their teammates are working on.

Screen Shot 2015-02-13 at 14.45.16

The technologies behind these widgets are simple: REST + AngularJS, so it is basically the static content. If you want to use the widgets with your own TeamCity, you can choose one of two options:

  • install the TeamCity.Widgets plugin to your TeamCity or

  • install the TeamCity.StaticUIExtention plugin and add widgets content as a folder under the StaticUIExtention config root. Once you restart your server to make TeamCity.StaticUIExtention work, you can update the static content without further restarts.

The code of the plugin is open and available on GitHub.

Your feedback is welcome: in the comments here or in our issue tracker.

Enjoy the widgets and happy building!

Posted in Uncategorized | 3 Comments